Strengthen Python tooling and reorganize E2E driver

Author: gajop

build/sbc_packager/application/archive.py

@@ -22,7 +22,7 @@ def create_application_archive(application_dir: Path, platform: str) -> Path:
 
 def write_file_manifest(application_dir: Path) -> Path:
     manifest_path = application_dir / "files.md5.gz"
-    entries = []
+    entries: list[str] = []
     for path in sorted(application_dir.rglob("*")):
         if path == manifest_path or path.is_symlink() or not path.is_file() or path.suffix == ".dbg":
             continue

build/sbc_packager/application/cli.py

@@ -4,9 +4,15 @@
 
 import typer
 
-from ..editor.archive import find_engine_loading_image, normalize_platform, prepare_game_archive, resolve_game_name
-from ..shared.archive import write_sha256
-from ..shared.files import collect_generated_top_level_excludes
+from sbc_packager.editor.archive import (
+    find_engine_loading_image,
+    normalize_platform,
+    prepare_game_archive,
+    resolve_game_name,
+)
+from sbc_packager.shared.archive import write_sha256
+from sbc_packager.shared.files import collect_generated_top_level_excludes
+
 from .archive import create_application_archive, write_file_manifest
 from .config import read_application_config, render_start_script, write_springsettings
 from .engine import install_engine, prune_engine, rename_engine

build/sbc_packager/application/config.py

@@ -1,13 +1,13 @@
 import json
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any
+from typing import cast
 
 
 @dataclass(frozen=True)
 class ApplicationConfig:
-    launch: dict[str, Any]
-    springsettings: dict[str, Any]
+    launch: dict[str, object]
+    springsettings: dict[str, object]
 
 
 def read_application_config(path: Path) -> ApplicationConfig:
@@ -16,12 +16,12 @@ def read_application_config(path: Path) -> ApplicationConfig:
     if not isinstance(data, dict):
         raise RuntimeError(f"Distribution configuration must be an object: {path}")
     return ApplicationConfig(
-        launch=require_object(data, "launch"),
-        springsettings=require_object(data, "springsettings"),
+        launch=require_object(cast("dict[str, object]", data), "launch"),
+        springsettings=require_object(cast("dict[str, object]", data), "springsettings"),
     )
 
 
-def render_start_script(game_name: str, launch: dict[str, Any]) -> str:
+def render_start_script(game_name: str, launch: dict[str, object]) -> str:
     map_name = require_string(launch, "map")
     game_options = render_game_options(launch.get("game_options"))
     map_options = render_options_block("MapOptions", launch.get("map_options"))
@@ -51,22 +51,22 @@ def render_start_script(game_name: str, launch: dict[str, Any]) -> str:
     )
 
 
-def write_springsettings(settings: dict[str, Any], destination: Path) -> Path:
+def write_springsettings(settings: dict[str, object], destination: Path) -> Path:
     values = {**settings, "DefaultStartScript": "script.txt"}
     output = destination / "springsettings.cfg"
     lines = [f"{key}={format_setting(value)}" for key, value in sorted(values.items())]
     output.write_text("\n".join(lines) + "\n", encoding="utf-8")
     return output
 
 
-def require_object(values: dict[str, Any], key: str) -> dict[str, Any]:
+def require_object(values: dict[str, object], key: str) -> dict[str, object]:
     value = values.get(key)
     if not isinstance(value, dict):
         raise RuntimeError(f"Distribution configuration requires an object '{key}'")
-    return value
+    return cast("dict[str, object]", value)
 
 
-def require_string(values: dict[str, Any], key: str) -> str:
+def require_string(values: dict[str, object], key: str) -> str:
     value = values.get(key)
     if not isinstance(value, str) or not value:
         raise RuntimeError(f"Launch configuration requires a non-empty '{key}' value")
@@ -86,12 +86,12 @@ def render_options_block(name: str, value: object) -> str:
     return f"\t[{name}]\n\t{{\n{entries}\n\t}}"
 
 
-def require_options(value: object, name: str) -> dict[str, Any]:
+def require_options(value: object, name: str) -> dict[str, object]:
     if value is None:
         return {}
     if not isinstance(value, dict):
         raise RuntimeError(f"Launch configuration '{name}' must be an object")
-    return value
+    return cast("dict[str, object]", value)
 
 
 def render_value(value: object) -> str:

build/sbc_packager/editor/archive.py

@@ -3,10 +3,10 @@
 import shutil
 import tempfile
 from pathlib import Path
-from typing import Literal
+from typing import Literal, cast
 
-from ..shared.archive import write_game_archive
-from ..shared.files import copy_repo_filtered
+from sbc_packager.shared.archive import write_game_archive
+from sbc_packager.shared.files import copy_repo_filtered
 
 Platform = Literal["linux", "win32"]
 SUPPORTED_IMAGE_SUFFIXES = {".jpg", ".jpeg", ".png"}
@@ -102,9 +102,10 @@ def install_port_flags(run_config: Path, game_directory: Path) -> None:
         config = json.load(source)
     if not isinstance(config, dict):
         raise RuntimeError(f"Run configuration must be an object: {run_config}")
+    raw_config = cast("dict[str, object]", config)
     flags: dict[str, str] = {}
     for key in PORT_FLAG_KEYS:
-        value = config.get(key)
+        value = raw_config.get(key)
         valid_values = VALID_PORT_FLAGS[key]
         if not isinstance(value, str) or value not in valid_values:
             choices = ", ".join(sorted(valid_values))

build/sbc_packager/editor/cli.py

@@ -5,8 +5,9 @@
 
 import typer
 
-from ..shared.archive import write_sha256
-from ..shared.files import collect_generated_top_level_excludes
+from sbc_packager.shared.archive import write_sha256
+from sbc_packager.shared.files import collect_generated_top_level_excludes
+
 from .archive import normalize_platform, prepare_game_archive, resolve_game_name
 
 app = typer.Typer(add_completion=False, no_args_is_help=True)

justfile

@@ -11,10 +11,12 @@ tool_pythonpath := "build:tools"
 default:
     just --list
 
-# Check Rust formatting for the native crate.
+# Apply mechanical formatting before the checks below.
 [group('lint')]
 fmt:
-    cd native && cargo fmt --check
+    cd native && cargo fmt
+    PYTHONPATH="{{tool_pythonpath}}" uv run --locked ruff check --fix build tools
+    PYTHONPATH="{{tool_pythonpath}}" uv run --locked ruff format build tools
 
 # Run clippy on all native targets with warnings denied.
 [group('lint')]

native/src/sbc/heightmap/brushes.rs

@@ -23,18 +23,6 @@ pub(crate) struct ShapeModify;
 pub(crate) struct Level;
 pub(crate) struct Smooth;
 
