Add files using upload-large-folder tool

backup.py

@@ -0,0 +1,198 @@
+#!/usr/bin/env python3
+"""Back up this workspace -- results, spatial codes, AND the code/setup itself -- to a
+Hugging Face dataset repo.
+
+Every "target" maps to one or more self-contained local paths (directories or single
+files), each uploaded with the exact same relative path it has in the workspace
+(results/A/... stays results/A/... in the repo, backup.py stays backup.py). That's what
+makes this safe to call repeatedly, once per plan, without ever overwriting or deleting
+anything outside the target you asked for:
+
+- Each target's --allow-patterns scope is disjoint from every other target's (results/A
+  vs results/B vs ... vs "data/spatial codes" vs "code"'s own paths), so backing up B can
+  never touch what A already uploaded.
+- huggingface_hub's upload_large_folder() only ever adds or updates the files it's given
+  -- it never deletes anything else already in the repo (no delete_patterns is passed
+  here, ever), so re-running the same target later (more scenes finished, --rebuild
+  reran a config, source files edited) just adds/updates those files' remote copies.
+- "symbolic" covers BOTH results/symbolic/<depth>/... (production) and
+  results/symbolic/ground truth/... in one call, since the latter is already nested
+  under the former; "spatial-codes" likewise covers both encoder-perceived
+  ("data/spatial codes/<model>/...") and ground-truth ("data/spatial codes/ground
+  truth/...") codes in one call, satisfying "upload after the regenerate spatial code
+  parts" without a separate target for it.
+- "code" covers every source directory (harness, symbolic, analysis, encoder,
+  inference, tests) plus the top-level README.md, backup.py, and setup.sh -- everything
+  needed to reproduce or re-run the experiment, not just its output. Deliberately
+  excludes data/ and results/ (covered by their own targets already) and experiments/
+  (a separate, concluded track, not part of the reproducible pipeline).
+
+Usage:
+    python backup.py --repo-id <you>/<repo> --target A
+    python backup.py --repo-id <you>/<repo> --target all
+    HF_TOKEN=hf_xxx python backup.py --repo-id <you>/<repo> --target spatial-codes
+    python backup.py --repo-id <you>/<repo> --target D --dry-run   # no token/network needed
+    python backup.py                                                # fully interactive
+
+Run after each plan finishes:
+    Plan A done            -> python backup.py --repo-id <you>/<repo> --target A
+    spatial codes regen'd  -> python backup.py --repo-id <you>/<repo> --target spatial-codes
+    Plan B done            -> python backup.py --repo-id <you>/<repo> --target B
+    Plan C done            -> python backup.py --repo-id <you>/<repo> --target C
+    Plan D done            -> python backup.py --repo-id <you>/<repo> --target D
+    symbolic runs done     -> python backup.py --repo-id <you>/<repo> --target symbolic
+    code/setup changed     -> python backup.py --repo-id <you>/<repo> --target code
+
+--repo-id, --target, and the Hugging Face token are all prompted for interactively
+(the token hidden) when not supplied via flag or $HF_TOKEN -- no separate shell wrapper
+needed to get that interactive setup.sh-style experience.
+"""
+
+from __future__ import annotations
+
+import argparse
+import getpass
+import os
+import sys
+from pathlib import Path
+
+WORKSPACE_ROOT = Path(__file__).resolve().parent
+
+# name -> list of paths (directories or single files, relative to WORKSPACE_ROOT)
+TARGETS = {
+    "A": ["results/A"],
+    "B": ["results/B"],
+    "C": ["results/C"],
+    "D": ["results/D"],
+    "symbolic": ["results/symbolic"],
+    "spatial-codes": ["data/spatial codes"],
+    "code": [
+        "README.md",
+        "backup.py",
+        "setup.sh",
+        "harness",
+        "symbolic",
+        "analysis",
+        "encoder",
+        "inference",
+        "tests",
+    ],
+}
+
+
+def _resolve_targets(target):
+    if target == "all":
+        return list(TARGETS)
+    if target in TARGETS:
+        return [target]
+    raise ValueError(f"unknown target {target!r}; expected one of {list(TARGETS) + ['all']}")
+
+
+def _has_content(local_path):
+    """True if this path is a real file, or a directory containing at least one file."""
+    if local_path.is_file():
+        return True
+    if local_path.is_dir():
+        return any(p.is_file() for p in local_path.rglob("*"))
+    return False
+
+
+def _allow_pattern(path):
+    """A directory needs a /** glob to sweep its contents; a single file's own relative
+    path already IS the exact pattern upload_large_folder needs."""
+    return f"{path}/**" if (WORKSPACE_ROOT / path).is_dir() else path
+
+
+def backup(repo_id, target, token=None, private=False, dry_run=False):
+    """Upload one (or every) target's paths to repo_id, preserving their exact relative
+    workspace paths. Returns the list of target names actually uploaded (skips any whose
+    local paths don't exist yet or are empty)."""
+    names = _resolve_targets(target)
+
+    pending = []
+    for name in names:
+        paths = TARGETS[name]
+        if not any(_has_content(WORKSPACE_ROOT / p) for p in paths):
+            print(f"[{name}] skipped -- nothing found at {', '.join(paths)}")
+            continue
+        pending.append(name)
+
+    if not pending:
+        return []
+
+    if dry_run:
+        for name in pending:
+            for path in TARGETS[name]:
+                print(f"[{name}] would upload {WORKSPACE_ROOT / path} -> {repo_id}:{path}")
+        return pending
+
+    from huggingface_hub import HfApi
+
+    api = HfApi(token=token)
+    api.create_repo(repo_id=repo_id, repo_type="dataset", private=private, exist_ok=True)
+
+    for name in pending:
+        patterns = [_allow_pattern(p) for p in TARGETS[name]]
+        print(f"[{name}] uploading {', '.join(TARGETS[name])} -> {repo_id} ...")
+        api.upload_large_folder(
+            repo_id=repo_id,
+            repo_type="dataset",
+            folder_path=str(WORKSPACE_ROOT),
+            allow_patterns=patterns,
+        )
+        print(f"[{name}] done")
+    return pending
+
+
+def main():
+    parser = argparse.ArgumentParser()
+    parser.add_argument(
+        "--repo-id", default=None, help="e.g. yourname/vsi-spatial-code-results"
+    )
+    parser.add_argument("--target", default=None, choices=list(TARGETS) + ["all"])
+    parser.add_argument(
+        "--token", default=None, help="defaults to $HF_TOKEN, then a cached hf login"
+    )
+    parser.add_argument("--private", action="store_true", help="create the repo private if new")
+    parser.add_argument(
+        "--dry-run", action="store_true",
+        help="print what would be uploaded and exit -- no token or network needed",
+    )
+    args = parser.parse_args()
+
+    repo_id = args.repo_id or input(
+        "Hugging Face dataset repo to back up to (e.g. yourname/vsi-spatial-code-results): "
+    ).strip()
+    if not repo_id:
+        parser.error("no repo given")
+
+    target = args.target
+    if target is None:
+        target = input(f"Target [{'|'.join(list(TARGETS) + ['all'])}]: ").strip()
+    if target not in TARGETS and target != "all":
+        parser.error(f"unknown target {target!r}; expected one of {list(TARGETS) + ['all']}")
+
+    token = args.token or os.environ.get("HF_TOKEN") or os.environ.get("HUGGING_FACE_HUB_TOKEN")
+    if not args.dry_run and token is None:
+        print(f"Hugging Face token needed to upload to {repo_id} (write access)")
+        print("Create one at https://huggingface.co/settings/tokens")
+        token = getpass.getpass("HF token (input hidden): ").strip()
+    if not args.dry_run and not token:
+        parser.error(
+            "no Hugging Face token given -- pass --token, set $HF_TOKEN, or run "
+            "`huggingface-cli login` first (not needed for --dry-run)"
+        )
+
+    uploaded = backup(
+        repo_id, target, token=token, private=args.private, dry_run=args.dry_run
+    )
+    if not uploaded:
+        print("nothing to upload")
+        sys.exit(1)
+    print(f"\n{'would upload' if args.dry_run else 'uploaded'} target(s): {', '.join(uploaded)}")
+    if not args.dry_run:
+        print(f"https://huggingface.co/datasets/{repo_id}")
+
+
+if __name__ == "__main__":
+    main()

