ci: Remove yapf and isort in favor of ruff (#613)

Author: akihironitta

.github/labeler.yml

@@ -12,17 +12,14 @@ ci:
               - .github/**/*
               - codecov.yaml
               - .pre-commit-config.yaml
-              - .ruff.toml
-              - .style.yapf
-              - setup.cfg
 
 documentation:
   - any:
       - changed-files:
           - any-glob-to-any-file:
               - docs/**/*
               - readthedocs.yml
-              - README.MD
+              - README.md
 
 benchmark:
   - any:

.github/workflows/aws/upload_final_index.py

@@ -69,24 +69,40 @@
 
 bucket.Object('index.html').upload_file('index.html', ExtraArgs=args)
 
-index_html = html.format('\n'.join([
-    href.format(f'{torch_version}.html'.replace('+', '%2B'), torch_version)
-    for torch_version in wheels_dict
-]))
+index_html = html.format(
+    '\n'.join(
+        [
+            href.format(
+                f'{torch_version}.html'.replace('+', '%2B'),
+                torch_version,
+            )
+            for torch_version in wheels_dict
+        ],
+    ),
+)
 
 with open('index.html', 'w') as f:
     f.write(index_html)
 
 bucket.Object('whl/index.html').upload_file('index.html', ExtraArgs=args)
 
 for torch_version, wheels in wheels_dict.items():
-    torch_version_html = html.format('\n'.join([
-        href.format(f'{orig_torch_version}/{wheel}'.replace('+', '%2B'), wheel)
-        for orig_torch_version, wheel in wheels
-    ]))
+    torch_version_html = html.format(
+        '\n'.join(
+            [
+                href.format(
+                    f'{orig_torch_version}/{wheel}'.replace('+', '%2B'),
+                    wheel,
+                )
+                for orig_torch_version, wheel in wheels
+            ],
+        ),
+    )
 
     with open(f'{torch_version}.html', 'w') as f:
         f.write(torch_version_html)
 
     bucket.Object(f'whl/{torch_version}.html').upload_file(
-        f'{torch_version}.html', ExtraArgs=args)
+        f'{torch_version}.html',
+        ExtraArgs=args,
+    )

.github/workflows/aws/upload_nightly_index.py

@@ -43,22 +43,35 @@
     if '2.9.0' in torch_version:
         wheels_dict[torch_version.replace('2.9.0', '2.9.1')].append(wheel)
 
-index_html = html.format('\n'.join([
-    href.format(f'{version}.html'.replace('+', '%2B'), version)
-    for version in wheels_dict
-]))
+index_html = html.format(
+    '\n'.join(
+        [
+            href.format(f'{version}.html'.replace('+', '%2B'), version)
+            for version in wheels_dict
+        ],
+    ),
+)
 
 with open('index.html', 'w') as f:
     f.write(index_html)
 bucket.Object('whl/nightly/index.html').upload_file('index.html', args)
 
 for torch_version, wheel_names in wheels_dict.items():
-    torch_version_html = html.format('\n'.join([
-        href.format(f'{wheel_name}'.replace('+', '%2B'),
-                    wheel_name.split('/')[-1]) for wheel_name in wheel_names
-    ]))
+    torch_version_html = html.format(
+        '\n'.join(
+            [
+                href.format(
+                    f'{wheel_name}'.replace('+', '%2B'),
+                    wheel_name.split('/')[-1],
+                )
+                for wheel_name in wheel_names
+            ],
+        ),
+    )
 
     with open(f'{torch_version}.html', 'w') as f:
         f.write(torch_version_html)
     bucket.Object(f'whl/nightly/{torch_version}.html').upload_file(
-        f'{torch_version}.html', args)
+        f'{torch_version}.html',
+        args,
+    )

.pre-commit-config.yaml

@@ -48,30 +48,21 @@ repos:
           --in-place,
         ]
 
-  - repo: https://github.com/google/yapf
-    rev: v0.43.0
-    hooks:
-      - id: yapf
-        name: Format code
-
-  - repo: https://github.com/pycqa/isort
-    rev: 8.0.1
-    hooks:
-      - id: isort
-        name: Sort imports
-
   - repo: https://github.com/astral-sh/ruff-pre-commit
     rev: v0.15.7
     hooks:
-      - id: ruff
-        name: Ruff formatting
+      - id: ruff-check
+        name: ruff check
         args: [--fix, --exit-non-zero-on-fix]
