Run ruff format on inference-monitor and training-monitor

The lint fixes introduced formatting inconsistencies that ruff format
--check catches in CI. Run the formatter to bring all files in line.

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: DannyWall92

inference-monitor/src/sentinel_inference/analyzers/kl_divergence.py

@@ -162,9 +162,7 @@ def submit(
 
                 if divergence > self._config.threshold_nats:
                     severity = (
-                        "critical"
-                        if divergence > self._config.threshold_nats * 10
-                        else "warning"
+                        "critical" if divergence > self._config.threshold_nats * 10 else "warning"
                     )
                     anomalies.append(
                         AnomalyEvent(

inference-monitor/src/sentinel_inference/analyzers/logit_analyzer.py

@@ -67,7 +67,10 @@ class EWMATracker:
     )
 
     def __init__(
-        self, lambda_: float = 0.1, control_limit: float = 3.5, burn_in: int = 1000,
+        self,
+        lambda_: float = 0.1,
+        control_limit: float = 3.5,
+        burn_in: int = 1000,
     ) -> None:
         self._lambda = lambda_
         self._L = control_limit
@@ -129,7 +132,7 @@ def update(self, value: float) -> bool:
 
         # Welford-style running mean and variance for target & sigma
         self._target = self._sum / self._count
-        variance = (self._sum_sq / self._count) - (self._target ** 2)
+        variance = (self._sum_sq / self._count) - (self._target**2)
         self._sigma = np.sqrt(max(variance, 1e-15))
 
         # EWMA update

inference-monitor/src/sentinel_inference/analyzers/statistical_tests.py

@@ -44,9 +44,7 @@ def baseline_size(self) -> int:
     def _rebuild_baseline(self) -> None:
         """Concatenate baseline samples into a single array for testing."""
         if self._baseline:
-            self._baseline_flat = np.concatenate(
-                [s.ravel() for s in self._baseline]
-            )
+            self._baseline_flat = np.concatenate([s.ravel() for s in self._baseline])
         else:
             self._baseline_flat = None
         self._needs_rebuild = False

inference-monitor/src/sentinel_inference/grpc_client.py

@@ -37,14 +37,14 @@
 
 # Anomaly type mapping from analyzer names to proto enum values.
 _ANOMALY_TYPE_MAP: dict[str, int] = {
-    "logit_analyzer": 1,        # ANOMALY_TYPE_LOGIT_DRIFT
-    "entropy_analyzer": 2,      # ANOMALY_TYPE_ENTROPY_ANOMALY
-    "kl_divergence": 3,         # ANOMALY_TYPE_KL_DIVERGENCE
-    "gradient_monitor": 4,      # ANOMALY_TYPE_GRADIENT_NORM_SPIKE
-    "loss_monitor": 5,          # ANOMALY_TYPE_LOSS_SPIKE
-    "ddp_divergence": 6,        # ANOMALY_TYPE_CROSS_RANK_DIVERGENCE
+    "logit_analyzer": 1,  # ANOMALY_TYPE_LOGIT_DRIFT
+    "entropy_analyzer": 2,  # ANOMALY_TYPE_ENTROPY_ANOMALY
+    "kl_divergence": 3,  # ANOMALY_TYPE_KL_DIVERGENCE
+    "gradient_monitor": 4,  # ANOMALY_TYPE_GRADIENT_NORM_SPIKE
+    "loss_monitor": 5,  # ANOMALY_TYPE_LOSS_SPIKE
+    "ddp_divergence": 6,  # ANOMALY_TYPE_CROSS_RANK_DIVERGENCE
     "checkpoint_validator": 7,  # ANOMALY_TYPE_CHECKPOINT_DIVERGENCE
-    "invariant_checker": 8,     # ANOMALY_TYPE_INVARIANT_VIOLATION
+    "invariant_checker": 8,  # ANOMALY_TYPE_INVARIANT_VIOLATION
 }
 
 # Severity mapping from string labels to proto enum values.
@@ -174,8 +174,11 @@ async def start(self) -> None:
 
             # Try to import the generated protobuf stubs.
             self._stub = self._create_stub()
-            logger.info("grpc_client_started", endpoint=self._config.endpoint,
-                        proto_stubs=self._proto_available)
+            logger.info(
+                "grpc_client_started",
+                endpoint=self._config.endpoint,
+                proto_stubs=self._proto_available,
+            )
         except ImportError:
             logger.warning("grpc_not_available", msg="Running without gRPC reporting.")
             self._channel = None
@@ -187,13 +190,15 @@ def _create_stub(self) -> Any:
         """Create the AnomalyService stub, trying generated stubs first."""
         try:
             from sentinel.v1 import anomaly_pb2_grpc  # type: ignore[import-untyped]
+
             stub = anomaly_pb2_grpc.AnomalyServiceStub(self._channel)
             self._proto_available = True
             logger.debug("using_generated_proto_stubs")
             return stub
         except ImportError:
-            logger.debug("generated_proto_stubs_not_found",
-                         msg="Falling back to manual serialization")
+            logger.debug(
+                "generated_proto_stubs_not_found", msg="Falling back to manual serialization"
+            )
             self._proto_available = False
             return None
 
@@ -217,8 +222,7 @@ async def stop(self) -> None:
             self._stream = None
         if self._channel is not None:
             await self._channel.close()
-        logger.info("grpc_client_stopped",
-                     pending_acks=len(self._pending_acks))
+        logger.info("grpc_client_stopped", pending_acks=len(self._pending_acks))
 
     # ------------------------------------------------------------------
     # Event submission
@@ -283,9 +287,7 @@ def _event_to_proto_dict(self, event: AnomalyEvent) -> dict[str, Any]:
         else:
             severity_val = _SEVERITY_MAP.get(str(severity_str).lower(), 2)
 
-        anomaly_type_val = _ANOMALY_TYPE_MAP.get(
-            getattr(event, "analyzer", ""), 0
-        )
+        anomaly_type_val = _ANOMALY_TYPE_MAP.get(getattr(event, "analyzer", ""), 0)
 
         # Generate a deterministic event ID from content hash.
         content = f"{event.analyzer}:{event.stat_name}:{event.sample_count}:{event.observed_value}"
@@ -307,9 +309,7 @@ def _event_to_proto_dict(self, event: AnomalyEvent) -> dict[str, Any]:
                 f"{event.analyzer}/{event.stat_name}: observed={event.observed_value:.6f}, "
                 f"ewma={event.ewma_value:.6f}, ucl={event.ucl}, lcl={event.lcl}"
             ),
-            "tensor_fingerprint": hashlib.sha256(
-                f"{event.observed_value}".encode()
-            ).digest()[:16],
+            "tensor_fingerprint": hashlib.sha256(f"{event.observed_value}".encode()).digest()[:16],
             "timestamp": time.time(),
             "metadata": event.details if isinstance(event.details, dict) else {},
             "step_number": event.sample_count,
@@ -428,9 +428,7 @@ async def _do_send_proto(self, report: AnomalyReport) -> None:
         if self._stream is None:
             self._stream = self._stub.StreamAnomalyEvents()
             # Start background ack reader.
-            self._ack_task = asyncio.create_task(
-                self._read_acks_proto()
-            )
+            self._ack_task = asyncio.create_task(self._read_acks_proto())
 
         self._pending_acks[report.sequence_number] = time.time()
         await self._stream.write(batch)
@@ -470,13 +468,15 @@ async def _do_send_manual(self, report: AnomalyReport) -> None:
         """
         import json
 
-
-        payload = json.dumps({
-            "source_hostname": report.source_hostname,
-            "sequence_number": report.sequence_number,
-            "batch_timestamp": {"seconds": int(report.timestamp)},
-            "events": report.events,
-        }, default=str).encode("utf-8")
+        payload = json.dumps(
+            {
+                "source_hostname": report.source_hostname,
+                "sequence_number": report.sequence_number,
+                "batch_timestamp": {"seconds": int(report.timestamp)},
+                "events": report.events,
+            },
+            default=str,
+        ).encode("utf-8")
 
         call = self._channel.unary_unary(
             "/sentinel.v1.AnomalyService/StreamAnomalyEvents",

inference-monitor/src/sentinel_inference/interceptors/triton_interceptor.py

@@ -125,12 +125,16 @@ async def capture_output(self) -> TensorCapture | None:
         for s in shape:
             num_elements *= s
 
-        tensor = np.frombuffer(
-            buf,
-            dtype=np.float32,
-            count=num_elements,
-            offset=offset,
-        ).reshape(shape).copy()
+        tensor = (
+            np.frombuffer(
+                buf,
+                dtype=np.float32,
+                count=num_elements,
+                offset=offset,
+            )
+            .reshape(shape)
+            .copy()
+        )
 
         # Clear ready flag
         struct.pack_into("<I", buf, 4, flags & ~1)

inference-monitor/src/sentinel_inference/monitor.py

@@ -246,16 +246,15 @@ async def _analyzer_worker(self, worker_id: int) -> None:
             all_anomalies: list[AnomalyEvent] = []
 
             try:
-                all_anomalies.extend(
-                    await self._run_analysis(capture, labels)
-                )
+                all_anomalies.extend(await self._run_analysis(capture, labels))
             except Exception:
                 logger.exception("analyzer_worker_error", worker_id=worker_id)
 
             if all_anomalies:
                 for event in all_anomalies:
                     ANOMALIES_TOTAL.labels(
-                        **labels, type=event.analyzer,
+                        **labels,
+                        type=event.analyzer,
                     ).inc()
                 await self._grpc_client.submit(all_anomalies)
 
@@ -274,22 +273,14 @@ async def _run_analysis(
 
         # Logit analyzer
         t0 = time.monotonic()
-        result = await loop.run_in_executor(
-            None, self._logit_analyzer.analyze, capture.tensor
-        )
-        ANALYSIS_DURATION.labels(**labels, analyzer="logit").observe(
-            time.monotonic() - t0
-        )
+        result = await loop.run_in_executor(None, self._logit_analyzer.analyze, capture.tensor)
+        ANALYSIS_DURATION.labels(**labels, analyzer="logit").observe(time.monotonic() - t0)
         anomalies.extend(result)
 
         # Entropy analyzer
         t0 = time.monotonic()
-        result = await loop.run_in_executor(
-            None, self._entropy_analyzer.analyze, capture.tensor
-        )
-        ANALYSIS_DURATION.labels(**labels, analyzer="entropy").observe(
-            time.monotonic() - t0
-        )
+        result = await loop.run_in_executor(None, self._entropy_analyzer.analyze, capture.tensor)
+        ANALYSIS_DURATION.labels(**labels, analyzer="entropy").observe(time.monotonic() - t0)
         anomalies.extend(result)
 
         # KL divergence (cross-replica)
@@ -302,35 +293,25 @@ async def _run_analysis(
             capture.request_id,
             None,
         )
-        ANALYSIS_DURATION.labels(**labels, analyzer="kl_divergence").observe(
-            time.monotonic() - t0
-        )
+        ANALYSIS_DURATION.labels(**labels, analyzer="kl_divergence").observe(time.monotonic() - t0)
         anomalies.extend(result)
 
         # Spectral analyzer
         t0 = time.monotonic()
-        result = await loop.run_in_executor(
-            None, self._spectral_analyzer.analyze, capture.tensor
-        )
-        ANALYSIS_DURATION.labels(**labels, analyzer="spectral").observe(
-            time.monotonic() - t0
-        )
+        result = await loop.run_in_executor(None, self._spectral_analyzer.analyze, capture.tensor)
+        ANALYSIS_DURATION.labels(**labels, analyzer="spectral").observe(time.monotonic() - t0)
         anomalies.extend(result)
 
         # Statistical tests
         t0 = time.monotonic()
-        result = await loop.run_in_executor(
-            None, self._stat_tests.analyze, capture.tensor
-        )
+        result = await loop.run_in_executor(None, self._stat_tests.analyze, capture.tensor)
         ANALYSIS_DURATION.labels(**labels, analyzer="statistical_tests").observe(
             time.monotonic() - t0
         )
         anomalies.extend(result)
 
         # Tensor fingerprint (for logging / future use)
-        _fp = await loop.run_in_executor(
-            None, self._fingerprinter.compute, capture.tensor
-        )
+        _fp = await loop.run_in_executor(None, self._fingerprinter.compute, capture.tensor)
 
         # Update token sketches if tensor looks like token IDs
         if capture.tensor.ndim >= 1:
@@ -408,6 +389,7 @@ def main() -> None:
     if sys.platform != "win32":
         try:
             import uvloop
+
             asyncio.set_event_loop_policy(uvloop.EventLoopPolicy())
             logger.info("using_uvloop")
         except ImportError:

inference-monitor/tests/unit/test_kl_divergence.py

@@ -65,9 +65,7 @@ def test_identical_distributions(self) -> None:
     def test_symmetric(self) -> None:
         p = np.array([0.9, 0.1])
         q = np.array([0.1, 0.9])
-        assert abs(
-            jensen_shannon_divergence(p, q) - jensen_shannon_divergence(q, p)
-        ) < 1e-10
+        assert abs(jensen_shannon_divergence(p, q) - jensen_shannon_divergence(q, p)) < 1e-10
 
     def test_bounded(self) -> None:
         """JSD should be in [0, ln(2)]."""
@@ -96,15 +94,11 @@ def test_no_anomaly_same_output(self) -> None:
         input_hash = "test_hash_1"
 
         # Submit from replica A
-        events_a = detector.submit(
-            logits, input_hash, "req1", replica_id="replica_a"
-        )
+        events_a = detector.submit(logits, input_hash, "req1", replica_id="replica_a")
         assert len(events_a) == 0
 
         # Submit same logits from replica B
-        events_b = detector.submit(
-            logits, input_hash, "req2", replica_id="replica_b"
-        )
+        events_b = detector.submit(logits, input_hash, "req2", replica_id="replica_b")
         assert len(events_b) == 0
 
     def test_detects_divergent_outputs(self) -> None:
@@ -118,9 +112,7 @@ def test_detects_divergent_outputs(self) -> None:
         input_hash = "test_hash_2"
 
         detector.submit(logits_a, input_hash, "req1", replica_id="replica_a")
-        events = detector.submit(
-            logits_b, input_hash, "req2", replica_id="replica_b"
-        )
+        events = detector.submit(logits_b, input_hash, "req2", replica_id="replica_b")
         assert len(events) > 0
         assert events[0].analyzer == "kl_divergence"
 
@@ -135,9 +127,7 @@ def test_same_replica_ignored(self) -> None:
         input_hash = "test_hash_3"
 
         detector.submit(logits_a, input_hash, "req1", replica_id="replica_a")
-        events = detector.submit(
-            logits_b, input_hash, "req2", replica_id="replica_a"
-        )
+        events = detector.submit(logits_b, input_hash, "req2", replica_id="replica_a")
         assert len(events) == 0
 
     def test_different_input_hash_not_matched(self) -> None:

inference-monitor/tests/unit/test_logit_analyzer.py

@@ -136,9 +136,7 @@ class TestLogitAnalyzer:
     """Integration tests for the full LogitAnalyzer."""
 
     def test_no_anomalies_during_burn_in(self) -> None:
-        config = LogitAnalyzerConfig(
-            ewma=EWMAConfig(**{"lambda": 0.1, "L": 3.5, "burn_in": 100})
-        )
+        config = LogitAnalyzerConfig(ewma=EWMAConfig(**{"lambda": 0.1, "L": 3.5, "burn_in": 100}))
         analyzer = LogitAnalyzer(config)
         rng = np.random.default_rng(42)
         for _ in range(99):
@@ -148,9 +146,7 @@ def test_no_anomalies_during_burn_in(self) -> None:
 
     def test_detects_corruption(self) -> None:
         """Analyzer should detect a sudden distributional shift."""
-        config = LogitAnalyzerConfig(
-            ewma=EWMAConfig(**{"lambda": 0.1, "L": 3.0, "burn_in": 50})
-        )
+        config = LogitAnalyzerConfig(ewma=EWMAConfig(**{"lambda": 0.1, "L": 3.0, "burn_in": 50}))
         analyzer = LogitAnalyzer(config)
         rng = np.random.default_rng(42)
 
@@ -176,9 +172,7 @@ def test_disabled_returns_empty(self) -> None:
         assert analyzer.analyze(logits) == []
 
     def test_anomaly_event_fields(self) -> None:
-        config = LogitAnalyzerConfig(
-            ewma=EWMAConfig(**{"lambda": 0.3, "L": 2.0, "burn_in": 20})
-        )
+        config = LogitAnalyzerConfig(ewma=EWMAConfig(**{"lambda": 0.3, "L": 2.0, "burn_in": 20}))
         analyzer = LogitAnalyzer(config)
         rng = np.random.default_rng(0)
 
@@ -187,9 +181,7 @@ def test_anomaly_event_fields(self) -> None:
 
         # Inject anomaly
         for _ in range(50):
-            anomalies = analyzer.analyze(
-                rng.normal(20.0, 1.0, size=500).astype(np.float32)
-            )
+            anomalies = analyzer.analyze(rng.normal(20.0, 1.0, size=500).astype(np.float32))
             if anomalies:
                 event = anomalies[0]
                 assert event.analyzer == "logit_analyzer"

training-monitor/src/sentinel_training/common/anomaly_detector.py

@@ -220,9 +220,7 @@ def is_sdc_suspected(self) -> bool:
         """
         return self.composite_score() > self._composite_threshold
 
-    def recent_anomalies(
-        self, anomaly_type: AnomalyType | None = None
-    ) -> list[AnomalyScore]:
+    def recent_anomalies(self, anomaly_type: AnomalyType | None = None) -> list[AnomalyScore]:
         """Return recent anomalies, optionally filtered by type.
 
         Args: