style(prism): normalize baseline formatting

Author: echobt

examples/tiny-1m/architecture.py

@@ -45,7 +45,7 @@ def __init__(self, dim: int, n_heads: int) -> None:
         self.dim = dim
         self.n_heads = n_heads
         self.head_dim = dim // n_heads
-        self.scale = self.head_dim ** -0.5
+        self.scale = self.head_dim**-0.5
         self.qkv = nn.Linear(dim, dim * 3, bias=False)
         self.proj = nn.Linear(dim, dim, bias=False)
 

scripts/mission/launch.py

@@ -617,8 +617,7 @@ def _reconstruct_dispute_via_api(
         (
             u
             for u in units
-            if u.get("work_unit_id") == sid
-            or str(u.get("work_unit_id", "")).startswith(sid)
+            if u.get("work_unit_id") == sid or str(u.get("work_unit_id", "")).startswith(sid)
         ),
         None,
     )
@@ -645,8 +644,7 @@ def _reconstruct_dispute_via_api(
         f"outcome={audit.get('outcome')}"
     )
     print(
-        f"  (c) prism submission status={submission.get('status')} "
-        f"no_live_score={ok_invalidated}"
+        f"  (c) prism submission status={submission.get('status')} no_live_score={ok_invalidated}"
     )
     print(f"  (d) fault worker={fault['worker_id']} visible on API+CLI={ok_fault_both}")
     passed = ok_disputed and ok_audit and ok_invalidated and ok_fault_both

scripts/mission/legacy_smoke.py

@@ -253,8 +253,7 @@ def run(workdir: Path) -> bool:
             f"assigned_validator_hotkey={row['assigned_validator_hotkey']}"
         )
         assigned_to_validator = (
-            row["assigned_validator_hotkey"] == validator_hk
-            and row["required_capability"] == "gpu"
+            row["assigned_validator_hotkey"] == validator_hk and row["required_capability"] == "gpu"
         )
         worker_regs = h._count("worker_registrations")
         worker_asgn = h._count("worker_assignments")

src/prism_challenge/admission.py

@@ -66,14 +66,10 @@ async def count_active_workers(settings: PrismSettings, hotkey: str) -> int | No
                 ACTIVE_WORKERS_PATH, params={"hotkey": hotkey}, headers=headers
             )
     except httpx.HTTPError as exc:
-        logger.warning(
-            "admission master query failed (%s); failing closed", type(exc).__name__
-        )
+        logger.warning("admission master query failed (%s); failing closed", type(exc).__name__)
         return None
     if response.status_code >= 400:
-        logger.warning(
-            "admission master returned HTTP %s; failing closed", response.status_code
-        )
+        logger.warning("admission master returned HTTP %s; failing closed", response.status_code)
         return None
     try:
         payload = response.json()

src/prism_challenge/evaluator/benchmarks/official.py

@@ -91,9 +91,7 @@ class NeedleScoringConfig(BaseModel):
     @model_validator(mode="after")
     def weights_sum_to_one(self) -> NeedleScoringConfig:
         total = (
-            self.exact_match_weight
-            + self.contains_answer_weight
-            + self.normalized_position_weight
+            self.exact_match_weight + self.contains_answer_weight + self.normalized_position_weight
         )
         if abs(total - 1.0) > 1e-6:
             raise ValueError(f"needle scoring weights must sum to 1.0, got {total:.6f}")
