feat(ruff): enable mccabe and pep8-naming rules (#22396)

.ruff.toml

@@ -172,13 +172,15 @@ exclude = [
 [lint]
 select = [
   "AIR",  # Airflow
+  "C90",  # mccabe
   "COM",  # flake8-commas
   "E",    # pycodestyle
   "F",    # Pyflakes
   "FAST", # FastAPI
   "FLY",  # flynt
   "FURB", # Refurb
   "I",    # isort
+  "N",    # pep8-naming
   "NPY",  # NumPy
   "PERF", # Perflint
   "PGH",  # pygrep-hooks

aerospace/hm-aerosandbox/src/main.py

@@ -124,8 +124,8 @@ def main() -> None:
         align_trailing_vortices_with_wind=False,
     )
     aero = vlm.run()
-    L_over_D = aero["CL"] / aero["CD"]
-    opti.minimize(-L_over_D)
+    l_over_d = aero["CL"] / aero["CD"]
+    opti.minimize(-l_over_d)
     sol = opti.solve()
     best_alpha = sol(alpha)
     logger.info(f"Alpha for max L/D: {best_alpha:.3f} deg")

cloud-platform/aws/amazon-sagemaker/pytorch-mnist/src/models/net.py

@@ -1,4 +1,4 @@
-import torch.nn.functional as F
+import torch.nn.functional as F  # noqa: N812  # noqa: N812
 from torch import nn
 
 

cloud-platform/aws/amazon-sagemaker/pytorch-mnist/src/utils/test.py

@@ -1,7 +1,7 @@
 import logging
 
 import torch
-import torch.nn.functional as F
+import torch.nn.functional as F  # noqa: N812
 import torch.utils.data
 import torch.utils.data.distributed
 

cloud-platform/aws/amazon-sagemaker/pytorch-mnist/src/utils/train.py

@@ -3,7 +3,7 @@
 
 import torch
 import torch.distributed as dist
-import torch.nn.functional as F
+import torch.nn.functional as F  # noqa: N812
 import torch.utils.data
 import torch.utils.data.distributed
 from models.net import Net

data-analytics/hm-networkx/src/main.py

@@ -8,11 +8,11 @@
 
 def create_network() -> nx.Graph:
     # Initialize a new undirected graph
-    G = nx.Graph()
+    graph = nx.Graph()
 
     # Add nodes
     nodes = ["A", "B", "C", "D", "E"]
-    G.add_nodes_from(nodes)
+    graph.add_nodes_from(nodes)
 
     # Add edges with weights
     edges = [
@@ -23,55 +23,55 @@ def create_network() -> nx.Graph:
         ("A", "E", 6),
         ("B", "E", 3),
     ]
-    G.add_weighted_edges_from(edges)
-    return G
+    graph.add_weighted_edges_from(edges)
+    return graph
 
 
-def analyze_network(G: nx.Graph) -> None:
+def analyze_network(graph: nx.Graph) -> None:
     # Calculate and print basic network metrics
     logger.info("Network Analysis:")
-    logger.info(f"Number of nodes: {G.number_of_nodes()}")
-    logger.info(f"Number of edges: {G.number_of_edges()}")
+    logger.info(f"Number of nodes: {graph.number_of_nodes()}")
+    logger.info(f"Number of edges: {graph.number_of_edges()}")
 
     # Calculate degree for each node
     logger.info("Node degrees:")
-    for node in G.nodes():
-        logger.info(f"Node {node}: {G.degree(node)}")
+    for node in graph.nodes():
+        logger.info(f"Node {node}: {graph.degree(node)}")
 
     # Calculate betweenness centrality
-    betweenness = nx.betweenness_centrality(G)
+    betweenness = nx.betweenness_centrality(graph)
     logger.info("Betweenness centrality:")
     for node, bc in betweenness.items():
         logger.info(f"Node {node}: {bc:.3f}")
 
     # Calculate shortest paths
     logger.info("Shortest paths from node A:")
-    for target in G.nodes():
+    for target in graph.nodes():
         if target != "A":
-            path = nx.shortest_path(G, "A", target, weight="weight")
-            distance = nx.shortest_path_length(G, "A", target, weight="weight")
+            path = nx.shortest_path(graph, "A", target, weight="weight")
+            distance = nx.shortest_path_length(graph, "A", target, weight="weight")
             logger.info(f"A to {target}: {path} (distance: {distance})")
 
 
-def visualize_network(G: nx.Graph) -> None:
+def visualize_network(graph: nx.Graph) -> None:
     """
     Create and display a visualization of the network.
     """
     plt.figure(figsize=(10, 8))
-    pos = nx.spring_layout(G)
+    pos = nx.spring_layout(graph)
 
     # Draw nodes
-    nx.draw_networkx_nodes(G, pos, node_color="lightblue", node_size=500)
+    nx.draw_networkx_nodes(graph, pos, node_color="lightblue", node_size=500)
 
     # Draw edges
-    nx.draw_networkx_edges(G, pos)
+    nx.draw_networkx_edges(graph, pos)
 
     # Draw labels
-    nx.draw_networkx_labels(G, pos)
+    nx.draw_networkx_labels(graph, pos)
 
     # Draw edge labels
-    edge_labels = nx.get_edge_attributes(G, "weight")
-    nx.draw_networkx_edge_labels(G, pos, edge_labels=edge_labels)
+    edge_labels = nx.get_edge_attributes(graph, "weight")
+    nx.draw_networkx_edge_labels(graph, pos, edge_labels=edge_labels)
 
     plt.title("Network Graph")
     plt.axis("off")

high-performance-computing/hm-jax/src/main.py

@@ -8,13 +8,13 @@
 
 
 # The linear model
-def predict(w: float, b: float, X: jnp.ndarray) -> jnp.ndarray:
-    return w * X + b
+def predict(w: float, b: float, x: jnp.ndarray) -> jnp.ndarray:
+    return w * x + b
 
 
 # The loss function (mean squared error)
-def loss_fn(w: float, b: float, X: jnp.ndarray, y: jnp.ndarray) -> float:
-    predictions = predict(w, b, X)
+def loss_fn(w: float, b: float, x: jnp.ndarray, y: jnp.ndarray) -> float:
+    predictions = predict(w, b, x)
     return jnp.mean((predictions - y) ** 2)
 
 
@@ -23,11 +23,11 @@ def loss_fn(w: float, b: float, X: jnp.ndarray, y: jnp.ndarray) -> float:
 def update(
     w: float,
     b: float,
-    X: jnp.ndarray,
+    x: jnp.ndarray,
     y: jnp.ndarray,
     learning_rate: float,
 ) -> tuple[float, float]:
-    dw, db = grad(loss_fn, argnums=(0, 1))(w, b, X, y)
+    dw, db = grad(loss_fn, argnums=(0, 1))(w, b, x, y)
     w -= learning_rate * dw
     b -= learning_rate * db
     return w, b
@@ -36,18 +36,18 @@ def update(
 def main() -> None:
     # Generate synthetic data
     key = random.PRNGKey(0)
-    N = 100  # number of data points
-    X = random.normal(key, (N,))  # features
+    n = 100  # number of data points
+    x = random.normal(key, (n,))  # features
 
     # Adding even more non-linearity and varying noise
     true_w, true_b = 2.0, -1.0  # true weights for the linear model
     y = (
-        true_w * X
+        true_w * x
         + true_b
-        + jnp.sin(X) * 0.5
-        + jnp.cos(2 * X) * 0.3  # additional non-linear component
-        + random.normal(key, (N,)) * jnp.abs(X) * 0.5  # varying noise based on X
-        + random.normal(key, (N,)) * 2.0  # additional noise for more randomness
+        + jnp.sin(x) * 0.5
+        + jnp.cos(2 * x) * 0.3  # additional non-linear component
+        + random.normal(key, (n,)) * jnp.abs(x) * 0.5  # varying noise based on X
+        + random.normal(key, (n,)) * 2.0  # additional noise for more randomness
     )
 
     # Initialize weights
@@ -61,17 +61,17 @@ def main() -> None:
     # Train
     losses = []
     for i in range(num_iterations):
-        w, b = update(w, b, X, y, learning_rate)
-        current_loss = loss_fn(w, b, X, y)
+        w, b = update(w, b, x, y, learning_rate)
+        current_loss = loss_fn(w, b, x, y)
         losses.append(current_loss)
         if i % 10 == 0:
             logger.info(
                 f"Iteration {i}: loss = {current_loss:.4f}, w = {w:.4f}, b = {b:.4f}",
             )
 
     # Plot the results
-    plt.plot(X, y, "bo", label="Data")
-    plt.plot(X, predict(w, b, X), "r-", label="Fitted Line")
+    plt.plot(x, y, "bo", label="Data")
+    plt.plot(x, predict(w, b, x), "r-", label="Fitted Line")
     plt.legend()
     plt.title(f"Linear Regression: w = {w:.2f}, b = {b:.2f}")
     plt.show()

machine-learning/convolutional-neural-network/src/model/net.py

@@ -1,5 +1,5 @@
 import torch
-import torch.nn.functional as F
+import torch.nn.functional as F  # noqa: N812
 from torch import nn
 
 

machine-learning/dali/src/main.py

@@ -60,8 +60,8 @@ def get_num_samples(data_path: Path) -> int:
 
 
 def main() -> None:
-    BATCH_SIZE: int = 2
-    NUM_THREADS: int = 2
+    batch_size: int = 2
+    num_threads: int = 2
 
     # Create data directory and download sample images
     data_path = Path("data")
@@ -75,8 +75,8 @@ def main() -> None:
 
     pipe = image_pipeline(
         data_path=data_path,
-        batch_size=BATCH_SIZE,
-        num_threads=NUM_THREADS,
+        batch_size=batch_size,
+        num_threads=num_threads,
     )
     pipe.build()
 

machine-learning/graph-neural-network/src/model/conv.py

@@ -1,5 +1,5 @@
 import torch
-import torch.nn.functional as F
+import torch.nn.functional as F  # noqa: N812
 from ogb.graphproppred.mol_encoder import AtomEncoder, BondEncoder
 from torch_geometric.nn import MessagePassing, global_add_pool
 from torch_geometric.utils import degree
@@ -8,10 +8,6 @@
 # GIN convolution along the graph structure
 class GINConv(MessagePassing):
     def __init__(self, emb_dim):
-        """
-        emb_dim (int): node embedding dimensionality
-        """
-
         super().__init__(aggr="add")
         self.mlp = torch.nn.Sequential(
             torch.nn.Linear(emb_dim, 2 * emb_dim),
@@ -78,13 +74,7 @@ def update(self, aggr_out):
         return aggr_out
 
 
-# GNN to generate node embedding
-class GNN_node(torch.nn.Module):
-    """
-    Output:
-        node representations
-    """
-
+class GNNNode(torch.nn.Module):
     def __init__(
         self,
         num_layer,
@@ -94,11 +84,6 @@ def __init__(
         residual=False,
         gnn_type="gin",
     ):
-        """
-        emb_dim (int): node embedding dimensionality
-        num_layer (int): number of GNN message passing layers
-        """
-
         super().__init__()
         self.num_layer = num_layer
         self.drop_ratio = drop_ratio
@@ -162,12 +147,7 @@ def forward(self, batched_data):
 
 
 # Virtual GNN to generate node embedding
-class GNN_node_Virtualnode(torch.nn.Module):
-    """
-    Output:
-        node representations
-    """
-
+class GNNVirtualNode(torch.nn.Module):
     def __init__(
         self,
         num_layer,
@@ -177,10 +157,6 @@ def __init__(
         residual=False,
         gnn_type="gin",
     ):
-        """
-        emb_dim (int): node embedding dimensionality
-        """
-
         super().__init__()
         self.num_layer = num_layer
         self.drop_ratio = drop_ratio

machine-learning/graph-neural-network/src/model/gnn.py

@@ -1,5 +1,5 @@
 import torch
-from model.conv import GNN_node, GNN_node_Virtualnode
+from model.conv import GNNNode, GNNVirtualNode
 from torch_geometric.nn import (
     GlobalAttention,
     Set2Set,
@@ -41,7 +41,7 @@ def __init__(
 
         # GNN to generate node embeddings
         if virtual_node:
-            self.gnn_node = GNN_node_Virtualnode(
+            self.gnn_node = GNNVirtualNode(
                 num_layer,
                 emb_dim,
                 jk=jk,
@@ -50,7 +50,7 @@ def __init__(
                 gnn_type=gnn_type,
             )
         else:
-            self.gnn_node = GNN_node(
+            self.gnn_node = GNNNode(
                 num_layer,
                 emb_dim,
                 jk=jk,

machine-learning/hm-kubeflow/pipelines/classify-mnist/src/main.py

@@ -6,9 +6,9 @@
     packages_to_install=["torch==2.0.0", "torchvision==0.15.1", "lightning==2.0.5"],
 )
 def train():
-    import lightning as L
+    import lightning as L  # noqa: N812
     import torch
-    import torch.nn.functional as F
+    import torch.nn.functional as F  # noqa: N812
     import torchvision
     from torch import nn
     from torch.utils import data

machine-learning/hm-mlflow/experiments/classify-mnist/src/main.py

@@ -1,7 +1,7 @@
-import lightning as L
+import lightning as L  # noqa: N812
 import mlflow
 import torch
-import torch.nn.functional as F
+import torch.nn.functional as F  # noqa: N812
 import torchvision
 from args import get_args
 from lightning.pytorch.loggers.wandb import WandbLogger