style: ruff format entire codebase

35 files were never formatted with ruff. Applying consistent formatting
to pass the new ruff format --check CI step.

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: Tremayne Timms

src/diagnostics/clock_throttle.py

@@ -75,48 +75,41 @@ def _get_throttle_reasons(gpu_index: int) -> dict:
 
             # Get current throttle reasons
             try:
-                throttle_reasons = (
-                    pynvml.nvmlDeviceGetCurrentClocksThrottleReasons(
-                        handle
-                    )
-                )
+                throttle_reasons = pynvml.nvmlDeviceGetCurrentClocksThrottleReasons(handle)
             except (pynvml.NVMLError, AttributeError):
                 throttle_reasons = 0
 
             # Get supported throttle reasons
             try:
-                supported = (
-                    pynvml.nvmlDeviceGetSupportedClocksThrottleReasons(
-                        handle
-                    )
-                )
+                supported = pynvml.nvmlDeviceGetSupportedClocksThrottleReasons(handle)
             except (pynvml.NVMLError, AttributeError):
                 supported = 0xFFFFFFFF
 
             # Get current clocks for context
             try:
                 graphics_clock = pynvml.nvmlDeviceGetClockInfo(
-                    handle, 0  # NVML_CLOCK_GRAPHICS
+                    handle,
+                    0,  # NVML_CLOCK_GRAPHICS
                 )
             except pynvml.NVMLError:
                 graphics_clock = 0
 
             try:
-                max_graphics = pynvml.nvmlDeviceGetMaxClockInfo(
-                    handle, 0
-                )
+                max_graphics = pynvml.nvmlDeviceGetMaxClockInfo(handle, 0)
             except pynvml.NVMLError:
                 max_graphics = 0
 
             # Parse active throttle reasons
             active_reasons = []
             for bit, name in THROTTLE_REASONS.items():
                 if throttle_reasons & bit:
-                    active_reasons.append({
-                        "bit": hex(bit),
-                        "reason": name,
-                        "is_problem": bit in PROBLEM_THROTTLE_BITS,
-                    })
+                    active_reasons.append(
+                        {
+                            "bit": hex(bit),
+                            "reason": name,
+                            "is_problem": bit in PROBLEM_THROTTLE_BITS,
+                        }
+                    )
 
             return {
                 "throttle_bitmask": hex(throttle_reasons),
@@ -125,11 +118,7 @@ def _get_throttle_reasons(gpu_index: int) -> dict:
                 "graphics_clock_mhz": graphics_clock,
                 "max_graphics_clock_mhz": max_graphics,
                 "clock_reduction_pct": (
-                    round(
-                        (1 - graphics_clock / max_graphics) * 100, 1
-                    )
-                    if max_graphics > 0
-                    else 0
+                    round((1 - graphics_clock / max_graphics) * 100, 1) if max_graphics > 0 else 0
                 ),
             }
         finally:
