Fix ruff, ty, and pytest failures; apply ruff format

Removes unused imports and an ambiguous variable name, narrows
Optional types before use so ty's flow analysis is satisfied, swaps
sum() over polars expressions for pl.sum_horizontal to avoid the
Literal[0] fallback type, and converts numpy bin edges to plain lists
before passing to matplotlib's hist (whose stub only accepts
Sequence[float]). Also applies ruff format across the repo, which had
drifted out of sync with the formatter.

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

scripts/bump_dataset_version.py

@@ -92,7 +92,11 @@ def _git_user_name() -> str | None:
 
 
 def plan_bump_gen(
-    root: Path, kind: str, reason: str, by: str | None, date: str,
+    root: Path,
+    kind: str,
+    reason: str,
+    by: str | None,
+    date: str,
     target: str | None = None,
 ) -> tuple[list[Path], str]:
     """New gen tag is one past the highest seen under raw/ or processed/ for *kind*,
@@ -120,7 +124,12 @@ def plan_bump_gen(
 
 
 def plan_bump_schema(
-    root: Path, kind: str, gen_tag: str, reason: str, by: str | None, date: str,
+    root: Path,
+    kind: str,
+    gen_tag: str,
+    reason: str,
+    by: str | None,
+    date: str,
     target: str | None = None,
 ) -> tuple[list[Path], str]:
     if not GEN_RE.match(gen_tag):
@@ -140,7 +149,9 @@ def plan_bump_schema(
         schema_tag = f"schema{next_schema}"
     new_dirs = [processed_gen_dir / schema_tag]
     by_suffix = f" ({by})" if by else ""
-    log_line = f"- `{gen_tag}`/`{schema_tag}` (kind={kind}) — {date} — {reason}{by_suffix}"
+    log_line = (
+        f"- `{gen_tag}`/`{schema_tag}` (kind={kind}) — {date} — {reason}{by_suffix}"
+    )
     return new_dirs, log_line
 
 
@@ -196,7 +207,9 @@ def _manifest_referenced_files(pools_root: Path) -> set[Path]:
     return referenced
 
 
-def _referenced_root_count(raw_gen_dir: Path, processed_gen_dir: Path) -> tuple[int, int]:
+def _referenced_root_count(
+    raw_gen_dir: Path, processed_gen_dir: Path
+) -> tuple[int, int]:
     """(total .root files, count with a same-named .parquet under any schema) for one gen."""
     if not raw_gen_dir.is_dir():
         return 0, 0
@@ -349,13 +362,17 @@ def print_status(root: Path) -> None:
             )
             schema_sizes = {s: _du(schema_dir / f"schema{s}") for s in schemas}
             schema_counts = {
-                s: _referenced_parquet_count(schema_dir / f"schema{s}", manifest_referenced)
+                s: _referenced_parquet_count(
+                    schema_dir / f"schema{s}", manifest_referenced
+                )
                 for s in schemas
             }
             processed_size = sum(schema_sizes.values())
             processed_files = sum(c[0] for c in schema_counts.values())
             processed_referenced = sum(c[1] for c in schema_counts.values())
-            raw_files, raw_referenced = _referenced_root_count(raw_gen_dir, processed_gen_dir)
+            raw_files, raw_referenced = _referenced_root_count(
+                raw_gen_dir, processed_gen_dir
+            )
             gen_total = raw_size + processed_size
             gen_files = raw_files + processed_files
             kind_total += gen_total
@@ -367,14 +384,22 @@ def print_status(root: Path) -> None:
                 print(_reason_line(gen_reason, indent=2))
             print(
                 _row(
-                    "raw", raw_size, indent=2, level="bucket",
-                    count=raw_files, referenced=raw_referenced,
+                    "raw",
+                    raw_size,
+                    indent=2,
+                    level="bucket",
+                    count=raw_files,
+                    referenced=raw_referenced,
                 )
             )
             print(
                 _row(
-                    "processed", processed_size, indent=2, level="bucket",
-                    count=processed_files, referenced=processed_referenced,
+                    "processed",
+                    processed_size,
+                    indent=2,
+                    level="bucket",
+                    count=processed_files,
+                    referenced=processed_referenced,
                 )
             )
             if schemas:
@@ -382,8 +407,12 @@ def print_status(root: Path) -> None:
                     s_total, s_referenced = schema_counts[s]
                     print(
                         _row(
-                            f"schema{s}", schema_sizes[s], indent=3, level="schema",
-                            count=s_total, referenced=s_referenced,
+                            f"schema{s}",
+                            schema_sizes[s],
+                            indent=3,
+                            level="schema",
+                            count=s_total,
+                            referenced=s_referenced,
                         )
                     )
                     schema_reason = schema_reasons.get((kind, gen_tag, f"schema{s}"))
@@ -391,7 +420,9 @@ def print_status(root: Path) -> None:
                         print(_reason_line(schema_reason, indent=4))
             else:
                 print(_colorize("      (none)", "schema"))
-        print(_row(f"{kind} total", kind_total, indent=1, level="gen", count=kind_files))
+        print(
+            _row(f"{kind} total", kind_total, indent=1, level="gen", count=kind_files)
+        )
         print()
         grand_total += kind_total
         grand_files += kind_files
@@ -414,6 +445,7 @@ def print_status(root: Path) -> None:
 # update-manifest
 # ---------------------------------------------------------------------------
 
+
 def plan_update_manifest(
     manifest_path: Path,
     target_schema: str | None,
@@ -489,8 +521,13 @@ def plan_update_manifest(
     return result, missing
 
 
-def apply_update_manifest(manifest_path: Path, lines: list[tuple[str, str | None]]) -> None:
-    out = [replacement if replacement is not None else original for original, replacement in lines]
+def apply_update_manifest(
+    manifest_path: Path, lines: list[tuple[str, str | None]]
+) -> None:
+    out = [
+        replacement if replacement is not None else original
+        for original, replacement in lines
+    ]
     manifest_path.write_text("\n".join(out) + "\n")
 
 
@@ -498,6 +535,7 @@ def apply_update_manifest(manifest_path: Path, lines: list[tuple[str, str | None
 # create-manifest
 # ---------------------------------------------------------------------------
 
+
 def _resolve_manifest_files(manifest_path: Path) -> list[Path]:
     """Read a manifest and return its entries as resolved absolute paths."""
     files = []
@@ -571,6 +609,7 @@ def apply_create_manifest(output_path: Path, lines: list[str]) -> None:
 # CLI entry points (called from scripts/dwarf.py)
 # ---------------------------------------------------------------------------
 
+
 def run_status(root: str) -> None:
     root_path = Path(root)
     if not root_path.is_dir():
@@ -597,7 +636,9 @@ def _run_bump(
     if gen is None:
         new_dirs, log_line = plan_bump_gen(root_path, kind, reason, by, date, to)
     else:
-        new_dirs, log_line = plan_bump_schema(root_path, kind, gen, reason, by, date, to)
+        new_dirs, log_line = plan_bump_schema(
+            root_path, kind, gen, reason, by, date, to
+        )
 
     print(f"=== {'EXECUTING' if execute else 'DRY RUN'} ===")
     print("new directories:")

scripts/create_root_files.py

@@ -61,7 +61,9 @@ def parse_detector_spec(spec: str) -> tuple[str, str | None]:
     if ":" in spec:
         label, config = spec.split(":", 1)
         if not label or not config:
-            raise PlanError(f"invalid --detector spec {spec!r}: expected NAME or NAME:CONFIG")
+            raise PlanError(
+                f"invalid --detector spec {spec!r}: expected NAME or NAME:CONFIG"
+            )
         return label, config
     return spec, None
 
@@ -111,7 +113,10 @@ def run_job(
     gen: str,
     tmp_root: Path,
 ) -> JobResult:
-    workdir = tmp_root / f"{kind}-{gen}-{job.detector}-{job.shard_index:03d}-{uuid.uuid4().hex[:8]}"
+    workdir = (
+        tmp_root
+        / f"{kind}-{gen}-{job.detector}-{job.shard_index:03d}-{uuid.uuid4().hex[:8]}"
+    )
     workdir.mkdir(parents=True)
 
     cmd = [str(executable)]
@@ -123,25 +128,42 @@ def run_job(
 
     if result.returncode != 0:
         return JobResult(
-            job, False, None,
+            job,
+            False,
+            None,
             f"executable exited {result.returncode}",
-            result.stdout, result.stderr,
+            result.stdout,
+            result.stderr,
         )
 
     produced = sorted(workdir.glob("*.root"))
     if len(produced) != 1:
         return JobResult(
-            job, False, None,
+            job,
+            False,
+            None,
             f"expected exactly one .root output in {workdir}, found {len(produced)}: "
             f"{[p.name for p in produced]}",
-            result.stdout, result.stderr,
+            result.stdout,
+            result.stderr,
         )
 
-    dest = dataset_root / "raw" / kind / gen / job.detector / f"shard-{job.shard_index:03d}.root"
+    dest = (
+        dataset_root
+        / "raw"
+        / kind
+        / gen
+        / job.detector
+        / f"shard-{job.shard_index:03d}.root"
+    )
     if dest.exists():
         return JobResult(
-            job, False, None, f"refusing to overwrite existing {dest}",
-            result.stdout, result.stderr,
+            job,
+            False,
+            None,
+            f"refusing to overwrite existing {dest}",
+            result.stdout,
+            result.stderr,
         )
 
     dest.parent.mkdir(parents=True, exist_ok=True)
@@ -166,7 +188,14 @@ def run_all(
     with ThreadPoolExecutor(max_workers=max_workers) as pool:
         futures = {
             pool.submit(
-                run_job, job, executable, events_per_file, dataset_root, kind, gen, tmp_root
+                run_job,
+                job,
+                executable,
+                events_per_file,
+                dataset_root,
+                kind,
+                gen,
+                tmp_root,
             ): job
             for job in jobs
         }
@@ -212,8 +241,19 @@ def run_make_root(
     print(f"=== {'EXECUTING' if execute else 'DRY RUN'} ===")
     print(f"executable: {executable}")
     for job in planned_jobs:
-        cmd = [str(executable)] + ([job.config] if job.config else []) + [str(events_per_file)]
-        dest = dataset_root_path / "raw" / kind / gen / job.detector / f"shard-{job.shard_index:03d}.root"
+        cmd = (
+            [str(executable)]
+            + ([job.config] if job.config else [])
+            + [str(events_per_file)]
+        )
+        dest = (
+            dataset_root_path
+            / "raw"
+            / kind
+            / gen
+            / job.detector
+            / f"shard-{job.shard_index:03d}.root"
+        )
         print(f"  {' '.join(cmd)}  ->  {dest}")
 
     if not execute:
@@ -223,8 +263,14 @@ def run_make_root(
     tmp_root = dataset_root_path / ".sim-tmp"
     tmp_root.mkdir(parents=True, exist_ok=True)
     results = run_all(
-        planned_jobs, executable, events_per_file, dataset_root_path, kind, gen,
-        max_workers=jobs, tmp_root=tmp_root,
+        planned_jobs,
+        executable,
+        events_per_file,
+        dataset_root_path,
+        kind,
+        gen,
+        max_workers=jobs,
+        tmp_root=tmp_root,
     )
     if tmp_root.is_dir() and not any(tmp_root.iterdir()):
         tmp_root.rmdir()
@@ -233,7 +279,10 @@ def run_make_root(
     if failures:
         print(f"\n{len(failures)} of {len(results)} job(s) failed:", file=sys.stderr)
         for r in failures:
-            print(f"  {r.job.detector} shard-{r.job.shard_index:03d}: {r.message}", file=sys.stderr)
+            print(
+                f"  {r.job.detector} shard-{r.job.shard_index:03d}: {r.message}",
+                file=sys.stderr,
+            )
         raise SystemExit(1)
 
     print(f"\nAll {len(results)} job(s) completed.")

scripts/dwarf.py

@@ -51,9 +51,7 @@ class PoolType(str, Enum):
 
 @app.command()
 def convert(
-    root_files: Annotated[
-        list[Path], typer.Argument(help="Input ROOT file(s)")
-    ],
+    root_files: Annotated[list[Path], typer.Argument(help="Input ROOT file(s)")],
     output: Annotated[
         Optional[Path],
         typer.Option(
@@ -107,11 +105,15 @@ def convert(
         typer.echo("error: --jobs must be >= 1", err=True)
         raise typer.Exit(1)
 
-    compression_value = "uncompressed" if compression is Compression.none else compression.value
+    compression_value = (
+        "uncompressed" if compression is Compression.none else compression.value
+    )
 
     if jobs == 1:
         if output is not None and len(root_files) > 1:
-            typer.echo("error: --output can only be used with a single input file", err=True)
+            typer.echo(
+                "error: --output can only be used with a single input file", err=True
+            )
             raise typer.Exit(1)
         for root_file in root_files:
             convert_steps_to_parquet(
@@ -149,7 +151,8 @@ def migrate(
     execute: Annotated[
         bool,
         typer.Option(
-            "--execute", help="Actually move/copy files and write manifests (default: dry run)"
+            "--execute",
+            help="Actually move/copy files and write manifests (default: dry run)",
         ),
     ] = False,
     copy: Annotated[
@@ -168,25 +171,40 @@ def migrate(
 @app.command("bump-gen")
 def bump_gen(
     reason: Annotated[str, typer.Option("--reason", help="Why this gen exists")],
-    kind: Annotated[str, typer.Option("--kind", help="steps | hits | ... (default: steps)")] = "steps",
+    kind: Annotated[
+        str, typer.Option("--kind", help="steps | hits | ... (default: steps)")
+    ] = "steps",
     by: Annotated[
         Optional[str], typer.Option("--by", help="Attribution (default: git user.name)")
     ] = None,
     date: Annotated[
-        Optional[str], typer.Option("--date", help="Override date (default: today, ISO)")
+        Optional[str],
+        typer.Option("--date", help="Override date (default: today, ISO)"),
     ] = None,
     to: Annotated[
         Optional[str],
         typer.Option(
-            "--to", metavar="genN", help="Target gen tag (default: one past the current highest)"
+            "--to",
+            metavar="genN",
+            help="Target gen tag (default: one past the current highest)",
         ),
     ] = None,
-    execute: Annotated[bool, typer.Option("--execute", help="Apply (default: dry run)")] = False,
-    root: Annotated[Path, typer.Option("--root", help="Dataset root")] = _DATASET_ROOT_DEFAULT,
+    execute: Annotated[
+        bool, typer.Option("--execute", help="Apply (default: dry run)")
+    ] = False,
+    root: Annotated[
+        Path, typer.Option("--root", help="Dataset root")
+    ] = _DATASET_ROOT_DEFAULT,
 ) -> None:
     """Cut a new raw generation."""
     run_bump_gen(
-        kind=kind, reason=reason, by=by, date=date, execute=execute, root=str(root), to=to
+        kind=kind,
+        reason=reason,
+        by=by,
+        date=date,
+        execute=execute,
+        root=str(root),
+        to=to,
     )
 
 
@@ -194,12 +212,15 @@ def bump_gen(
 def bump_schema(
     gen: Annotated[str, typer.Option("--gen", help="Existing gen tag, e.g. gen1")],
     reason: Annotated[str, typer.Option("--reason", help="Why this schema exists")],
-    kind: Annotated[str, typer.Option("--kind", help="steps | hits | ... (default: steps)")] = "steps",
+    kind: Annotated[
+        str, typer.Option("--kind", help="steps | hits | ... (default: steps)")
+    ] = "steps",
     by: Annotated[
         Optional[str], typer.Option("--by", help="Attribution (default: git user.name)")
     ] = None,
     date: Annotated[
-        Optional[str], typer.Option("--date", help="Override date (default: today, ISO)")
+        Optional[str],
+        typer.Option("--date", help="Override date (default: today, ISO)"),
     ] = None,
     to: Annotated[
         Optional[str],
@@ -209,8 +230,12 @@ def bump_schema(
             help="Target schema tag (default: one past the current highest)",
         ),
     ] = None,
-    execute: Annotated[bool, typer.Option("--execute", help="Apply (default: dry run)")] = False,
-    root: Annotated[Path, typer.Option("--root", help="Dataset root")] = _DATASET_ROOT_DEFAULT,
+    execute: Annotated[
+        bool, typer.Option("--execute", help="Apply (default: dry run)")
+    ] = False,
+    root: Annotated[
+        Path, typer.Option("--root", help="Dataset root")
+    ] = _DATASET_ROOT_DEFAULT,
 ) -> None:
     """Cut a new schema within a gen."""
     run_bump_schema(
@@ -227,7 +252,9 @@ def bump_schema(
 
 @app.command()
 def status(
-    root: Annotated[Path, typer.Option("--root", help="Dataset root")] = _DATASET_ROOT_DEFAULT,
+    root: Annotated[
+        Path, typer.Option("--root", help="Dataset root")
+    ] = _DATASET_ROOT_DEFAULT,
 ) -> None:
     """List existing gens/schemas per kind."""
     run_status(str(root))
@@ -248,10 +275,13 @@ def update_manifest(
     ] = None,
     gen: Annotated[
         Optional[str],
-        typer.Option("--gen", metavar="genN", help="Target gen tag (default: keep existing gen)"),
+        typer.Option(
+            "--gen", metavar="genN", help="Target gen tag (default: keep existing gen)"
+        ),
     ] = None,
     execute: Annotated[
-        bool, typer.Option("--execute", help="Write updated manifests (default: dry run)")
+        bool,
+        typer.Option("--execute", help="Write updated manifests (default: dry run)"),
     ] = False,
 ) -> None:
     """Repoint manifest(s) to a new gen and/or schema, verifying all target files exist."""
@@ -278,7 +308,9 @@ def create_manifest(
     ] = None,
     type_: Annotated[
         Optional[PoolType],
-        typer.Option("--type", help="Pool type — full, holdout, or dev (required with --pool)"),
+        typer.Option(
+            "--type", help="Pool type — full, holdout, or dev (required with --pool)"
+        ),
     ] = None,
     root: Annotated[
         Path, typer.Option("--root", help="Dataset root (used with --pool)")
@@ -323,7 +355,9 @@ def make_root(
     gen: Annotated[
         str, typer.Option("--gen", help="Existing gen tag under raw/<kind>/, e.g. gen1")
     ],
-    kind: Annotated[str, typer.Option("--kind", help="steps | hits | ... (default: steps)")] = "steps",
+    kind: Annotated[
+        str, typer.Option("--kind", help="steps | hits | ... (default: steps)")
+    ] = "steps",
     dataset_root: Annotated[
         Path, typer.Option("--dataset-root", help="Dataset root")
     ] = _DATASET_ROOT_DEFAULT,
@@ -331,7 +365,10 @@ def make_root(
         int, typer.Option("--jobs", "-j", help="Parallel simulation runs (default: 4)")
     ] = 4,
     execute: Annotated[
-        bool, typer.Option("--execute", help="Actually run jobs (default: dry run / print plan)")
+        bool,
+        typer.Option(
+            "--execute", help="Actually run jobs (default: dry run / print plan)"
+        ),
     ] = False,
 ) -> None:
     """Generate new ROOT shards via a minicalosim executable."""

scripts/steps_to_parquet_parallel.py

@@ -202,7 +202,10 @@ def run_parallel_job(
 
     failures = [root_file for root_file, code, _, _ in results if code != 0]
     if failures:
-        print(f"\n{len(failures)} of {len(results)} conversion(s) failed:", file=sys.stderr)
+        print(
+            f"\n{len(failures)} of {len(results)} conversion(s) failed:",
+            file=sys.stderr,
+        )
         for root_file in failures:
             print(f"  {root_file}", file=sys.stderr)
         raise SystemExit(1)