Ruff migration wave 1: manual fixes across all packages (9 parallel agents)

~2,300 violations fixed by hand across examples/, scripts/, tests/,
torchwright/: D205/D415 docstring shaping, ANN annotations in
non-test code, RUF001/2/3 unicode-to-ASCII conformance, PLR2004
constant extraction, PTH pathlib migration, E501 splits, E741 renames,
ARG underscore renames for callback slots, ERA001 dead-code removal,
PT018 assert splits, and singles.

Integration repairs after the wave: export.py helpers re-annotated
HeadlessTransformer (not CompiledHeadless), **attrs/**changes -> Any
at ONNX emission and SchedulingProblem._replace, SupportsInt cast in
replay_plan, IntVar cast at _and_presence, past_kvs variance widening.

Recovered bucket-8's swiglu fixes from the stash a concurrent agent
created mid-wave (git stash in the shared worktree captured ~140
in-flight files; the seven swiglu files were never restored).

Gates: ruff 7846 -> 593 (remaining = deferred wave-2 families +
reported false positives), mypy green, full import walk, format
stable.

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

Author: physicsrob

examples/_calculator_common.py

@@ -37,6 +37,8 @@
 the shared parse, comparison, and leading-zero trim are all constant-depth.)
 """
 
+from collections.abc import Callable
+
 import torch
 
 from torchwright.graph import Embedding, Linear, Node, RopeConfig
@@ -140,13 +142,13 @@ def _slice(node: Node, start: int, width: int, name: str = "slice") -> Node:
 def compare_digit_seqs(
     embedding: Embedding, seq1: list[Node], seq2: list[Node]
 ) -> Node:
-    """Lexicographic comparison at constant depth: weight the digit flags so
-    the first difference outweighs everything after it.
+    """Lexicographic comparison at constant depth.
 
-    This is how a person compares equal-width numbers — walk from the most
-    significant digit, and the first position where the digits differ
-    decides — encoded arithmetically in three FFN stages regardless of
-    digit count:
+    Weight the digit flags so the first difference outweighs everything
+    after it.  This is how a person compares equal-width numbers — walk
+    from the most significant digit, and the first position where the
+    digits differ decides — encoded arithmetically in three FFN stages
+    regardless of digit count:
 
     1. one ``onehot_lookup`` per position maps the concatenated digit pair
        to a three-way flag: ``+1`` (a > b), ``0`` (equal), ``-1`` (a < b)
@@ -325,8 +327,9 @@ def parse_expression(
 
 
 def _pad_result(embedding: Embedding, digits: list[Node], seq_len: int) -> list[Node]:
-    """Align a digit sequence into the shared result frame (free literals):
-    leading ``"0"`` digits out to the widest answer width (``seq_len - 2``,
+    """Align a digit sequence into the shared result frame (free literals).
+
+    Leading ``"0"`` digits out to the widest answer width (``seq_len - 2``,
     multiplication's ``2·max_digits``), then ``<eos>`` padding.  Every branch
     then has the same digit width, so the one post-dispatch trim's
     ``max_removals`` cap keeps exactly one digit of an all-zero answer no
@@ -343,20 +346,24 @@ def emit_result(
     saw_newline: Node,
     result_digits: list[Node],
 ) -> Node:
-    """Emit ``result_digits`` autoregressively once the newline fires, printing
-    a space at every position before then.
+    """Emit ``result_digits`` autoregressively once the newline fires.
+
+    Prints a space at every position before then.
     """
     return output_sequence(
         rope, saw_newline, result_digits, embedding.get_embedding(" ")
     )
 
 
+_DigitSeqOp = Callable[[Embedding, list[Node], list[Node]], list[Node]]
+
+
 def build_calculator(
     max_digits: int,
     *,
-    add_digit_seqs,
-    subtract_digit_seqs,
-    multiply_digit_seqs,
+    add_digit_seqs: _DigitSeqOp,
+    subtract_digit_seqs: _DigitSeqOp,
+    multiply_digit_seqs: _DigitSeqOp,
 ) -> tuple[Node, Embedding]:
     """Assemble the calculator graph from one variant's arithmetic.
 

examples/adder.py

@@ -37,7 +37,8 @@ def create_network_parts() -> tuple[Node, Embedding]:
     """Build the 3-digit adder graph and return (output_node, embedding)."""
     vocab = [
         *list(
-            " 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*()-+="
+            " 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+            "!@#$%^&*()-+="
         ),
         "\n",
         "<bos>",

examples/adder_1digit.py

@@ -39,20 +39,26 @@ def check_is_num(embedding_value: Node, embedding: Embedding) -> Node:
     )
 
 
+_DECIMAL_BASE = 10
+
+
 def sum_numbers(embedding: Embedding, num1: Node, num2: Node) -> tuple[Node, Node]:
-    """Adds num1 with num2.
-    Assumes num1 and num2 are both embedding-valued nodes.
-    return result as embedding-valued node and carry as boolean.
+    """Add num1 with num2.
+
+    Assumes num1 and num2 are both embedding-valued nodes.  Returns the
+    result as an embedding-valued node and the carry as a boolean.
     """
     result_table = {}
     carry_table = {}
-    for A in range(10):
-        for B in range(10):
+    for A in range(_DECIMAL_BASE):
+        for B in range(_DECIMAL_BASE):
             numcat = torch.cat(
                 [embedding.get_embedding(str(A)), embedding.get_embedding(str(B))]
             )
-            result_table[numcat] = embedding.get_embedding(str((A + B) % 10))
-            carry_table[numcat] = torch.tensor([1.0 if (A + B) >= 10 else -1.0])
+            result_table[numcat] = embedding.get_embedding(str((A + B) % _DECIMAL_BASE))
+            carry_table[numcat] = torch.tensor(
+                [1.0 if (A + B) >= _DECIMAL_BASE else -1.0]
+            )
 
     num1_num2 = concat([num1, num2])
     return (

examples/adder_v2.py

@@ -53,7 +53,8 @@ def create_network(max_digits: int = 3) -> Unembedding:
     """
     vocab = [
         *list(
-            " 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ!@#$%^&*()-+="
+            " 0123456789abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ"
+            "!@#$%^&*()-+="
         ),
         "\n",
         "<bos>",

examples/calculator_advanced.py

@@ -1,5 +1,7 @@
-"""Depth-optimized calculator: the same calculator as ``calculator_simple`` but
-with the logarithmic-depth arithmetic a hardware multiplier uses.
+"""Depth-optimized calculator.
+
+The same calculator as ``calculator_simple`` but with the logarithmic-depth
+arithmetic a hardware multiplier uses.
 
 This is one of two standalone calculator implementations.  It computes the same
 functions as ``calculator_simple`` but trades the legible serial folds for
@@ -39,6 +41,8 @@
 exact with no dropped nonzero carry.
 """
 
+from collections.abc import Callable
+
 import torch
 
 from examples._calculator_common import (
@@ -84,6 +88,7 @@
 
 _KILL, _PROPAGATE, _GENERATE = 0, 1, 2
 _SEG_W = 3
+_DECIMAL_BASE = 10
 
 
 def _combine_table() -> dict[torch.Tensor, torch.Tensor]:
@@ -139,8 +144,10 @@ def carry_lookahead(segments: list[Node]) -> list[Node]:
         _state(_GENERATE, _SEG_W): _state(_YES, _CARRY_W),
     }
     carries: list[Node] = [create_literal_value(_state(_NO, _CARRY_W))]
-    for j in range(1, n):
-        carries.append(onehot_lookup(prefix[j - 1], generated, _state(_NO, _CARRY_W)))
+    carries.extend(
+        onehot_lookup(prefix[j - 1], generated, _state(_NO, _CARRY_W))
+        for j in range(1, n)
+    )
     return carries
 
 
@@ -149,8 +156,8 @@ def _carry_lookahead_op(
     seq1: list[Node],
     seq2: list[Node],
     *,
-    status_of,
-    digit_of,
+    status_of: Callable[[int, int], int],
+    digit_of: Callable[[int, int, int], int],
 ) -> list[Node]:
     """Add or subtract two MSB-first digit sequences via carry-lookahead.
 
@@ -199,9 +206,13 @@ def add_digit_seqs(
         seq1,
         seq2,
         status_of=lambda a, b: (
-            _GENERATE if a + b >= 10 else _PROPAGATE if a + b == 9 else _KILL
+            _GENERATE
+            if a + b >= _DECIMAL_BASE
+            else _PROPAGATE
+            if a + b == _DECIMAL_BASE - 1
+            else _KILL
         ),
-        digit_of=lambda a, b, carry: (a + b + carry) % 10,
+        digit_of=lambda a, b, carry: (a + b + carry) % _DECIMAL_BASE,
     )
 
 
@@ -264,7 +275,7 @@ def _digit_value_proj(embedding: Embedding) -> torch.Tensor:
     return proj
 
 
-def _make_compressor(embedding: Embedding):
+def _make_compressor(embedding: Embedding) -> Callable[[list[Node]], tuple[Node, Node]]:
     """Return an 11:2 compressor ``(<=11 one-hot digits) -> (sum, carry)``.
 
     Rather than a ``10**11``-row lookup (one neuron per input combination — fat
@@ -288,7 +299,7 @@ def _make_compressor(embedding: Embedding):
         for t in range(n_buckets)
     }
 
-    def compress(digits: list[Node]):
+    def compress(digits: list[Node]) -> tuple[Node, Node]:
         values: list[Node] = [Linear(d, value_proj, name="digit_value") for d in digits]
         total = sum_nodes(values)  # plain-number add of up to 11 digits, 0..99
         bucket = bool_to_01(in_range(total, add_const(total, 1.0), n_buckets))
@@ -359,14 +370,16 @@ def multiply_digit_seqs(
     # Step 2: carry-save reduction — up to _RADIX rows -> 2 rows per level, all
     # columns in parallel, until two rows survive.
     compress = _make_compressor(embedding)
+    _FINAL_ROW_COUNT = 2
+    _MIN_COMPRESSIBLE_CHUNK = 3
 
-    while len(rows) > 2:
+    while len(rows) > _FINAL_ROW_COUNT:
         nxt: list[list[Node]] = []
         k = 0
         while k < len(rows):
             chunk = rows[k : k + _RADIX]
             k += len(chunk)
-            if len(chunk) < 3:  # 1 or 2 leftover rows: nothing to compress
+            if len(chunk) < _MIN_COMPRESSIBLE_CHUNK:  # 1-2 leftover rows: nothing
                 nxt.extend(chunk)
                 continue
             sum_row = [zero] * width
@@ -380,7 +393,7 @@ def multiply_digit_seqs(
             nxt.append(carry_row)
         rows = nxt
 
-    while len(rows) < 2:  # pad to exactly two rows for the final add
+    while len(rows) < _FINAL_ROW_COUNT:  # pad to exactly two rows for the final add
         rows.append([zero] * width)
 
     # Step 3: add the two surviving rows (MSB-first) with carry-lookahead.
@@ -392,7 +405,9 @@ def multiply_digit_seqs(
 def create_network_parts(
     max_digits: int = 3,
 ) -> tuple[Node, Embedding]:
-    """The advanced calculator: the depth-optimized arithmetic wired up by
+    """Build the advanced calculator.
+
+    The depth-optimized arithmetic wired up by
     :func:`examples._calculator_common.build_calculator`.
     """
     return build_calculator(

examples/calculator_memorize.py

@@ -133,8 +133,9 @@ def compiled_layers(max_digits: int, d_hidden: int = 16384) -> int:
 
 
 def _format_answer(embedding: Embedding, value: int, seq_len: int) -> torch.Tensor:
-    """The complete formatted answer as a flat ``seq_len * 17`` vector:
-    sign and decimal digits, then <eos> padding — exactly what the other
+    """The complete formatted answer as a flat ``seq_len * 17`` vector.
+
+    Sign and decimal digits, then <eos> padding - exactly what the other
     calculators spend their comparison / borrow / trim machinery producing.
     """
     text = str(value)