+      - id: ruff-format
+        name: ruff format
 
   - repo: https://github.com/PyCQA/flake8
     rev: 7.3.0
     hooks:
       - id: flake8
         name: Check PEP8
+        args: [--extend-ignore=E203]
 
   - repo: https://github.com/pre-commit/mirrors-clang-format
     rev: v22.1.1

benchmark/classes/hash_map.py

@@ -9,8 +9,12 @@
 if __name__ == '__main__':
     parser = argparse.ArgumentParser()
     parser.add_argument('--device', type=str, default='cuda')
-    parser.add_argument('--dtype', type=str, default='int',
-                        choices=['short', 'int', 'long'])
+    parser.add_argument(
+        '--dtype',
+        type=str,
+        default='int',
+        choices=['short', 'int', 'long'],
+    )
     parser.add_argument('--num_keys', type=int, default=10_000_000)
     parser.add_argument('--num_queries', type=int, default=1_000_000)
     args = parser.parse_args()
@@ -25,14 +29,19 @@
 
     max_value = torch.iinfo(dtype).max
 
-    key1 = torch.randint(0, max_value, (args.num_keys, ), dtype=dtype,
-                         device=args.device).unique()
+    key1 = torch.randint(
+        0,
+        max_value,
+        (args.num_keys,),
+        dtype=dtype,
+        device=args.device,
+    ).unique()
     query1 = key1[torch.randperm(key1.size(0), device=args.device)]
-    query1 = query1[:args.num_queries]
+    query1 = query1[: args.num_queries]
 
     key2 = torch.randperm(args.num_keys, dtype=dtype, device=args.device)
     query2 = torch.randperm(args.num_queries, dtype=dtype, device=args.device)
-    query2 = query2[:args.num_queries]
+    query2 = query2[: args.num_queries]
 
     if key1.is_cuda:
         t_init = t_get = 0
@@ -77,10 +86,17 @@
     for i in range(num_warmups + num_steps):
         torch.cuda.synchronize()
         t_start = time.perf_counter()
-        hash_map = torch.full((args.num_keys, ), fill_value=-1, dtype=dtype,
-                              device=args.device)
-        hash_map[key2.long()] = torch.arange(args.num_keys, dtype=dtype,
-                                             device=args.device)
+        hash_map = torch.full(
+            (args.num_keys,),
+            fill_value=-1,
+            dtype=dtype,
+            device=args.device,
+        )
+        hash_map[key2.long()] = torch.arange(
+            args.num_keys,
+            dtype=dtype,
+            device=args.device,
+        )
         torch.cuda.synchronize()
         if i >= num_warmups:
             t_init += time.perf_counter() - t_start
@@ -99,8 +115,10 @@
         t_init = t_get = 0
         for i in range(num_warmups + num_steps):
             t_start = time.perf_counter()
-            hash_map = pd.CategoricalDtype(categories=key1.numpy(),
-                                           ordered=True)
+            hash_map = pd.CategoricalDtype(
+                categories=key1.numpy(),
+                ordered=True,
+            )
             if i >= num_warmups:
                 t_init += time.perf_counter() - t_start
 

benchmark/ops/sampled.py

@@ -17,8 +17,8 @@
     if args.device == 'cpu':
         num_warmups, num_steps = num_warmups // 10, num_steps // 10
 
-    a_index = torch.randint(0, num_nodes, (num_edges, ), device=args.device)
-    b_index = torch.randint(0, num_nodes, (num_edges, ), device=args.device)
+    a_index = torch.randint(0, num_nodes, (num_edges,), device=args.device)
+    b_index = torch.randint(0, num_nodes, (num_edges,), device=args.device)
     out_grad = torch.randn(num_edges, num_feats, device=args.device)
 
     for fn in ['add', 'sub', 'mul', 'div']:

benchmark/ops/spline.py

@@ -7,6 +7,7 @@
 
 try:
     import torch_spline_conv
+
     HAS_TORCH_SPLINE_CONV = True
 except ImportError:
     HAS_TORCH_SPLINE_CONV = False
@@ -33,10 +34,16 @@
     for degree in [1, 2, 3]:
         E, D = 10000, 3
         pseudo = torch.rand(E, D, dtype=torch.float, device=args.device)
-        kernel_size = torch.tensor([5] * D, dtype=torch.long,
-                                   device=args.device)
-        is_open_spline = torch.tensor([1] * D, dtype=torch.uint8,
-                                      device=args.device)
+        kernel_size = torch.tensor(
+            [5] * D,
+            dtype=torch.long,
+            device=args.device,
+        )
+        is_open_spline = torch.tensor(
+            [1] * D,
+            dtype=torch.uint8,
+            device=args.device,
+        )
         label = f'spline_basis (degree={degree}, E={E}, D={D})'
 
         if bench_original:
