pre-commit fixes

lianakoleva · lianakoleva · commit cb4bfe3a28a2 · 2026-05-08T16:30:28.000-07:00
Signed-off-by: Liana Koleva &lt;43767763+lianakoleva@users.noreply.github.com&gt;
diff --git a/docs/cli-options.md b/docs/cli-options.md
@@ -118,8 +118,7 @@ aiperf profile --model your_model --url localhost:8000 --goodput "request_latenc
 
 #### `-m`, `--model-names`, `--model` `<list>`
 
-Model name(s) to be benchmarked. Can be a comma-separated list or a single model name.
-If omitted, `aiperf profile` attempts to auto-detect a model from `GET {url}/v1/models`.
+Model name(s) to be benchmarked. Can be a comma-separated list or a single model name. If omitted, `aiperf profile` will attempt to auto-detect a model from `GET {url}/v1/models`.
 
 #### `--model-selection-strategy` `<str>`
 
diff --git a/src/aiperf/cli_commands/profile.py b/src/aiperf/cli_commands/profile.py
@@ -3,6 +3,7 @@
 """CLI command for running the Profile subcommand."""
 
 import asyncio
+import logging
 
 from cyclopts import App
 
@@ -11,6 +12,79 @@
 app = App(name="profile")
 
 
+def _ensure_stderr_logging() -> None:
+    if not logging.getLogger().handlers:
+        logging.basicConfig(
+            level=logging.INFO,
+            format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
+        )
+
+
+def _request_headers_for_endpoint(user_config: UserConfig) -> dict[str, str]:
+    raw_headers = user_config.input.headers or []
+    headers = {str(k): str(v) for k, v in raw_headers}
+    if user_config.endpoint.api_key:
+        headers["Authorization"] = f"Bearer {user_config.endpoint.api_key}"
+    return headers
+
+
+def _maybe_autodiscover_models(user_config: UserConfig) -> None:
+    # If the user didn't provide --model/--model-names, try to discover
+    # one from the server's OpenAI-compatible model list.
+    if user_config.endpoint.model_names:
+        return
+
+    from aiperf.common.config.config_defaults import OutputDefaults
+    from aiperf.common.models.model_autodetect import (
+        autodetect_names,
+    )
+
+    # Install a basic stderr handler so the log message is visible even
+    # when `--wait-for-model-timeout` is left at the default (0).
+    _ensure_stderr_logging()
+
+    user_config.endpoint.model_names = asyncio.run(
+        autodetect_names(
+            urls=user_config.endpoint.urls,
+            headers=_request_headers_for_endpoint(user_config),
+        )
+    )
+
+    # `UserConfig` computed an artifact directory during config-load.
+    # If it used the default artifact directory (not overridden by the
+    # user), update it to reflect the discovered model name.
+    if "artifact_directory" not in user_config.output.model_fields_set:
+        user_config.output.artifact_directory = OutputDefaults.ARTIFACT_DIRECTORY
+        user_config.output.artifact_directory = (
+            user_config._compute_artifact_directory()
+        )
+
+
+def _maybe_wait_for_model(user_config: UserConfig) -> None:
+    if user_config.endpoint.wait_for_model_timeout <= 0:
+        return
+
+    from aiperf.common.readiness_probe import wait_for_endpoint
+
+    # The probe runs before `run_system_controller` (which installs
+    # rich logging), so there are no handlers attached yet. Install
+    # a basic stderr handler so probe log messages are visible.
+    _ensure_stderr_logging()
+
+    asyncio.run(
+        wait_for_endpoint(
+            urls=user_config.endpoint.urls,
+            model_names=user_config.endpoint.model_names,
+            mode=user_config.endpoint.wait_for_model_mode,
+            endpoint_type=str(user_config.endpoint.type),
+            custom_endpoint=user_config.endpoint.custom_endpoint,
+            timeout_s=user_config.endpoint.wait_for_model_timeout,
+            interval_s=user_config.endpoint.wait_for_model_interval,
+            headers=_request_headers_for_endpoint(user_config),
+        )
+    )
+
+
 @app.default
 def profile(
     user_config: UserConfig,
@@ -54,78 +128,6 @@ def profile(
         from aiperf.common.config.loader import load_service_config
 
         service_config = service_config or load_service_config()
-
-        # If the user didn't provide --model/--model-names, try to discover
-        # one from the server's OpenAI-compatible model list.
-        if not user_config.endpoint.model_names:
-            import logging
-
-            from aiperf.common.config.config_defaults import OutputDefaults
-            from aiperf.common.models.model_autodetect import (
-                autodetect_model_names_from_v1_models,
-            )
-
-            # Install a basic stderr handler so the log message is visible even
-            # when `--wait-for-model-timeout` is left at the default (0).
-            if not logging.getLogger().handlers:
-                logging.basicConfig(
-                    level=logging.INFO,
-                    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-                )
-
-            raw_headers = user_config.input.headers or []
-            headers = {str(k): str(v) for k, v in raw_headers}
-            if user_config.endpoint.api_key:
-                headers["Authorization"] = f"Bearer {user_config.endpoint.api_key}"
-
-            user_config.endpoint.model_names = asyncio.run(
-                autodetect_model_names_from_v1_models(
-                    urls=user_config.endpoint.urls,
-                    headers=headers,
-                )
-            )
-
-            # `UserConfig` computed an artifact directory during config-load.
-            # If it used the default artifact directory (not overridden by the
-            # user), update it to reflect the discovered model name.
-            if "artifact_directory" not in user_config.output.model_fields_set:
-                user_config.output.artifact_directory = (
-                    OutputDefaults.ARTIFACT_DIRECTORY
-                )
-                user_config.output.artifact_directory = (
-                    user_config._compute_artifact_directory()
-                )
-
-        if user_config.endpoint.wait_for_model_timeout > 0:
-            import logging
-
-            from aiperf.common.readiness_probe import wait_for_endpoint
-
-            # The probe runs before `run_system_controller` (which installs
-            # rich logging), so there are no handlers attached yet. Install
-            # a basic stderr handler so probe log messages are visible.
-            if not logging.getLogger().handlers:
-                logging.basicConfig(
-                    level=logging.INFO,
-                    format="%(asctime)s - %(name)s - %(levelname)s - %(message)s",
-                )
-
-            raw_headers = user_config.input.headers or []
-            headers = {str(k): str(v) for k, v in raw_headers}
-            if user_config.endpoint.api_key:
-                headers["Authorization"] = f"Bearer {user_config.endpoint.api_key}"
-
-            asyncio.run(
-                wait_for_endpoint(
-                    urls=user_config.endpoint.urls,
-                    model_names=user_config.endpoint.model_names,
-                    mode=user_config.endpoint.wait_for_model_mode,
-                    endpoint_type=str(user_config.endpoint.type),
-                    custom_endpoint=user_config.endpoint.custom_endpoint,
-                    timeout_s=user_config.endpoint.wait_for_model_timeout,
-                    interval_s=user_config.endpoint.wait_for_model_interval,
-                    headers=headers,
-                )
-            )
-
+        _maybe_autodiscover_models(user_config)
+        _maybe_wait_for_model(user_config)
         run_system_controller(user_config, service_config)
diff --git a/src/aiperf/common/models/model_autodetect.py b/src/aiperf/common/models/model_autodetect.py
@@ -19,71 +19,70 @@
 _logger = AIPerfLogger(__name__)
 
 
-async def autodetect_model_names_from_v1_models(
-    *,
-    urls: list[str],
-    headers: dict[str, str],
-    timeout_s: float = 10.0,
-) -> list[str]:
-    """Fetch `GET {url}/v1/models` and return a best-effort model list.
-
-    Selection strategy: return only the first discovered model id.
-    """
-
-    if not urls:
-        raise ValueError("Autodetection requires at least one --url base URL")
-
-    # Use the first URL for discovery. If you have multiple URLs with
-    # different model sets, you should pass --model explicitly.
-    base_url = urls[0].rstrip("/")
-    models_url = base_url + "/v1/models"
-
-    client = AioHttpClient(timeout=timeout_s)
-    try:
-        record = await client.get_request(models_url, headers=headers)
-    finally:
-        await client.close()
-
-    status = record.status
-    if status != 200:
+def _extract_body_text(record: Any, models_url: str) -> str:
+    if record.status != 200:
         raise ValueError(
-            f"Failed to auto-detect models from {models_url}: HTTP status={status}"
+            f"Failed to auto-detect models from {models_url}: HTTP status={record.status}"
         )
-
     if not record.responses:
         raise ValueError(f"Empty response body while autodetecting {models_url}")
-
-    response_obj: Any = record.responses[0]
-    body_text = getattr(response_obj, "text", None)
+    body_text = getattr(record.responses[0], "text", None)
     if not isinstance(body_text, str) or not body_text:
         raise ValueError(f"Non-text response while autodetecting {models_url}")
+    return body_text
+
 
+def _extract_ids_from_payload(body_text: str, models_url: str) -> list[str]:
     try:
         payload = orjson.loads(body_text)
     except orjson.JSONDecodeError as e:
         raise ValueError(
             f"Invalid JSON returned from {models_url} while autodetecting models"
         ) from e
-
     if not isinstance(payload, dict):
         raise ValueError(f"Unexpected /v1/models response shape from {models_url}")
-
     data = payload.get("data")
     if not isinstance(data, list):
         raise ValueError(
             f"Unexpected /v1/models response: missing data[] in {models_url}"
         )
-
-    ids: list[str] = []
-    for entry in data:
-        if isinstance(entry, dict):
-            model_id = entry.get("id")
-            if isinstance(model_id, str) and model_id:
-                ids.append(model_id)
-
+    ids = [
+        entry["id"]
+        for entry in data
+        if isinstance(entry, dict)
+        and isinstance(entry.get("id"), str)
+        and entry.get("id")
+    ]
     if not ids:
         raise ValueError(f"No model ids found in /v1/models response from {models_url}")
+    return ids
+
+
+async def autodetect_names(
+    *,
+    urls: list[str],
+    headers: dict[str, str],
+    timeout_s: float = 10.0,
+) -> list[str]:
+    """Fetch `GET {url}/v1/models` and return a best-effort model list.
+
+    Selection strategy: return only the first discovered model id.
+    """
+    if not urls:
+        raise ValueError("Autodetection requires at least one --url base URL")
+
+    # Use the first URL for discovery. If you have multiple URLs with
+    # different model sets, you should pass --model explicitly.
+    base_url = urls[0].rstrip("/")
+    models_url = base_url + "/v1/models"
+
+    client = AioHttpClient(timeout=timeout_s)
+    try:
+        record = await client.get_request(models_url, headers=headers)
+    finally:
+        await client.close()
 
+    ids = _extract_ids_from_payload(_extract_body_text(record, models_url), models_url)
     chosen = ids[0]
     if len(ids) > 1:
         _logger.warning(
diff --git a/tests/unit/common/test_model_autodetect.py b/tests/unit/common/test_model_autodetect.py
@@ -9,9 +9,7 @@
 import orjson
 import pytest
 
-from aiperf.common.models.model_autodetect import (
-    autodetect_model_names_from_v1_models,
-)
+from aiperf.common.models.model_autodetect import autodetect_names
 
 
 class _FakeRecord:
@@ -67,7 +65,7 @@ def test_autodetect_picks_first_id_from_data(
     fake = _install_fake_aiohttp(monkeypatch, status=200, body_text=body_text)
 
     result = asyncio.run(
-        autodetect_model_names_from_v1_models(
+        autodetect_names(
             urls=["http://localhost:8000"],
             headers={"Authorization": "Bearer token"},
             timeout_s=1.0,
@@ -93,7 +91,7 @@ def test_autodetect_single_model_logs_info_not_warning(
     _install_fake_aiohttp(monkeypatch, status=200, body_text=body_text)
 
     asyncio.run(
-        autodetect_model_names_from_v1_models(
+        autodetect_names(
             urls=["http://localhost:8000"],
             headers={},
             timeout_s=1.0,
@@ -110,7 +108,7 @@ def test_autodetect_raises_on_non_200(monkeypatch: pytest.MonkeyPatch) -> None:
 
     with pytest.raises(ValueError, match="Failed to auto-detect models"):
         asyncio.run(
-            autodetect_model_names_from_v1_models(
+            autodetect_names(
                 urls=["http://localhost:8000"],
                 headers={},
                 timeout_s=1.0,
