fix code conventions

CienetStingLin · CienetStingLin · commit 2f4fa058bc33 · 2025-09-04T16:01:53.000+08:00
diff --git a/.buildkite/scripts/run_in_docker.sh b/.buildkite/scripts/run_in_docker.sh
@@ -35,10 +35,10 @@ if [ "$MOUNT_EXPECT_RESULT" = "True" ]; then
     echo "[DEBUG] Path: $EXPECT_VALUES_PATH, Filename: $EXPECT_VALUES_FILENAME, "
 
     EXPECT_VOLUME=(-v "$(pwd)/$EXPECT_VALUES_FILENAME":"$EXPECT_VALUES_PATH$EXPECT_VALUES_FILENAME")
-    echo "docker -v cmd: ${EXPECT_VOLUME[@]}"
+    echo "docker -v cmd: " "${EXPECT_VOLUME[@]}"
 
     EXPECT_ENV=(-e EXPECT_VALUES_PATH="$EXPECT_VALUES_PATH" -e EXPECT_VALUES_FILENAME="$EXPECT_VALUES_FILENAME")
-    echo "docker -e cmd: ${EXPECT_ENV[@]}"
+    echo "docker -e cmd: " "${EXPECT_ENV[@]}"
 fi
 
 if ! grep -q "^HF_TOKEN=" /etc/environment; then
@@ -115,4 +115,4 @@ exec docker run \
   ${NEW_MODEL_DESIGN:+-e NEW_MODEL_DESIGN="$NEW_MODEL_DESIGN"} \
   ${USE_V6E8_QUEUE:+-e USE_V6E8_QUEUE="$USE_V6E8_QUEUE"} \
   "${IMAGE_NAME}:${BUILDKITE_COMMIT}" \
-  "$@" # Pass all script arguments as the command to run in the container
+  "$@" # Pass all script arguments as the command to run in the container
diff --git a/scripts/vllm/integration/conftest.py b/scripts/vllm/integration/conftest.py
@@ -1,29 +1,25 @@
-import pytest
-import json
-
 def pytest_addoption(parser):
     """Adds custom command-line options to pytest."""
-    parser.addoption(
-        "--tensor-parallel-size",
-        type=int,
-        default=1,
-        help="The tensor parallel size to use for the test."
+    parser.addoption("--tensor-parallel-size",
+                     type=int,
+                     default=1,
+                     help="The tensor parallel size to use for the test."
     )
-    parser.addoption(
-        "--expected-values-file",
-        type=str,
-        default=None,
-        help="Path to a JSON file with expected accuracy values."
+    parser.addoption("--expected-values-file",
+                     type=str,
+                     default=None,
+                     help="Path to a JSON file with expected accuracy values."
     )
     parser.addoption(
         "--model-names",
         action="store",
         default=None,
-        help="Comma-separated list of model names to test (e.g., 'model1,model2')"
-    )
+        help=
+        "Comma-separated list of model names to test (e.g., 'model1,model2')")
     parser.addoption(
         "--fp8-kv-model-names",
         action="store",
         default=None,
-        help="Comma-separated list of model names to test fp8-kv (e.g., 'model1,model2')"
-    )
+        help=
+        "Comma-separated list of model names to test fp8-kv (e.g., 'model1,model2')"
+    )
diff --git a/scripts/vllm/integration/test_accuracy.py b/scripts/vllm/integration/test_accuracy.py
@@ -11,15 +11,15 @@
 AsyncLLMEngine are working correctly.
 """
 
-import lm_eval
-import pytest
 import json
-import threading
 import os
-
+import threading
 from pathlib import Path
 from vllm.platforms import current_platform
 
+import lm_eval
+import pytest
+
 MODEL_NAMES = [
     "Qwen/Qwen3-1.7B",
     "google/gemma-3-1b-it",
@@ -42,21 +42,30 @@
 }
 
 # Parametrize test cases based on CLI arguments or default values
-def parametrize_by_cli_or_default(metafunc, fixture_name, cli_parameter, default_list):
+def parametrize_by_cli_or_default(metafunc, fixture_name, cli_parameter, 
+                                  default_list):
     if fixture_name in metafunc.fixturenames:
         print(f"Checking CLI parameter '{cli_parameter}' for '{fixture_name}'")
         names_str = metafunc.config.getoption(cli_parameter)
         if names_str:
             print(f"Using '{cli_parameter}' parameter for '{fixture_name}'")
-            param_list = [name.strip() for name in names_str.split(',') if name.strip()]
+            param_list = [
+                name.strip() for name in names_str.split(',') if name.strip()
+            ]
             metafunc.parametrize(fixture_name, param_list)
         else:
             print(f"Using default list for '{fixture_name}'")
             metafunc.parametrize(fixture_name, default_list)
 
 def pytest_generate_tests(metafunc):
-    parametrize_by_cli_or_default(metafunc, fixture_name="model", cli_parameter="--model-names", default_list=MODEL_NAMES)
-    parametrize_by_cli_or_default(metafunc, fixture_name="fp8_kv_model", cli_parameter="--fp8-kv-model-names", default_list=FP8_KV_MODEL_NAMES)
+    parametrize_by_cli_or_default(metafunc, 
+                                  fixture_name="model", 
+                                  cli_parameter="--model-names", 
+                                  default_list=MODEL_NAMES)
+    parametrize_by_cli_or_default(metafunc, 
+                                  fixture_name="fp8_kv_model", 
+                                  cli_parameter="--fp8-kv-model-names", 
+                                  default_list=FP8_KV_MODEL_NAMES)
 
 # Write expected values to json file
 # TBD: To support the functionality of connecting GPU and TPU expected values in the future
@@ -67,17 +76,23 @@ def write_expected_value_to_json(model_name, measured_value, json_filepath):
             with open(json_filepath, 'r', encoding='utf-8') as f:
                 data = json.load(f)
         except (FileNotFoundError, json.JSONDecodeError):
-            print(f"'{json_filepath}' not found or is empty/invalid. A new one will be created.")
+            print(
+                f"'{json_filepath}' not found or is empty/invalid. A new one will be created."
+            )
             data = {}
         
         data[model_name] = measured_value
         
         try:
             with open(json_filepath, 'w', encoding='utf-8') as f:
                 json.dump(data, f, indent=4)
-            print(f"Successfully updated '{json_filepath}' with the result for {model_name}.")
+            print(
+                f"Successfully updated '{json_filepath}' with the result for {model_name}."
+            )
         except IOError as e:
-            print(f"Error: Failed to write to file '{json_filepath}'. Reason: {e}")
+            print(
+                f"Error: Failed to write to file '{json_filepath}'. Reason: {e}"
+            )
 
 # Read expected values from json file if exist
 # TBD: To support the functionality of connecting GPU and TPU expected values in the future
@@ -93,19 +108,24 @@ def read_expected_value(expected_json_filepath=None):
             with open(expected_json_filepath, 'r', encoding='utf-8') as f:
                 expected_values_data = json.load(f)
         else:
-            raise FileNotFoundError(f"Expected values file not found: {expected_json_filepath}")
+            raise FileNotFoundError(
+                f"Expected values file not found: {expected_json_filepath}")
     return expected_values_data
 
 
-def run_test(model_name, expected_values_data, expected_json_filepath, more_args=None):
+def run_test(model_name, 
+             expected_values_data, 
+             expected_json_filepath, 
+             more_args=None):
     """Run the end to end accuracy test."""
     print(f"Running test for model: {model_name}")
 
     model_args = f"pretrained={model_name},max_model_len=4096"
     
     download_path = "/mnt/disks/persist"
     # download_path = "/tmp/hf_model"
-    if os.path.isdir(download_path) and os.access(download_path, os.R_OK) and os.access(download_path, os.W_OK):
+    if os.path.isdir(download_path) and os.access(
+            download_path, os.R_OK) and os.access(download_path, os.W_OK):
         model_args = f"{model_args},download_dir={download_path}"
     
     if more_args is not None:
@@ -120,7 +140,7 @@ def run_test(model_name, expected_values_data, expected_json_filepath, more_args
 
     # Execute default behavior when `expected_json_filepath` is not set.
     if expected_json_filepath is None:
-        print(f"Execute default behavior")
+        print("Execute default behavior")
         measured_value = results["results"][TASK][FILTER]
         assert model_name in EXPECTED_VALUES, (
             f"Cannot find the expected value for the model {model_name=}")
@@ -129,27 +149,32 @@ def run_test(model_name, expected_values_data, expected_json_filepath, more_args
                 and measured_value + RTOL > expected_value
                 ), f"Expected: {expected_value} |  Measured: {measured_value}"
     else:
-        print(f"Execute specific models behavior")
+        print("Execute specific models behavior")
         measured_value = results["results"][TASK][FILTER]
         expected_value = expected_values_data.get(model_name)
 
         # Model expected value not exist, write in file
         if model_name not in expected_values_data:
             print(f"Warning: No expected value found for {model_name}. "
-                "Skipping accuracy check.")
+                  "Skipping accuracy check.")
             print(f"Measured value: {measured_value}")
-            write_expected_value_to_json(model_name, measured_value, expected_json_filepath)
+            write_expected_value_to_json(model_name, measured_value, 
+                                         expected_json_filepath)
 
         else:
-            print(f"Found expected value! {model_name=}, {measured_value=}, {expected_value=}")
-            assert (measured_value - RTOL < expected_value
+            print(
+                f"Found expected value! {model_name=}, {measured_value=}, {expected_value=}"
+            )
+            assert (
+                measured_value - RTOL < expected_value
                 and measured_value + RTOL > expected_value
-                ), f"Expected: {expected_value} |  Measured: {measured_value}"
+            ), f"Expected: {expected_value} |  Measured: {measured_value}"
 
 @pytest.mark.skipif(not current_platform.is_cuda()
                     and not current_platform.is_tpu(),
                     reason="V1 is currently only supported on CUDA and TPU")
-def test_lm_eval_accuracy_v1_engine(model, monkeypatch: pytest.MonkeyPatch, request: pytest.FixtureRequest):
+def test_lm_eval_accuracy_v1_engine(model, monkeypatch: pytest.MonkeyPatch, 
+                                    request: pytest.FixtureRequest):
     """Run with the V1 Engine."""
     print(f"Testing model: {model}...")
 
@@ -174,14 +199,16 @@ def test_lm_eval_accuracy_v1_engine(model, monkeypatch: pytest.MonkeyPatch, requ
         
         print(f"common args: {more_args}")
 
-        run_test(model, expected_values_data, expected_json_filepath, more_args)
+        run_test(model, expected_values_data, expected_json_filepath, 
+                 more_args)
 
 
 @pytest.mark.skipif(not current_platform.is_cuda()
                     and not current_platform.is_tpu(),
                     reason="V1 is currently only supported on CUDA and TPU")
 def test_lm_eval_accuracy_v1_engine_fp8_kv_cache(
-        fp8_kv_model, monkeypatch: pytest.MonkeyPatch, request: pytest.FixtureRequest):
+        fp8_kv_model, monkeypatch: pytest.MonkeyPatch, 
+        request: pytest.FixtureRequest):
     """Run with the V1 Engine."""
     print(f"Testing fp8_kv_model: {fp8_kv_model}...")
 
@@ -206,4 +233,5 @@ def test_lm_eval_accuracy_v1_engine_fp8_kv_cache(
             
         print(f"common args: {more_args}")
 
-        run_test(fp8_kv_model, expected_values_data, expected_json_filepath, more_args)
+        run_test(fp8_kv_model, expected_values_data, expected_json_filepath, 
+                 more_args)
diff --git a/tests/e2e/benchmarking/test_accuracy.sh b/tests/e2e/benchmarking/test_accuracy.sh
@@ -63,4 +63,4 @@ echo "--------------------------------------------------"
 # Default action
 python -m pytest -rP test_accuracy.py::test_lm_eval_accuracy_v1_engine --tensor-parallel-size="$tensor_parallel_size" --model-names="$comma_model_list"
 
-exit $exit_code
+exit $exit_code