@@ -217,9 +215,7 @@ def parse_official_benchmark_outputs(
     parsed_scores = list(parse_lm_eval_output(lm_payload))
     parsed_scores.append(parse_needle_output(needle_payload, needle_spec))
     benchmark_scores = {score.benchmark_key: score.score for score in parsed_scores}
-    missing = tuple(
-        key for key in OFFICIAL_BENCHMARK_SCORE_KEYS if key not in benchmark_scores
-    )
+    missing = tuple(key for key in OFFICIAL_BENCHMARK_SCORE_KEYS if key not in benchmark_scores)
     errors = tuple(f"missing benchmark result: {key}" for key in missing)
     return BenchmarkParseResult(
         benchmark_scores=benchmark_scores,
@@ -301,8 +297,7 @@ def _parse_task_group(
     if metric is None:
         raise ValueError(f"{task_id} result missing supported metrics {preferred_metrics}")
     values = [
-        _require_float(result[metric], f"{task_id}.{metric}")
-        for result in task_results.values()
+        _require_float(result[metric], f"{task_id}.{metric}") for result in task_results.values()
     ]
     stderr = _average_stderr(task_results, metric)
     return ParsedBenchmarkScore(
@@ -315,9 +310,7 @@ def _parse_task_group(
     )
 
 
-def _matching_task_results(
-    results: dict[str, Any], task_id: str
-) -> dict[str, dict[str, Any]]:
+def _matching_task_results(results: dict[str, Any], task_id: str) -> dict[str, dict[str, Any]]:
     matches: dict[str, dict[str, Any]] = {}
     for key, value in results.items():
         if key == task_id or key.startswith(f"{task_id}_"):

src/prism_challenge/evaluator/components.py

@@ -309,9 +309,7 @@ def _top_level_functions(content: str, path: str) -> set[str]:
             f"submission contract violation: cannot parse {path} ({exc.msg})"
         ) from exc
     return {
-        node.name
-        for node in tree.body
-        if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef)
+        node.name for node in tree.body if isinstance(node, ast.FunctionDef | ast.AsyncFunctionDef)
     }
 
 

src/prism_challenge/evaluator/cpu_test_mode.py

@@ -99,9 +99,7 @@ def stage_tiny_train_data(root: Path | str, *, lines: int = 64) -> Path:
     data_dir.mkdir(parents=True, exist_ok=True)
     shard = data_dir / "train-00000.jsonl"
     if not shard.exists():
-        shard.write_text(
-            "".join(_SHARD_LINE.format(i=i) for i in range(lines)), encoding="utf-8"
-        )
+        shard.write_text("".join(_SHARD_LINE.format(i=i) for i in range(lines)), encoding="utf-8")
     return data_dir
 
 

src/prism_challenge/evaluator/data_prep.py

@@ -63,9 +63,7 @@ def _load(self) -> object:
             try:
                 import tiktoken
             except ImportError as exc:  # pragma: no cover - exercised only without tiktoken
-                raise LockedDatasetError(
-                    "tiktoken is required for the gpt2 token counter"
-                ) from exc
+                raise LockedDatasetError("tiktoken is required for the gpt2 token counter") from exc
             self._encoding = tiktoken.get_encoding("gpt2")
         return self._encoding
 

src/prism_challenge/evaluator/dataset.py

@@ -63,9 +63,7 @@ def partition_bucket(doc_id: str) -> int:
 def bucket_to_split(bucket: int) -> str:
     """Map a partition bucket to its split using the fixed/pinned boundaries."""
     if not 0 <= bucket < PARTITION_MODULUS:
-        raise LockedDatasetError(
-            f"partition bucket {bucket} out of range [0, {PARTITION_MODULUS})"
-        )
+        raise LockedDatasetError(f"partition bucket {bucket} out of range [0, {PARTITION_MODULUS})")
     for split, (low, high) in PARTITION_BUCKETS.items():
         if low <= bucket <= high:
             return split
@@ -171,9 +169,7 @@ def to_dict(self) -> dict[str, Any]:
             "partition": self.partition,
             "tokenizer": dict(self.tokenizer),
             "splits": {
-                name: self.splits[name].to_dict()
-                for name in LOCKED_SPLITS
-                if name in self.splits
+                name: self.splits[name].to_dict() for name in LOCKED_SPLITS if name in self.splits
             },
         }
 
@@ -319,8 +315,7 @@ def verify_locked_manifest(
             actual = hashlib.sha256(data).hexdigest()
             if actual != shard.sha256:
                 problems.append(
-                    f"sha256 mismatch for {shard.path}: "
-                    f"manifest {shard.sha256} != on-disk {actual}"
+                    f"sha256 mismatch for {shard.path}: manifest {shard.sha256} != on-disk {actual}"
                 )
             if len(data) != shard.bytes:
                 problems.append(
@@ -345,9 +340,7 @@ def verify_locked_manifest_or_raise(
 ) -> None:
     problems = verify_locked_manifest(root, manifest, splits=splits)
     if problems:
-        raise LockedDatasetError(
-            "locked dataset integrity check failed: " + "; ".join(problems)
-        )
+        raise LockedDatasetError("locked dataset integrity check failed: " + "; ".join(problems))
 
 
 def locked_shard_paths(manifest: LockedManifest, split: str) -> list[str]:
@@ -405,9 +398,7 @@ def iter_locked_documents(root: Path | str, split: str) -> Iterator[LockedDocume
                 doc_id = str(record["id"])
                 text = record["text"]
             except (json.JSONDecodeError, KeyError, TypeError) as exc:
-                raise LockedDatasetError(
-                    f"malformed locked shard line {rel}:{offset}"
-                ) from exc
+                raise LockedDatasetError(f"malformed locked shard line {rel}:{offset}") from exc
             if not isinstance(text, str):
                 raise LockedDatasetError(f"locked shard line {rel}:{offset} has non-string text")
             yield LockedDocument(doc_id=doc_id, text=text, shard=rel, offset=offset, index=index)

src/prism_challenge/evaluator/distributed_contract.py

@@ -272,9 +272,7 @@ def _is_rank0_test(test: ast.AST) -> bool:
         return any(_is_rank0_test(value) for value in test.values)
     if isinstance(test, ast.Compare) and len(test.ops) == 1 and isinstance(test.ops[0], ast.Eq):
         left, right = test.left, test.comparators[0]
-        return (_is_rank_ref(left) and _is_zero(right)) or (
-            _is_rank_ref(right) and _is_zero(left)
-        )
+        return (_is_rank_ref(left) and _is_zero(right)) or (_is_rank_ref(right) and _is_zero(left))
     return False