Apply ruff format, which CI has been failing on for four commits

CI runs `ruff check` and `ruff format --check`; I had only been running the
first locally before each push, so formatting drift accumulated unnoticed while
every local gate reported green. Four consecutive pushes were red for this and
nothing else -- no test or type failure among them.

The lesson is about the gate, not the formatting: a local check that is a subset
of the CI check will pass while CI fails, and reporting "green" from the subset
is reporting something that was not verified.

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

Author: ehsun-sh

examples/export_ui_data.py

@@ -166,9 +166,7 @@ def main() -> None:
             "counts": np.asarray(histogram.counts).astype(int).tolist(),
             "inphase_edges": np.asarray(histogram.inphase_edges).round(5).tolist(),
             "quadrature_edges": np.asarray(histogram.quadrature_edges).round(5).tolist(),
-            "reference": [
-                [float(p.real), float(p.imag)] for p in np.asarray(histogram.reference)
-            ],
+            "reference": [[float(p.real), float(p.imag)] for p in np.asarray(histogram.reference)],
         },
         "eye": {
             "counts": np.asarray(eye.counts).astype(int).tolist(),

src/oosim/components/coherent.py

@@ -356,9 +356,7 @@ def run(self, ctx: SimulationContext, inputs: dict[str, Signal]) -> dict[str, Si
         default_offset = 0 if self.matched_filter else sps // 2
         offset = default_offset if self.sample_offset < 0 else int(self.sample_offset)
         if not 0 <= offset < sps:
-            raise ValueError(
-                f"{self.label}: sample_offset must be in [0, {sps}), got {offset}"
-            )
+            raise ValueError(f"{self.label}: sample_offset must be in [0, {sps}), got {offset}")
 
         complex_baseband = np.asarray(current_i.samples).astype(np.float64) + 1j * np.asarray(
             current_q.samples
@@ -370,9 +368,7 @@ def run(self, ctx: SimulationContext, inputs: dict[str, Signal]) -> dict[str, Si
             # every symbol instant but its own — so the neighbours contribute
             # nothing to this decision — and it is simultaneously matched to the
             # transmitted pulse, which is what makes it optimal against noise.
-            taps = root_raised_cosine(
-                self.roll_off, int(self.filter_span), ctx.samples_per_symbol
-            )
+            taps = root_raised_cosine(self.roll_off, int(self.filter_span), ctx.samples_per_symbol)
             complex_baseband = circular_filter(complex_baseband, taps)
 
         symbols = complex_baseband.reshape(-1, sps)[:, offset]

src/oosim/components/electrical.py

@@ -207,9 +207,7 @@ def run(self, ctx: SimulationContext, inputs: dict[str, Signal]) -> dict[str, Si
         # results. Doing it the other way round would pre-distort a rectangle and
         # then smear the correction.
         if self.pulse_shaping:
-            taps = root_raised_cosine(
-                self.roll_off, int(self.filter_span), ctx.samples_per_symbol
-            )
+            taps = root_raised_cosine(self.roll_off, int(self.filter_span), ctx.samples_per_symbol)
             waveform = shape_symbols(values, ctx.samples_per_symbol, taps)
         else:
             waveform = np.repeat(values, ctx.samples_per_symbol)

src/oosim/dsp.py

@@ -21,9 +21,7 @@
 SYMMETRY_TILT = 0.1
 
 
-def root_raised_cosine(
-    roll_off: float, span_symbols: int, samples_per_symbol: int
-) -> np.ndarray:
+def root_raised_cosine(roll_off: float, span_symbols: int, samples_per_symbol: int) -> np.ndarray:
     """Root-raised-cosine impulse response, normalised to unit energy.
 
     A rectangular symbol has a sinc spectrum, which never ends: it is fine for a

src/oosim/modulation.py

@@ -74,8 +74,7 @@ def bits_to_indices(bits: np.ndarray, bits_per_symbol: int) -> np.ndarray:
         raise ValueError(f"bits_per_symbol must be >= 1, got {bits_per_symbol}")
     if bits.shape[0] % bits_per_symbol:
         raise ValueError(
-            f"{bits.shape[0]} bits does not divide into whole symbols of "
-            f"{bits_per_symbol} bits"
+            f"{bits.shape[0]} bits does not divide into whole symbols of {bits_per_symbol} bits"
         )
 
     grouped = bits.astype(np.int64).reshape(-1, bits_per_symbol)

tests/test_coherent.py

@@ -317,9 +317,7 @@ def _beat(signal_state: tuple[complex, complex], lo_state: tuple[complex, comple
     ctx = SimulationContext(
         bit_rate=10e9, samples_per_symbol=4, sequence_length=64, seed=1, precision="double"
     )
-    receiver = CoherentReceiver(
-        responsivity=1.0, shot_noise=False, thermal_noise=False, label="rx"
-    )
+    receiver = CoherentReceiver(responsivity=1.0, shot_noise=False, thermal_noise=False, label="rx")
     n = ctx.num_samples
     f0 = C_LIGHT / 1550e-9
 
@@ -424,9 +422,7 @@ def test_offset_removal_never_makes_the_measurement_worse() -> None:
     symbols it becomes radians — turning a 14% EVM into a meaningless one. The
     fix is to keep the correction only when it helps, and this asserts it.
     """
-    _, uncorrected, _ = _run(
-        bits_per_symbol=4, predistort=False, remove_frequency_offset=False
-    )
+    _, uncorrected, _ = _run(bits_per_symbol=4, predistort=False, remove_frequency_offset=False)
     _, corrected, _ = _run(bits_per_symbol=4, predistort=False, remove_frequency_offset=True)
 
     assert corrected.evm <= uncorrected.evm + 1e-12
@@ -531,7 +527,7 @@ def test_shot_noise_scales_the_way_the_formula_says() -> None:
 def test_snr_is_linear_in_received_power() -> None:
     _, low, _ = _run(bits_per_symbol=2, tx_dbm=-40.0, shot_noise=True, sequence_length=8192)
     _, high, _ = _run(bits_per_symbol=2, tx_dbm=-37.0, shot_noise=True, sequence_length=8192)
-    assert high.snr / low.snr == pytest.approx(10.0 ** 0.3, rel=0.08)
+    assert high.snr / low.snr == pytest.approx(10.0**0.3, rel=0.08)
 
 
 def test_mer_is_the_evm_stated_in_decibels() -> None:

tests/test_dualpol.py

@@ -464,9 +464,9 @@ def test_power_is_conserved_from_the_combiner_to_the_rotator() -> None:
     combined = PolarizationCombiner(label="pbc").run(
         ctx, {"x": cw(0.7, 0.0, ctx), "y": cw(0.4, 0.0, ctx)}
     )["out"]
-    rotated = PolarizationRotator(angle=33.0, phase=48.0, label="rot").run(
-        ctx, {"in": combined}
-    )["out"]
+    rotated = PolarizationRotator(angle=33.0, phase=48.0, label="rot").run(ctx, {"in": combined})[
+        "out"
+    ]
 
     assert rotated.signal_power() == pytest.approx(0.7**2 + 0.4**2, rel=1e-12)
     assert math.isclose(combined.signal_power(), rotated.signal_power(), rel_tol=1e-12)

tests/test_shaping.py

@@ -162,9 +162,7 @@ def build(
         PRBSGenerator(order=23.0, bits_per_symbol=float(bits_per_symbol), label="prbs")
     )
     mapper = graph.add(
-        QAMMapper(
-            bits_per_symbol=float(bits_per_symbol), differential=differential, label="map"
-        )
+        QAMMapper(bits_per_symbol=float(bits_per_symbol), differential=differential, label="map")
     )
     reference = graph.add(
         QAMMapper(bits_per_symbol=float(bits_per_symbol), differential=False, label="ref")
@@ -181,9 +179,7 @@ def build(
     modulator = graph.add(IQModulator(label="mod"))
     lo = graph.add(CWLaser(power=13.0, linewidth=0.0, label="lo"))
     receiver = graph.add(CoherentReceiver(shot_noise=False, thermal_noise=False, label="rx"))
-    sampler = graph.add(
-        IQSampler(matched_filter=pulse_shaping, roll_off=roll_off, label="smp")
-    )
+    sampler = graph.add(IQSampler(matched_filter=pulse_shaping, roll_off=roll_off, label="smp"))
 
     graph.connect(prbs["out"], mapper["in"])
     graph.connect(prbs["out"], reference["in"])