@@ -152,20 +141,17 @@ def _check_clock_throttling(
             test_name="telemetry.clock_throttle",
             status=TestStatus.SKIP,
             duration_seconds=time.time() - start,
-            message=(
-                f"Could not query throttle reasons: "
-                f"{throttle_data['error']}"
-            ),
+            message=(f"Could not query throttle reasons: {throttle_data['error']}"),
             gpu_uuid=gpu.uuid,
             details=throttle_data,
         )
 
     active = throttle_data.get("active_reasons", [])
     problem_reasons = [r for r in active if r.get("is_problem")]
     unexpected_reasons = [
-        r for r in active
-        if not r.get("is_problem")
-        and int(r["bit"], 16) not in NORMAL_THROTTLE_BITS
+        r
+        for r in active
+        if not r.get("is_problem") and int(r["bit"], 16) not in NORMAL_THROTTLE_BITS
     ]
 
     details = {
@@ -182,10 +168,7 @@ def _check_clock_throttling(
             test_name="telemetry.clock_throttle",
             status=TestStatus.FAIL,
             duration_seconds=time.time() - start,
-            message=(
-                f"GPU throttled: {', '.join(reason_names)} "
-                f"(clock reduced {reduction}%)"
-            ),
+            message=(f"GPU throttled: {', '.join(reason_names)} (clock reduced {reduction}%)"),
             failure_code="DIAG-910",
             gpu_uuid=gpu.uuid,
             details=details,
@@ -197,10 +180,7 @@ def _check_clock_throttling(
             test_name="telemetry.clock_throttle",
             status=TestStatus.WARN,
             duration_seconds=time.time() - start,
-            message=(
-                f"Unexpected clock limiting active: "
-                f"{', '.join(reason_names)}"
-            ),
+            message=(f"Unexpected clock limiting active: {', '.join(reason_names)}"),
             gpu_uuid=gpu.uuid,
             details=details,
         )
@@ -220,6 +200,4 @@ def run_clock_throttle_checks(
     profile: dict[str, Any],
 ) -> list[TestResult]:
     """Execute clock throttle analysis on all GPUs."""
-    return [
-        _check_clock_throttling(gpu, profile) for gpu in gpu_infos
-    ]
+    return [_check_clock_throttling(gpu, profile) for gpu in gpu_infos]

src/diagnostics/compute_stress.py

@@ -96,10 +96,12 @@ def _run_compute_stress(
                             temp = _pynvml.nvmlDeviceGetTemperature(
                                 handle, _pynvml.NVML_TEMPERATURE_GPU
                             )
-                            temp_samples.append({
-                                "time_s": round(now - stress_start, 1),
-                                "temp_c": temp,
-                            })
+                            temp_samples.append(
+                                {
+                                    "time_s": round(now - stress_start, 1),
+                                    "temp_c": temp,
+                                }
+                            )
                             _pynvml.nvmlShutdown()
                         except Exception:
                             pass
@@ -134,7 +136,7 @@ def _run_compute_stress(
                 status=TestStatus.FAIL,
                 duration_seconds=time.time() - start,
                 message=f"Compute stress failed with {len(errors)} error(s) "
-                        f"after {iteration_count} iterations",
+                f"after {iteration_count} iterations",
                 failure_code="DIAG-600",
                 gpu_uuid=gpu.uuid,
                 details=details,
@@ -146,7 +148,7 @@ def _run_compute_stress(
                 status=TestStatus.WARN,
                 duration_seconds=time.time() - start,
                 message=f"Stress test ended early: {stress_duration:.1f}s "
-                        f"of {duration_seconds}s target",
+                f"of {duration_seconds}s target",
                 gpu_uuid=gpu.uuid,
                 details=details,
             )
@@ -156,7 +158,7 @@ def _run_compute_stress(
             status=TestStatus.PASS,
             duration_seconds=time.time() - start,
             message=f"Compute stress OK: {iteration_count} GEMM ops, "
-                    f"{gflops:.0f} GFLOPS over {stress_duration:.1f}s",
+            f"{gflops:.0f} GFLOPS over {stress_duration:.1f}s",
             gpu_uuid=gpu.uuid,
             details=details,
         )

src/diagnostics/deployment.py

@@ -123,19 +123,13 @@ def _check_ecc_mode(gpu_infos: list[GPUInfo], profile: dict[str, Any]) -> TestRe
     results = []
     for gpu in gpu_infos:
         if not ecc_supported:
-            results.append(
-                {"index": gpu.index, "ecc_mode": gpu.ecc_mode, "status": "SKIP"}
-            )
+            results.append({"index": gpu.index, "ecc_mode": gpu.ecc_mode, "status": "SKIP"})
         elif ecc_expected is not None:
             expected_str = "enabled" if ecc_expected else "disabled"
             if gpu.ecc_mode == expected_str:
-                results.append(
-                    {"index": gpu.index, "ecc_mode": gpu.ecc_mode, "status": "PASS"}
-                )
+                results.append({"index": gpu.index, "ecc_mode": gpu.ecc_mode, "status": "PASS"})
             else:
-                results.append(
-                    {"index": gpu.index, "ecc_mode": gpu.ecc_mode, "status": "FAIL"}
-                )
+                results.append({"index": gpu.index, "ecc_mode": gpu.ecc_mode, "status": "FAIL"})
 
     if not ecc_supported:
         return TestResult(
@@ -177,8 +171,7 @@ def _check_gpu_processes(gpu_infos: list[GPUInfo]) -> TestResult:
         try:
             procs = pynvml.nvmlDeviceGetComputeRunningProcesses(handle)
             heavy = [
-                p for p in procs
-                if (p.usedGpuMemory or 0) > COMPUTE_VRAM_THRESHOLD_MB * 1024 * 1024
+                p for p in procs if (p.usedGpuMemory or 0) > COMPUTE_VRAM_THRESHOLD_MB * 1024 * 1024
             ]
             if heavy:
                 busy_gpus.append(

src/diagnostics/ecc_health.py

@@ -30,23 +30,19 @@ def _query_ecc_counters(gpu_index: int) -> dict:
             vol_sbe = 0
             vol_dbe = 0
             try:
-                vol_sbe = (
-                    pynvml.nvmlDeviceGetTotalEccErrors(
-                        handle,
-                        pynvml.NVML_SINGLE_BIT_ECC,
-                        pynvml.NVML_VOLATILE_ECC,
-                    )
+                vol_sbe = pynvml.nvmlDeviceGetTotalEccErrors(
+                    handle,
+                    pynvml.NVML_SINGLE_BIT_ECC,
+                    pynvml.NVML_VOLATILE_ECC,
                 )
             except (pynvml.NVMLError, AttributeError):
                 vol_sbe = -1  # Not supported
 
             try:
-                vol_dbe = (
-                    pynvml.nvmlDeviceGetTotalEccErrors(
-                        handle,
-                        pynvml.NVML_DOUBLE_BIT_ECC,
-                        pynvml.NVML_VOLATILE_ECC,
-                    )
+                vol_dbe = pynvml.nvmlDeviceGetTotalEccErrors(
+                    handle,
+                    pynvml.NVML_DOUBLE_BIT_ECC,
+                    pynvml.NVML_VOLATILE_ECC,
                 )
             except (pynvml.NVMLError, AttributeError):
                 vol_dbe = -1
@@ -55,23 +51,19 @@ def _query_ecc_counters(gpu_index: int) -> dict:
             agg_sbe = 0
             agg_dbe = 0
             try:
-                agg_sbe = (
-                    pynvml.nvmlDeviceGetTotalEccErrors(
-                        handle,
-                        pynvml.NVML_SINGLE_BIT_ECC,
-                        pynvml.NVML_AGGREGATE_ECC,
-                    )
+                agg_sbe = pynvml.nvmlDeviceGetTotalEccErrors(
+                    handle,
+                    pynvml.NVML_SINGLE_BIT_ECC,
+                    pynvml.NVML_AGGREGATE_ECC,
                 )
             except (pynvml.NVMLError, AttributeError):
                 agg_sbe = -1
 
             try:
-                agg_dbe = (
-                    pynvml.nvmlDeviceGetTotalEccErrors(
-                        handle,
-                        pynvml.NVML_DOUBLE_BIT_ECC,
-                        pynvml.NVML_AGGREGATE_ECC,
-                    )
+                agg_dbe = pynvml.nvmlDeviceGetTotalEccErrors(
+                    handle,
+                    pynvml.NVML_DOUBLE_BIT_ECC,
+                    pynvml.NVML_AGGREGATE_ECC,
                 )
             except (pynvml.NVMLError, AttributeError):
                 agg_dbe = -1
@@ -80,23 +72,19 @@ def _query_ecc_counters(gpu_index: int) -> dict:
             retired_sbe = 0
             retired_dbe = 0
             try:
-                retired_sbe = (
-                    pynvml.nvmlDeviceGetRetiredPages(
-                        handle,
-                        pynvml.NVML_PAGE_RETIREMENT_CAUSE_MULTIPLE_SINGLE_BIT_ECC_ERRORS,
-                    )
+                retired_sbe = pynvml.nvmlDeviceGetRetiredPages(
+                    handle,
+                    pynvml.NVML_PAGE_RETIREMENT_CAUSE_MULTIPLE_SINGLE_BIT_ECC_ERRORS,
                 )
                 if isinstance(retired_sbe, (list, tuple)):
                     retired_sbe = len(retired_sbe)
             except (pynvml.NVMLError, AttributeError):
                 retired_sbe = -1
 
             try:
-                retired_dbe = (
-                    pynvml.nvmlDeviceGetRetiredPages(
-                        handle,
-                        pynvml.NVML_PAGE_RETIREMENT_CAUSE_DOUBLE_BIT_ECC_ERROR,
-                    )
+                retired_dbe = pynvml.nvmlDeviceGetRetiredPages(
+                    handle,
+                    pynvml.NVML_PAGE_RETIREMENT_CAUSE_DOUBLE_BIT_ECC_ERROR,
                 )
                 if isinstance(retired_dbe, (list, tuple)):
                     retired_dbe = len(retired_dbe)
@@ -106,9 +94,7 @@ def _query_ecc_counters(gpu_index: int) -> dict:
             # Pending retired pages
             pending_retirement = False
             try:
-                pending = (
-                    pynvml.nvmlDeviceGetRetiredPages_v2(handle)
-                )
+                pending = pynvml.nvmlDeviceGetRetiredPages_v2(handle)
                 if pending:
                     pending_retirement = True
             except (pynvml.NVMLError, AttributeError):
@@ -118,9 +104,7 @@ def _query_ecc_counters(gpu_index: int) -> dict:
             remapped_rows = {}
             try:
                 remapped = pynvml.nvmlDeviceGetRemappedRows(handle)
-                correctable, uncorrectable, pending_remap, failure = (
-                    remapped
-                )
+                correctable, uncorrectable, pending_remap, failure = remapped
                 remapped_rows = {
                     "correctable": correctable,
                     "uncorrectable": uncorrectable,
@@ -168,10 +152,7 @@ def _check_ecc_health(
                 test_name="telemetry.ecc_health",
                 status=TestStatus.SKIP,
                 duration_seconds=time.time() - start,
-                message=(
-                    "ECC not supported on this GPU "
-                    f"({gpu.name})"
-                ),
+                message=(f"ECC not supported on this GPU ({gpu.name})"),
                 gpu_uuid=gpu.uuid,
                 details={"ecc_mode": gpu.ecc_mode},
             )
@@ -183,10 +164,7 @@ def _check_ecc_health(
             test_name="telemetry.ecc_health",
             status=TestStatus.SKIP,
             duration_seconds=time.time() - start,
-            message=(
-                f"ECC query failed: "
-                f"{counters.get('error', 'unknown')}"
-            ),
+            message=(f"ECC query failed: {counters.get('error', 'unknown')}"),
             gpu_uuid=gpu.uuid,
             details=counters,
         )
@@ -256,9 +234,7 @@ def _check_ecc_health(
             test_name="telemetry.ecc_health",
             status=TestStatus.WARN,
             duration_seconds=time.time() - start,
-            message=(
-                "Pages pending retirement — reboot recommended"
-            ),
+            message=("Pages pending retirement — reboot recommended"),
             gpu_uuid=gpu.uuid,
             details=details,
         )
@@ -282,6 +258,4 @@ def run_ecc_health_checks(
     profile: dict[str, Any],
 ) -> list[TestResult]:
     """Execute ECC health analysis on all GPUs."""
-    return [
-        _check_ecc_health(gpu, profile) for gpu in gpu_infos
-    ]
+    return [_check_ecc_health(gpu, profile) for gpu in gpu_infos]