encoder/render.py

@@ -16,7 +16,7 @@ def build_spatial_code_for(
     tracking,
     frame_count=config.FRAMES_PER_VIDEO,
     rebuild=False,
-    spatial_code_format="original",
+    spatial_code_format="explicit",
 ):
     """Build a spatial code from cached or newly adapted scene geometry."""
     spatial_code_format = perceive.adapters.validate_spatial_code_format(
@@ -36,7 +36,7 @@ def write_spatial_code_for(
     tracking,
     frame_count=config.FRAMES_PER_VIDEO,
     rebuild=False,
-    spatial_code_format="original",
+    spatial_code_format="explicit",
 ):
     """Build and write one scene's spatial-code JSON."""
     code, how = build_spatial_code_for(

tests/test_encoder/.pytest_cache/.gitignore

@@ -0,0 +1,2 @@
+# Created by pytest automatically.
+*

tests/test_encoder/.pytest_cache/CACHEDIR.TAG

@@ -0,0 +1,4 @@
+Signature: 8a477f597d28d172789f06886806bc55
+# This file is a cache directory tag created by pytest.
+# For information about cache directory tags, see:
+#	https://bford.info/cachedir/spec.html

tests/test_encoder/.pytest_cache/README.md

@@ -0,0 +1,8 @@
+# pytest cache directory #
+
+This directory contains data from the pytest's cache plugin,
+which provides the `--lf` and `--ff` options, as well as the `cache` fixture.
+
+**Do not** commit this to version control.
+
+See [the docs](https://docs.pytest.org/en/stable/how-to/cache.html) for more information.

tests/test_encoder/.pytest_cache/v/cache/nodeids

@@ -0,0 +1 @@
+[]

tests/test_encoder/test_adapters.py

@@ -1,3 +1,5 @@
+"""Tests for encoder/adapters.py -- model-output adapters and canonical geometry validation."""
+
 import gzip
 import pickle
 import sys
@@ -289,7 +291,7 @@ def test_native_sam3_decodes_lossless_tracking_cache(monkeypatch):
 
 def test_spatial_code_format_validation():
     assert adapters.validate_spatial_code_format("compact") == "compact"
-    assert adapters.validate_spatial_code_format("original") == "original"
+    assert adapters.validate_spatial_code_format("explicit") == "explicit"
     with pytest.raises(ValueError, match="unknown spatial-code format"):
         adapters.validate_spatial_code_format("unknown")
 

tests/test_encoder/test_config.py

@@ -1,3 +1,5 @@
+"""Tests for encoder/config.py -- cache and spatial-code path helpers."""
+
 import pytest
 
 from encoder import config
@@ -14,7 +16,7 @@ def test_encoder_paths_mirror_all_dimensions(tmp_path, monkeypatch):
     ).endswith("depth-anything-3/relative/uniform/32/scene.pkl")
     assert config.spatial_code_path(
         "scene", "metric", "selective", "tracking", 64
-    ).endswith("metric/tracking/selective/64/original/scene.json")
+    ).endswith("metric/tracking/selective/64/explicit/scene.json")
     assert config.spatial_code_path(
         "scene", "relative", "uniform", "no tracking", 96, "compact"
     ).endswith("relative/no tracking/uniform/96/compact/scene.json")
@@ -25,3 +27,18 @@ def test_encoder_paths_reject_unknown_spatial_code_format():
         config.spatial_code_path(
             "scene", "metric", "uniform", "tracking", 32, "unknown"
         )
+
+
+def test_ground_truth_paths_have_no_depth_tracking_input_frames_axis(tmp_path, monkeypatch):
+    monkeypatch.setattr(config, "CODES_ROOT", tmp_path / "codes")
+    assert config.ground_truth_spatial_code_path("scene", "explicit").endswith(
+        "codes/ground truth/explicit/scene.json"
+    )
+    assert config.ground_truth_spatial_code_path("scene", "compact").endswith(
+        "codes/ground truth/compact/scene.json"
+    )
+
+
+def test_ground_truth_paths_reject_unknown_spatial_code_format():
+    with pytest.raises(ValueError, match="unknown spatial-code format"):
+        config.ground_truth_spatial_code_path("scene", "unknown")

tests/test_encoder/test_encoder.py

@@ -1,3 +1,6 @@
+"""Tests for encoder/geometric.py's low-level geometry primitives (backprojection,
+direction/turn classification, distance, centroid/extent math)."""
+
 import numpy as np
 import pytest
 

tests/test_encoder/test_ground_truth.py

@@ -0,0 +1,289 @@
+"""Tests for encoder/ground_truth.py -- spatial codes built from dataset annotations."""
+
+import json
+import math
+
+import numpy as np
+import pytest
+
+from encoder import config, geometric
+from encoder import ground_truth as gt
+
+IDENTITY_AXES = [1, 0, 0, 0, 1, 0, 0, 0, 1]
+
+
+def _instance(centroid, dims, axes=None):
+    return {
+        "centroid": list(centroid),
+        "axesLengths": list(dims),
+        "normalizedAxes": list(axes if axes is not None else IDENTITY_AXES),
+    }
+
+
+def _write_meta_info(tmp_path, scannet=None, arkitscenes=None, scannetpp=None):
+    meta_dir = tmp_path / "thinking-in-space" / "data" / "meta_info"
+    meta_dir.mkdir(parents=True)
+    for dataset, records in (
+        ("scannet", scannet or {}),
+        ("arkitscenes", arkitscenes or {}),
+        ("scannetpp", scannetpp or {}),
+    ):
+        with open(meta_dir / f"{dataset}_meta_info_val.json", "w") as stream:
+            json.dump(records, stream)
+    return meta_dir
+
+
+@pytest.fixture(autouse=True)
+def _clear_ground_truth_caches():
+    gt.load_meta_info.cache_clear()
+    gt._appearance_order_ranks_by_scene.cache_clear()
+    yield
+    gt.load_meta_info.cache_clear()
+    gt._appearance_order_ranks_by_scene.cache_clear()
+
+
+def test_load_meta_info_merges_all_three_datasets_and_tags_dataset(tmp_path, monkeypatch):
+    _write_meta_info(
+        tmp_path,
+        scannet={"scene0001_00": {"room_size": 10.0, "object_bbox": {}}},
+        arkitscenes={"41000000": {"room_size": 12.0, "object_bbox": {}}},
+        scannetpp={"abc123": {"room_size": 14.0, "object_bbox": {}}},
+    )
+    monkeypatch.setattr(gt, "META_INFO_DIR", tmp_path / "thinking-in-space" / "data" / "meta_info")
+    merged = gt.load_meta_info()
+    assert merged["scene0001_00"]["dataset"] == "scannet"
+    assert merged["41000000"]["dataset"] == "arkitscenes"
+    assert merged["abc123"]["dataset"] == "scannetpp"
+
+
+def test_floor_level_is_the_lowest_box_support_across_every_instance():
+    object_bbox = {
+        "chair": [_instance([0, 0, 1.0], [1, 1, 0.4])],  # spans z in [0.8, 1.2]
+        "table": [_instance([0, 0, 0.5], [1, 1, 1.0])],  # spans z in [0.0, 1.0]
+    }
+    # table reaches lower (0.0) than chair (0.8) -> floor_level should be 0.0
+    assert gt._floor_level(object_bbox) == pytest.approx(0.0)
+
+
+def test_floor_level_accounts_for_tilted_box_support():
+    # a box tilted 45 degrees around x has a lower support than its centroid_z - half_z
+    # would suggest if you ignored orientation.
+    axes = [
+        [1, 0, 0],
+        [0, math.cos(math.pi / 4), math.sin(math.pi / 4)],
+        [0, -math.sin(math.pi / 4), math.cos(math.pi / 4)],
+    ]
+    flat_axes = [v for row in axes for v in row]
+    object_bbox = {"box": [_instance([0, 0, 1.0], [1, 2, 2], axes=flat_axes)]}
+    half_extent_z = (1 / 2) * abs(0) + (2 / 2) * abs(math.sin(math.pi / 4)) + (
+        2 / 2
+    ) * abs(math.cos(math.pi / 4))
+    assert gt._floor_level(object_bbox) == pytest.approx(1.0 - half_extent_z)
+
+
+def test_floor_level_defaults_to_zero_for_empty_scene():
+    assert gt._floor_level({}) == 0.0
+
+
+def test_gt_oriented_box_rebases_height_above_floor_and_passes_xy_through():
+    instance = _instance([1.234, -2.345, 3.456], [1.0, 2.0, 3.0])
+    box = gt._gt_oriented_box(instance, floor_level=1.0)
+    center = box["3D oriented bounding box center coordinates"]
+    assert center == [1.23, -2.35, 2.46]
+    assert box["3D oriented bounding box dimensions"] == [1.0, 2.0, 3.0]
+    assert box["3D oriented bounding box orientation unit vectors"] == [
+        [1.0, 0.0, 0.0],
+        [0.0, 1.0, 0.0],
+        [0.0, 0.0, 1.0],
+    ]
+
+
+def test_gt_oriented_box_renormalizes_orientation_vectors():
+    axes = [2, 0, 0, 0, 2, 0, 0, 0, 2]  # not unit length
+    instance = _instance([0, 0, 0], [1, 1, 1], axes=axes)
+    box = gt._gt_oriented_box(instance, floor_level=0.0)
+    for row in box["3D oriented bounding box orientation unit vectors"]:
+        assert np.linalg.norm(row) == pytest.approx(1.0)
+
+
+def test_gt_floor_boundary_polygon_area_matches_room_size():
+    polygons = gt._gt_floor_boundary_polygons(room_size=16.0, room_center=[3.0, -2.0, 0.0])
+    assert len(polygons) == 1
+    area = geometric._compact_polygon_area(polygons[0]["outer boundary coordinates"])
+    assert area == pytest.approx(16.0, abs=0.01)
+    assert polygons[0]["interior hole boundary coordinates"] == []
+
+
+def test_appearance_order_ranks_topological_across_multiple_questions(tmp_path, monkeypatch):
+    jsonl_path = tmp_path / "test.jsonl"
+    questions = [
+        {
+            "scene_name": "scene1",
+            "question_type": "obj_appearance_order",
+            "ground_truth": "A",
+            "options": ["A. chair, table, lamp", "B. lamp, table, chair"],
+        },
+        {
+            "scene_name": "scene1",
+            "question_type": "obj_appearance_order",
+            "ground_truth": "A",
+            "options": ["A. table, sofa", "B. sofa, table"],
+        },
+        {
+            "scene_name": "scene2",
+            "question_type": "object_counting",
+            "ground_truth": "3",
+            "options": None,
+        },
+    ]
+    with open(jsonl_path, "w") as stream:
+        for question in questions:
+            stream.write(json.dumps(question) + "\n")
+    monkeypatch.setattr(config, "JSONL", jsonl_path)
+
+    ranks = gt._appearance_order_ranks_by_scene()
+    assert "scene2" not in ranks
+    scene1 = ranks["scene1"]
+    assert scene1["chair"] < scene1["table"] < scene1["lamp"]
+    assert scene1["table"] < scene1["sofa"]
+
+
+def test_build_compact_ground_truth_spatial_code_uses_ranks_and_nulls_unranked(
+    tmp_path, monkeypatch
+):
+    _write_meta_info(
+        tmp_path,
+        scannet={
+            "scene1": {
+                "room_size": 9.0,
+                "room_center": [0.0, 0.0, 0.0],
+                "object_bbox": {
+                    "chair": [_instance([0, 0, 0.5], [1, 1, 1])],
+                    "lamp": [_instance([1, 1, 0.5], [0.2, 0.2, 0.2])],
+                },
+            }
+        },
+    )
+    monkeypatch.setattr(gt, "META_INFO_DIR", tmp_path / "thinking-in-space" / "data" / "meta_info")
+    jsonl_path = tmp_path / "test.jsonl"
+    with open(jsonl_path, "w") as stream:
+        stream.write(
+            json.dumps(
+                {
+                    "scene_name": "scene1",
+                    "question_type": "obj_appearance_order",
+                    "ground_truth": "A",
+                    "options": ["A. chair, lamp"],
+                }
+            )
+            + "\n"
+        )
+    monkeypatch.setattr(config, "JSONL", jsonl_path)
+
+    code = gt.build_compact_ground_truth_spatial_code("scene1")
+    assert code["spatial code schema"] is geometric.COMPACT_SPATIAL_CODE_SCHEMA
+    assert code["objects"]["chair"][0]["first visible time"] == 0.0
+    assert code["objects"]["lamp"][0]["first visible time"] == 1.0
+
+
+def test_build_compact_ground_truth_spatial_code_nulls_untimed_classes(tmp_path, monkeypatch):
+    _write_meta_info(
+        tmp_path,
+        scannet={
+            "scene1": {
+                "room_size": 9.0,
+                "room_center": [0.0, 0.0, 0.0],
+                "object_bbox": {"chair": [_instance([0, 0, 0.5], [1, 1, 1])]},
+            }
+        },
+    )
+    monkeypatch.setattr(gt, "META_INFO_DIR", tmp_path / "thinking-in-space" / "data" / "meta_info")
+    monkeypatch.setattr(config, "JSONL", tmp_path / "empty.jsonl")
+    (tmp_path / "empty.jsonl").write_text("")
+
+    code = gt.build_compact_ground_truth_spatial_code("scene1")
+    assert code["objects"]["chair"][0]["first visible time"] is None
+
+
+def test_build_compact_ground_truth_spatial_code_raises_for_unknown_scene(tmp_path, monkeypatch):
+    _write_meta_info(tmp_path)
+    monkeypatch.setattr(gt, "META_INFO_DIR", tmp_path / "thinking-in-space" / "data" / "meta_info")
+    monkeypatch.setattr(config, "JSONL", tmp_path / "empty.jsonl")
+    (tmp_path / "empty.jsonl").write_text("")
+    with pytest.raises(KeyError):
+        gt.build_compact_ground_truth_spatial_code("nonexistent")
+
+
+def test_build_explicit_ground_truth_spatial_code_is_derived_from_compact(monkeypatch):
+    compact_code = {
+        "spatial code schema": geometric.COMPACT_SPATIAL_CODE_SCHEMA,
+        "objects": {
+            "chair": [
+                {
+                    "3D oriented bounding box": {
+                        "3D oriented bounding box center coordinates": [0, 0, 0.5],
+                        "3D oriented bounding box dimensions": [1, 1, 1],
+                        "3D oriented bounding box orientation unit vectors": [
+                            [1, 0, 0],
+                            [0, 1, 0],
+                            [0, 0, 1],
+                        ],
+                    },
+                    "first visible time": 0.0,
+                }
+            ]
+        },
+        "room": {"floor boundary polygons": []},
+    }
+    monkeypatch.setattr(gt, "build_compact_ground_truth_spatial_code", lambda scene: compact_code)
+    explicit_code = gt.build_explicit_ground_truth_spatial_code("scene1")
+    assert explicit_code["spatial code schema"] is geometric.EXPLICIT_SPATIAL_CODE_SCHEMA
+    assert explicit_code["objects"]["chair"]["count"] == 1
+    assert explicit_code["appearance order"] == ["chair"]
+
+
+def test_build_ground_truth_spatial_code_dispatches_by_format(monkeypatch):
+    monkeypatch.setattr(gt, "build_compact_ground_truth_spatial_code", lambda scene: "compact-code")
+    monkeypatch.setattr(gt, "build_explicit_ground_truth_spatial_code", lambda scene: "explicit-code")
+    assert gt.build_ground_truth_spatial_code("scene1", "compact") == "compact-code"
+    assert gt.build_ground_truth_spatial_code("scene1", "explicit") == "explicit-code"
+
+
+def test_build_ground_truth_spatial_code_rejects_unknown_format():
+    with pytest.raises(ValueError, match="unknown spatial-code format"):
+        gt.build_ground_truth_spatial_code("scene1", "unknown")
+
+
+def test_build_and_write_writes_to_the_ground_truth_path(tmp_path, monkeypatch):
+    monkeypatch.setattr(config, "CODES_ROOT", tmp_path / "codes")
+    monkeypatch.setattr(gt, "build_ground_truth_spatial_code", lambda scene, fmt: {"objects": {}})
+    path = gt.build_and_write("scene1", "explicit")
+    assert path.endswith("codes/ground truth/explicit/scene1.json")
+    assert json.loads(open(path).read()) == {"objects": {}}
+
+
+def test_scenes_returns_sorted_meta_info_keys(tmp_path, monkeypatch):
+    _write_meta_info(
+        tmp_path,
+        scannet={"scene0002_00": {}, "scene0001_00": {}},
+        arkitscenes={"41000000": {}},
+    )
+    monkeypatch.setattr(gt, "META_INFO_DIR", tmp_path / "thinking-in-space" / "data" / "meta_info")
+    assert gt.scenes() == ["41000000", "scene0001_00", "scene0002_00"]
+
+
+def test_build_all_writes_every_scene_and_format(tmp_path, monkeypatch):
+    monkeypatch.setattr(config, "CODES_ROOT", tmp_path / "codes")
+    monkeypatch.setattr(gt, "scenes", lambda: ["scene1", "scene2"])
+    monkeypatch.setattr(gt, "build_ground_truth_spatial_code", lambda scene, fmt: {"objects": {}})
+    written = gt.build_all()
+    assert len(written) == 4
+    assert (tmp_path / "codes" / "ground truth" / "explicit" / "scene1.json").exists()
+    assert (tmp_path / "codes" / "ground truth" / "compact" / "scene2.json").exists()
+
+
+def test_build_all_respects_explicit_scene_list_and_formats(tmp_path, monkeypatch):
+    monkeypatch.setattr(config, "CODES_ROOT", tmp_path / "codes")
+    monkeypatch.setattr(gt, "build_ground_truth_spatial_code", lambda scene, fmt: {"objects": {}})
+    written = gt.build_all(spatial_code_formats=("compact",), scene_list=["scene9"])
+    assert written == [str(tmp_path / "codes" / "ground truth" / "compact" / "scene9.json")]

tests/test_encoder/test_render.py

@@ -1,3 +1,5 @@
+"""Tests for encoder/render.py -- spatial-code rendering entry point."""
+
 from encoder import render
 
 def test_render_exposes_tracking_and_format_dimensions():

tests/test_encoder/test_run.py

@@ -1,3 +1,5 @@
+"""Tests for encoder/run.py -- combined cache loading and source provenance."""
+
 from encoder import run
 
 def test_cache_or_load_exposes_explicit_dimensions():

tests/test_inference/test_adapters.py

@@ -1,3 +1,5 @@
+"""Tests for inference/adapters.py -- inference backend registry and adapter dispatch."""
+
 import numpy as np
 import pytest
 

tests/test_inference/test_launch.py

@@ -1,3 +1,5 @@
+"""Tests for inference/launch.py -- multi-GPU/CPU batch driver."""
+
 from inference import launch
 
 def test_launcher_imports():