Fix ruff format check error

Author: xmhubj

benchmarks/benchmark_throughput_autotune.py

@@ -604,7 +604,8 @@ def write_results_csv(
     baseline_fake_result: tuple[float, float] | None = None,
     baseline_enable_result: tuple[float, float] | None = None,
     op_backends: dict[str, list[str]] | None = None,
-    per_op_backend_results: dict[str, dict[str, tuple[float, float] | None]] | None = None,
+    per_op_backend_results: dict[str, dict[str, tuple[float, float] | None]]
+    | None = None,
 ) -> None:
     """
     Write per-operator results into a CSV file, sorted by total throughput desc.
@@ -1089,7 +1090,11 @@ def main() -> None:
                 op_backends=tuned_op_backends,
                 per_op_backend_results=per_op_backend_results,
             )
-            if val is not None and baseline_total is not None and (best_result is None or val[0] > best_result[0]):
+            if (
+                val is not None
+                and baseline_total is not None
+                and (best_result is None or val[0] > best_result[0])
+            ):
                 best_result = val
                 best_backend = backend
 

benchmarks/benchmark_throughput_flagos.py

@@ -13,48 +13,64 @@
 # scenarios (name, input_len, output_len, concurrency)
 SCENARIOS = [
     # from FlagScale
-    ("p128d128",     128,    128,   100),
-    ("p6144d128",    6144,   128,   100),
-    ("p30720d128",   30720,  128,   100),
-    ("p128d6144",    128,    6144,  100),
-    ("p6144d6144",   6144,   6144,  100),
-    ("p30720d6144",  30720,  6144,  100),
+    ("p128d128", 128, 128, 100),
+    ("p6144d128", 6144, 128, 100),
+    ("p30720d128", 30720, 128, 100),
+    ("p128d6144", 128, 6144, 100),
+    ("p6144d6144", 6144, 6144, 100),
+    ("p30720d6144", 30720, 6144, 100),
     # from FlagRelease
-    ("p4096d2048",   4096,   2048,  64),
+    ("p4096d2048", 4096, 2048, 64),
     # from vendors
-    ("p6144d1024",   6144,  1024,   100),
-    ("p4096d1024",   4096,  1024,   100),
-    ("p2048d1024",   2048,  1024,   100),
-    ("p1024d1024",   1024,  1024,   100),
+    ("p6144d1024", 6144, 1024, 100),
+    ("p4096d1024", 4096, 1024, 100),
+    ("p2048d1024", 2048, 1024, 100),
+    ("p1024d1024", 1024, 1024, 100),
 ]
 
 LOG_DIR = "vllm_bench_logs"
 os.makedirs(LOG_DIR, exist_ok=True)
 
-NUM_RUNS = 4 
+NUM_RUNS = 4
 # ====================
 
+
 def run_benchmark(name, input_len, output_len, concurrency, run_id):
     num_prompts = concurrency
     cmd = [
-        "vllm", "bench", "serve",
-        "--host", HOST,
-        "--port", str(PORT),
-        "--backend", BACKEND,
-        "--model", SERVED_MODEL_NAME,
-        "--tokenizer", "Qwen/Qwen3-Next-80B-A3B-Instruct",
-        "--dataset-name", "random",
-        "--endpoint", ENDPOINT,
+        "vllm",
+        "bench",
+        "serve",
+        "--host",
+        HOST,
+        "--port",
+        str(PORT),
+        "--backend",
+        BACKEND,
+        "--model",
+        SERVED_MODEL_NAME,
+        "--tokenizer",
+        "Qwen/Qwen3-Next-80B-A3B-Instruct",
+        "--dataset-name",
+        "random",
+        "--endpoint",
+        ENDPOINT,
         "--ignore-eos",
         "--trust-remote-code",
-        "--random-input-len", str(input_len),
-        "--random-output-len", str(output_len),
-        "--num-prompts", str(num_prompts),
-        "--max-concurrency", str(concurrency)
+        "--random-input-len",
+        str(input_len),
+        "--random-output-len",
+        str(output_len),
+        "--num-prompts",
+        str(num_prompts),
+        "--max-concurrency",
+        str(concurrency),
     ]
 
     log_file = os.path.join(LOG_DIR, f"{name}_run{run_id}.log")
-    print(f"\n[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] 🚀 Starting scenario: {name} (Run {run_id})")
+    print(
+        f"\n[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] 🚀 Starting scenario: {name} (Run {run_id})"
+    )
     print(f"    Input: {input_len}, Output: {output_len}, Concurrency: {concurrency}")
     print(f"    Logging to: {log_file}")
     print(f"    Command: {' '.join(cmd)}\n")
@@ -63,14 +79,20 @@ def run_benchmark(name, input_len, output_len, concurrency, run_id):
         result = subprocess.run(cmd, stdout=f, stderr=subprocess.STDOUT, text=True)
 
     status = "✅ Success" if result.returncode == 0 else "❌ Failed"
-    print(f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] {status}: {name} Run {run_id} (exit code: {result.returncode})\n")
+    print(
+        f"[{datetime.now().strftime('%Y-%m-%d %H:%M:%S')}] {status}: {name} Run {run_id} (exit code: {result.returncode})\n"
+    )
+
 
 def main():
-    print(f"🧪 Starting vLLM benchmark suite for {len(SCENARIOS)} scenarios, each repeated {NUM_RUNS} times...\n")
+    print(
+        f"🧪 Starting vLLM benchmark suite for {len(SCENARIOS)} scenarios, each repeated {NUM_RUNS} times...\n"
+    )
     for name, inp, out, conc in SCENARIOS:
         for run_id in range(1, NUM_RUNS + 1):
             run_benchmark(name, inp, out, conc, run_id)
     print("🏁 All scenarios and runs completed. Logs saved in:", LOG_DIR)
 
+
 if __name__ == "__main__":
     main()

benchmarks/benchmark_throughput_flagos_statistics.py

@@ -14,22 +14,23 @@
     "p6144d1024",
     "p4096d1024",
     "p2048d1024",
-    "p1024d1024"
+    "p1024d1024",
 ]
 
 LOG_DIR = "./vllm_bench_logs"
 
+
 def extract_throughputs(log_path):
     output_throughput = None
     total_throughput = None
     try:
-        with open(log_path, 'r', encoding='utf-8') as f:
+        with open(log_path, "r", encoding="utf-8") as f:
             content = f.read()
     except FileNotFoundError:
         return None, None
 
-    out_match = re.search(r'Output token throughput \(tok/s\):\s*([\d.]+)', content)
-    tot_match = re.search(r'Total Token throughput \(tok/s\):\s*([\d.]+)', content)
+    out_match = re.search(r"Output token throughput \(tok/s\):\s*([\d.]+)", content)
+    tot_match = re.search(r"Total Token throughput \(tok/s\):\s*([\d.]+)", content)
 
     if out_match:
         output_throughput = float(out_match.group(1))
@@ -38,6 +39,7 @@ def extract_throughputs(log_path):
 
     return output_throughput, total_throughput
 
+
 def compute_extended_stats(values):
     valid_vals = [v for v in values if v is not None]
     if not valid_vals:
@@ -60,9 +62,10 @@ def compute_extended_stats(values):
         f"{median_val:.2f}",
         f"{max_val:.2f}",
         f"{stdev_val:.2f}",
-        sigma_str
+        sigma_str,
     )
 
+
 def main():
     # aligned output
     scene_width = 14
@@ -101,5 +104,6 @@ def main():
         )
         print(line)
 
+
 if __name__ == "__main__":
     main()

examples/offline_inference.py

@@ -20,7 +20,7 @@
 if "USE_FLAGGEMS" in os.environ:
     print(f"USE_FLAGGEMS: {os.environ['USE_FLAGGEMS']}")
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     prompts = [
         "Hello, my name is",
     ]
@@ -40,5 +40,5 @@
 
     del llm
     torch.cuda.empty_cache()
-    
+
     print("\n Reasoning complete, resources cleared.")

examples/qwen3_next_offline_inference.py

@@ -10,15 +10,19 @@
 
 from vllm import LLM, SamplingParams
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     prompts = [
         "Hello, my name is",
     ]
 
     # Create a sampling params object.
     sampling_params = SamplingParams(max_tokens=10, temperature=0.0)
     # Create an LLM.
-    llm = LLM(model="Qwen/Qwen3-Next-80B-A3B-Instruct", tensor_parallel_size=4, max_model_len=262144)
+    llm = LLM(
+        model="Qwen/Qwen3-Next-80B-A3B-Instruct",
+        tensor_parallel_size=4,
+        max_model_len=262144,
+    )
 
     # Generate texts from the prompts.
     outputs = llm.generate(prompts, sampling_params)
@@ -27,4 +31,3 @@
         prompt = output.prompt
         generated_text = output.outputs[0].text
         print(f"Prompt: {prompt!r}, Generated text: {generated_text!r}")
-

setup.py

@@ -44,7 +44,7 @@ def _read_requirements(filename: str) -> list[str]:
 
 
 setup(
-    name='vllm_fl',
+    name="vllm_fl",
     # Follow:
     # https://packaging.python.org/en/latest/specifications/version-specifiers
     version=VERSION,
@@ -73,7 +73,8 @@ def _read_requirements(filename: str) -> list[str]:
     python_requires=">=3.9",
     install_requires=get_requirements(),
     extras_require={},
-    entry_points={'vllm.platform_plugins': ["fl = vllm_fl:register"],
-                  'vllm.general_plugins': ["fl = vllm_fl:register_model"]}
+    entry_points={
+        "vllm.platform_plugins": ["fl = vllm_fl:register"],
+        "vllm.general_plugins": ["fl = vllm_fl:register_model"],
+    },
 )
-

tests/functional_tests/compilation/test_graph_capture.py

@@ -25,6 +25,7 @@ def test_weak_ref_tensors_function(self):
         """Test weak_ref_tensors function exists."""
         try:
             from vllm_fl.compilation.graph import weak_ref_tensors
+
             assert weak_ref_tensors is not None
         except ImportError:
             pytest.skip("weak_ref_tensors not available")
@@ -110,6 +111,7 @@ class TestGraphCacheManagement:
 
     def test_batch_descriptor_hashing(self):
         """Test that batch descriptors can be used as dict keys."""
+
         @dataclass(frozen=True)
         class MockBatchDescriptor:
             num_tokens: int

tests/functional_tests/conftest.py

@@ -11,8 +11,12 @@
 def pytest_configure(config):
     """Register custom markers."""
     config.addinivalue_line("markers", "gpu: marks tests as requiring GPU")
-    config.addinivalue_line("markers", "multi_gpu: marks tests as requiring multiple GPUs")
-    config.addinivalue_line("markers", "flaggems: marks tests as requiring flag_gems library")
+    config.addinivalue_line(
+        "markers", "multi_gpu: marks tests as requiring multiple GPUs"
+    )
+    config.addinivalue_line(
+        "markers", "flaggems: marks tests as requiring flag_gems library"
+    )
 
 
 @pytest.fixture(scope="session")

tests/functional_tests/distributed/test_collective_ops.py

@@ -24,6 +24,7 @@ def test_communicator_fl_import(self):
         """Test that CommunicatorFL can be imported."""
         try:
             from vllm_fl.distributed.communicator import CommunicatorFL
+
             assert CommunicatorFL is not None
         except ImportError as e:
             pytest.skip(f"CommunicatorFL not available: {e}")
@@ -34,6 +35,7 @@ def test_pyflagcx_import(self):
             from vllm_fl.distributed.device_communicators.flagcx import (
                 PyFlagcxCommunicator,
             )
+
             assert PyFlagcxCommunicator is not None
         except ImportError as e:
             pytest.skip(f"PyFlagcxCommunicator not available: {e}")
@@ -49,7 +51,7 @@ def reference_all_reduce(tensors: list[torch.Tensor]) -> torch.Tensor:
 
     @pytest.mark.skipif(
         not torch.cuda.is_available() or torch.cuda.device_count() < 2,
-        reason="Multiple GPUs not available"
+        reason="Multiple GPUs not available",
     )
     def test_all_reduce_sum_correctness(self):
         """Test all_reduce sum produces correct results."""
@@ -69,8 +71,7 @@ class TestReduceScatterCorrectness:
 
     @staticmethod
     def reference_reduce_scatter(
-        input_tensor: torch.Tensor,
-        world_size: int
+        input_tensor: torch.Tensor, world_size: int
     ) -> list[torch.Tensor]:
         """Reference implementation of reduce_scatter."""
         # Split input into chunks
@@ -80,12 +81,14 @@ def reference_reduce_scatter(
 
     def test_reduce_scatter_reference(self):
         """Test reference reduce_scatter implementation."""
-        input_tensor = torch.tensor([
-            [1.0, 2.0],
-            [3.0, 4.0],
-            [5.0, 6.0],
-            [7.0, 8.0],
-        ])
+        input_tensor = torch.tensor(
+            [
+                [1.0, 2.0],
+                [3.0, 4.0],
+                [5.0, 6.0],
+                [7.0, 8.0],
+            ]
+        )
         world_size = 2
 
         result = self.reference_reduce_scatter(input_tensor, world_size)
@@ -109,10 +112,12 @@ def test_all_gather_reference(self):
             torch.tensor([[1.0, 2.0]]),
             torch.tensor([[3.0, 4.0]]),
         ]
-        expected = torch.tensor([
-            [1.0, 2.0],
-            [3.0, 4.0],
-        ])
+        expected = torch.tensor(
+            [
+                [1.0, 2.0],
+                [3.0, 4.0],
+            ]
+        )
 
         result = self.reference_all_gather(tensors)
         assert torch.allclose(result, expected)
@@ -123,7 +128,7 @@ class TestSendRecvCorrectness:
 
     @pytest.mark.skipif(
         not torch.cuda.is_available() or torch.cuda.device_count() < 2,
-        reason="Multiple GPUs not available"
+        reason="Multiple GPUs not available",
     )
     def test_send_recv_mock(self):
         """Test send/recv with mocked communicator."""

tests/functional_tests/inference/test_offline_minicpm.py

@@ -85,8 +85,7 @@ def test_inference(self, tokenizer, audio_count):
         if audio_count > 0:
             mm_data = {
                 "audio": [
-                    asset.audio_and_sample_rate
-                    for asset in AUDIO_ASSETS[:audio_count]
+                    asset.audio_and_sample_rate for asset in AUDIO_ASSETS[:audio_count]
                 ]
             }