-fn centre(stamp: BrushStamp) -> (f32, f32) {
-    (stamp.x + stamp.size / 2.0, stamp.z + stamp.size / 2.0)
-}
-
-fn signed_strength(brush: &BrushSettings, button: BrushButton) -> f32 {
-    if button.is_secondary() {
-        -brush.strength
-    } else {
-        brush.strength
-    }
-}
-
 pub(crate) fn prepare_pattern(
     brush: &BrushSettings,
     uploaded: &mut HashSet<String>,
@@ -57,6 +45,18 @@ pub(crate) fn prepare_pattern(
     true
 }
 
+fn centre(stamp: BrushStamp) -> (f32, f32) {
+    (stamp.x + stamp.size / 2.0, stamp.z + stamp.size / 2.0)
+}
+
+fn signed_strength(brush: &BrushSettings, button: BrushButton) -> f32 {
+    if button.is_secondary() {
+        -brush.strength
+    } else {
+        brush.strength
+    }
+}
+
 impl MapBrush for ShapeModify {
     fn name(&self) -> &'static str {
         "terrain-shape-modify"

native/src/sbc/states/map_editing.rs

@@ -34,17 +34,17 @@ pub(crate) enum BrushButton {
 }
 
 impl BrushButton {
+    pub(crate) fn is_secondary(self) -> bool {
+        self == Self::Secondary
+    }
+
     fn from_mouse(button: i32) -> Self {
         if button == RIGHT {
             Self::Secondary
         } else {
             Self::Primary
         }
     }
-
-    pub(crate) fn is_secondary(self) -> bool {
-        self == Self::Secondary
-    }
 }
 
 /// Domain-owned behaviour for a map brush. Adding a tool means implementing

pyproject.toml

@@ -39,9 +39,66 @@ line-length = 120
 target-version = "py313"
 
 [tool.ruff.lint]
-select = ["E", "F", "I", "UP", "B", "SIM"]
+select = [
+    "A",
+    "ANN",
+    "ARG",
+    "ASYNC",
+    "B",
+    "C4",
+    "C90",
+    "DTZ",
+    "E",
+    "ERA",
+    "EXE",
+    "F",
+    "FA",
+    "FLY",
+    "FURB",
+    "G",
+    "I",
+    "ICN",
+    "INP",
+    "ISC",
+    "LOG",
+    "N",
+    "PERF",
+    "PIE",
+    "PT",
+    "PTH",
+    "RET",
+    "RSE",
+    "RUF",
+    "SIM",
+    "SLOT",
+    "T10",
+    "TC",
+    "TID",
+    "UP",
+    "YTT",
+]
+
+[tool.ruff.lint.per-file-ignores]
+"tools/smoke/test_*.py" = ["S101"]
 
 [tool.pyright]
 pythonVersion = "3.13"
-typeCheckingMode = "standard"
+typeCheckingMode = "strict"
 reportMissingTypeStubs = false
+reportImplicitOverride = "error"
+reportMissingTypeArgument = "error"
+reportPrivateImportUsage = "error"
+reportUnknownArgumentType = "error"
+reportUnknownLambdaType = "error"
+reportUnknownMemberType = "error"
+reportUnknownParameterType = "error"
+reportUnknownVariableType = "error"
+reportUnnecessaryCast = "error"
+reportUnnecessaryComparison = "error"
+reportUnnecessaryContains = "error"
+reportUnnecessaryIsInstance = "error"
+reportUnnecessaryTypeIgnoreComment = "error"
+reportUntypedBaseClass = "error"
+reportUntypedClassDecorator = "error"
+reportUntypedFunctionDecorator = "error"
+reportUntypedNamedTuple = "error"

tools/e2e/cli_e2e.py

@@ -2,8 +2,8 @@
 
 import typer
 
-from .cases import TARGETS, select_cases, target_cases
-from .golden import STATUS_APPROVED, approve_review, load_review
+from .driver.cases import TARGETS, select_cases, target_cases
+from .driver.utils.golden import GOLDEN_ROOT, STATUS_APPROVED, approve_review, load_review
 from .runner import E2ERun
 
 app = typer.Typer(no_args_is_help=True)
@@ -53,19 +53,17 @@ def run(
 
 @app.command("goldens-status")
 def goldens_status() -> None:
-    from .golden import GOLDEN_ROOT
-
     pending = 0
     for case_dir in sorted(GOLDEN_ROOT.iterdir()):
         if not case_dir.is_dir():
             continue
         review = load_review(case_dir.name)
         shots = sorted(path.stem for path in case_dir.glob("*.png"))
-        approved = sum(review.get(shot, {}).get("status") == STATUS_APPROVED for shot in shots)
+        approved = sum(shot in review and review[shot]["status"] == STATUS_APPROVED for shot in shots)
         pending += len(shots) - approved
         typer.echo(f"{case_dir.name:26} {approved}/{len(shots)} approved")
         for shot in shots:
-            if review.get(shot, {}).get("status") != STATUS_APPROVED:
+            if shot not in review or review[shot]["status"] != STATUS_APPROVED:
                 typer.echo(f"    ai-reviewed  {shot}")
     if pending:
         typer.echo(f"\n{pending} image(s) awaiting approval.")