@@ -114,8 +121,13 @@
     x = torch.randn(E, M_in, dtype=torch.float, device=args.device)
     weight = torch.randn(K, M_in, M_out, dtype=torch.float, device=args.device)
     basis = torch.rand(E, S, dtype=torch.float, device=args.device)
-    weight_index = torch.randint(0, K, (E, S), dtype=torch.long,
-                                 device=args.device)
+    weight_index = torch.randint(
+        0,
+        K,
+        (E, S),
+        dtype=torch.long,
+        device=args.device,
+    )
     label = f'spline_weighting (E={E}, M_in={M_in}, M_out={M_out}, K={K})'
 
     if bench_original:

benchmark/sampler/hetero_neighbor.py

@@ -14,32 +14,48 @@
 from pyg_lib.testing import remap_keys, withDataset, withSeed
 
 argparser = argparse.ArgumentParser('Hetero neighbor sample benchmark')
-argparser.add_argument('--batch-sizes', nargs='+', type=int, default=[
-    512,
-    1024,
-    2048,
-    4096,
-    8192,
-])
+argparser.add_argument(
+    '--batch-sizes',
+    nargs='+',
+    type=int,
+    default=[
+        512,
+        1024,
+        2048,
+        4096,
+        8192,
+    ],
+)
 
 # TODO (kgajdamo): Support undirected hetero graphs
 # argparser.add_argument('--directed', action='store_true')
 argparser.add_argument('--disjoint', action='store_true')
-argparser.add_argument('--num_neighbors', type=ast.literal_eval, default=[
-    [-1],
-    [15, 10, 5],
-    [20, 15, 10],
-])
+argparser.add_argument(
+    '--num_neighbors',
+    type=ast.literal_eval,
+    default=[
+        [-1],
+        [15, 10, 5],
+        [20, 15, 10],
+    ],
+)
 # TODO(kgajdamo): Enable sampling with replacement
 # argparser.add_argument('--replace', action='store_true')
 argparser.add_argument('--shuffle', action='store_true')
 argparser.add_argument('--biased', action='store_true')
 argparser.add_argument('--temporal', action='store_true')
-argparser.add_argument('--temporal-strategy', choices=['uniform', 'last'],
-                       default='uniform')
+argparser.add_argument(
+    '--temporal-strategy',
+    choices=['uniform', 'last'],
+    default='uniform',
+)
 argparser.add_argument('--write-csv', action='store_true')
-argparser.add_argument('--libraries', nargs="*", type=str,
-                       default=['pyg-lib', 'torch-sparse'])
+argparser.add_argument(
+    '--libraries',
+    nargs='*',
+    type=str,
+    default=['pyg-lib', 'torch-sparse'],
+)
 args = argparser.parse_args()
 
 
@@ -48,7 +64,8 @@
 def test_hetero_neighbor(dataset, **kwargs):
     if args.temporal and not args.disjoint:
         raise ValueError(
-            "Temporal sampling needs to create disjoint subgraphs")
+            'Temporal sampling needs to create disjoint subgraphs',
+        )
 
     colptr_dict, row_dict = dataset
     num_nodes_dict = {k[-1]: v.size(0) - 1 for k, v in colptr_dict.items()}
@@ -57,7 +74,8 @@ def test_hetero_neighbor(dataset, **kwargs):
     if args.temporal:
         # generate random timestamps
         node_time, _ = torch.sort(
-            torch.randint(0, 100000, (num_nodes_dict['paper'], )))
+            torch.randint(0, 100000, (num_nodes_dict['paper'],)),
+        )
         node_time_dict = {'paper': node_time}
     else:
         node_time_dict = None
@@ -75,9 +93,10 @@ def test_hetero_neighbor(dataset, **kwargs):
         node_perm = torch.arange(0, num_nodes_dict['paper'])
 
     data = defaultdict(list)
-    for num_neighbors, batch_size in product(args.num_neighbors,
-                                             args.batch_sizes):
-
+    for num_neighbors, batch_size in product(
+        args.num_neighbors,
+        args.batch_sizes,
+    ):
         print(f'batch_size={batch_size}, num_neighbors={num_neighbors}):')
         data['num_neighbors'].append(num_neighbors)
         data['batch-size'].append(batch_size)