Update workspace code without replacing data (part 2)

setup.sh

@@ -3,15 +3,32 @@ set -Eeuo pipefail
 
 trap 'echo "ERROR: setup failed at line $LINENO: $BASH_COMMAND" >&2' ERR
 
+if [ "$#" -ne 1 ] || [ -z "$1" ]; then
+  echo "Usage: bash setup.sh <HF_TOKEN>" >&2
+  exit 2
+fi
+HF_TOKEN="$1"
+export HF_TOKEN
+shift
+
 echo "=== RunPod local-disk setup ==="
 
+WORKSPACE_ROOT="$(cd -- "$(dirname -- "${BASH_SOURCE[0]}")" && pwd)"
 DATA_ROOT="/root/data"
 MODELS_ROOT="/root/models"
 HF_CACHE="/root/hf-cache"
 HF_TMP="/root/hf-tmp"
-SEGVGGT_DIR="$MODELS_ROOT/SegVGGT"
-REQUIREMENTS="$SEGVGGT_DIR/requirements.txt"
+DA3_DIR="$MODELS_ROOT/depth-anything-3"
+SAM3_DIR="$MODELS_ROOT/sam3"
+# SEGVGGT_DIR="$MODELS_ROOT/SegVGGT"
+# REQUIREMENTS="$SEGVGGT_DIR/requirements.txt"
 VENV="/root/.venv"
+WORKSPACE_PACKAGES=(
+  numpy
+  opencv-contrib-python-headless
+  Pillow
+  scipy
+)
 
 mkdir -p "$DATA_ROOT" "$MODELS_ROOT" "$HF_CACHE" "$HF_TMP"
 
@@ -21,6 +38,7 @@ apt-get install -y \
   git \
   git-lfs \
   ffmpeg \
+  unzip \
   rsync \
   python3-pip \
   python3-venv
@@ -42,41 +60,86 @@ else
   git -C "$DATA_ROOT/thinking-in-space" pull --ff-only
 fi
 
-if [ ! -d "$DATA_ROOT/VSI-Bench" ] || \
-   [ -z "$(ls -A "$DATA_ROOT/VSI-Bench" 2>/dev/null)" ]; then
-  echo "Downloading VSI-Bench..."
-  mkdir -p "$DATA_ROOT/VSI-Bench"
-
-  HF_HOME="$HF_CACHE" \
-  TMPDIR="$HF_TMP" \
-  HF_HUB_DISABLE_XET=1 \
-  hf download nyu-visionx/VSI-Bench \
-    --repo-type dataset \
-    --local-dir "$DATA_ROOT/VSI-Bench"
+echo "Downloading or updating VSI-Bench..."
+mkdir -p "$DATA_ROOT/VSI-Bench"
+
+HF_HOME="$HF_CACHE" \
+TMPDIR="$HF_TMP" \
+HF_HUB_DISABLE_XET=1 \
+hf download nyu-visionx/VSI-Bench \
+  --repo-type dataset \
+  --local-dir "$DATA_ROOT/VSI-Bench"
+
+echo "Extracting VSI-Bench video archives..."
+for dataset in arkitscenes scannet scannetpp; do
+  archive="$DATA_ROOT/VSI-Bench/$dataset.zip"
+  if [ ! -f "$archive" ]; then
+    echo "ERROR: expected VSI-Bench archive not found: $archive" >&2
+    exit 1
+  fi
+  unzip -q -n "$archive" -d "$DATA_ROOT/VSI-Bench"
+done
+
+if [ ! -d "$DA3_DIR/.git" ]; then
+  echo "Cloning Depth Anything 3..."
+  git clone --recurse-submodules \
+    https://github.com/bytedance-seed/depth-anything-3.git \
+    "$DA3_DIR"
 else
-  echo "VSI-Bench already exists; skipping download."
+  echo "Updating existing Depth Anything 3 checkout..."
+  git -C "$DA3_DIR" pull --ff-only
+  git -C "$DA3_DIR" submodule update --init --recursive
 fi
 
-if [ ! -d "$SEGVGGT_DIR/.git" ]; then
-  echo "Cloning SegVGGT..."
+if [ ! -d "$SAM3_DIR/.git" ]; then
+  echo "Cloning SAM3..."
   git clone \
-    https://github.com/IDEA-Research/SegVGGT.git \
-    "$SEGVGGT_DIR"
+    https://github.com/facebookresearch/sam3.git \
+    "$SAM3_DIR"
 else
-  echo "Updating existing SegVGGT checkout..."
-  git -C "$SEGVGGT_DIR" fetch origin
-  git -C "$SEGVGGT_DIR" pull --ff-only
-fi
-
-if [ ! -f "$REQUIREMENTS" ]; then
-  echo "ERROR: requirements.txt not found at:"
-  echo "$REQUIREMENTS"
-  exit 1
+  echo "Updating existing SAM3 checkout..."
+  git -C "$SAM3_DIR" pull --ff-only
 fi
 
-echo "----- requirements.txt -----"
-cat "$REQUIREMENTS"
-echo "----------------------------"
+echo "Downloading Depth Anything 3 checkpoint into the DA3 checkout..."
+mkdir -p "$DA3_DIR/checkpoints/DA3-LARGE-1.1"
+HF_HOME="$HF_CACHE" \
+TMPDIR="$HF_TMP" \
+HF_HUB_DISABLE_XET=1 \
+hf download depth-anything/DA3-LARGE-1.1 \
+  --repo-type model \
+  --local-dir "$DA3_DIR/checkpoints/DA3-LARGE-1.1"
+
+echo "Downloading SAM3 checkpoint into the SAM3 checkout..."
+mkdir -p "$SAM3_DIR/checkpoints"
+HF_HOME="$HF_CACHE" \
+TMPDIR="$HF_TMP" \
+HF_HUB_DISABLE_XET=1 \
+hf download facebook/sam3 \
+  sam3.pt config.json \
+  --repo-type model \
+  --local-dir "$SAM3_DIR/checkpoints"
+
+# if [ ! -d "$SEGVGGT_DIR/.git" ]; then
+#   echo "Cloning SegVGGT..."
+#   git clone \
+#     https://github.com/IDEA-Research/SegVGGT.git \
+#     "$SEGVGGT_DIR"
+# else
+#   echo "Updating existing SegVGGT checkout..."
+#   git -C "$SEGVGGT_DIR" fetch origin
+#   git -C "$SEGVGGT_DIR" pull --ff-only
+# fi
+
+# if [ ! -f "$REQUIREMENTS" ]; then
+#   echo "ERROR: requirements.txt not found at:"
+#   echo "$REQUIREMENTS"
+#   exit 1
+# fi
+
+# echo "----- SegVGGT requirements.txt -----"
+# cat "$REQUIREMENTS"
+# echo "------------------------------------"
 
 echo "Recreating Python environment..."
 rm -rf "$VENV"
@@ -87,62 +150,82 @@ rm -rf "$VENV"
   --upgrade \
   pip setuptools wheel
 
-echo "Installing SegVGGT PyTorch versions..."
-"$VENV/bin/python" -m pip install \
-  --no-cache-dir \
-  torch==2.3.1 torchvision==0.18.1 \
-  --index-url https://download.pytorch.org/whl/cu121
+# echo "Installing SegVGGT PyTorch versions..."
+# "$VENV/bin/python" -m pip install \
+#   --no-cache-dir \
+#   torch==2.3.1 torchvision==0.18.1 \
+#   --index-url https://download.pytorch.org/whl/cu121
+
+# echo "Installing SegVGGT requirements..."
+# "$VENV/bin/python" -m pip install \
+#   --no-cache-dir \
+#   -r "$REQUIREMENTS"
 
-echo "Installing SegVGGT requirements..."
+echo "Installing workspace and its declared dependencies..."
 "$VENV/bin/python" -m pip install \
   --no-cache-dir \
-  -r "$REQUIREMENTS"
+  "${WORKSPACE_PACKAGES[@]}"
 
-echo "Verifying packages and CUDA..."
+# echo "Verifying packages and CUDA..."
+echo "Verifying workspace packages..."
 "$VENV/bin/python" -m pip check
-"$VENV/bin/python" - <<'VERIFY'
-import torch
-import torchvision
+PYTHONPATH="$WORKSPACE_ROOT" "$VENV/bin/python" - <<'VERIFY'
+# import torch
+# import torchvision
 import cv2
-import hydra
-import omegaconf
-
-assert torch.__version__.startswith("2.3.1"), torch.__version__
-assert torchvision.__version__.startswith("0.18.1"), torchvision.__version__
-assert torch.cuda.is_available(), "CUDA is unavailable"
-
-print("Torch:", torch.__version__)
-print("Torchvision:", torchvision.__version__)
-print("CUDA:", torch.version.cuda)
-print("GPU:", torch.cuda.get_device_name(0))
+# import hydra
+# import omegaconf
+import scipy
+
+import encoder.adapters
+import encoder.config
+import encoder.geometric
+import encoder.render
+import encoder.run
+import inference.adapters
+import inference.launch
+import inference.run
+
+# assert torch.__version__.startswith("2.3.1"), torch.__version__
+# assert torchvision.__version__.startswith("0.18.1"), torchvision.__version__
+# assert torch.cuda.is_available(), "CUDA is unavailable"
+#
+# print("Torch:", torch.__version__)
+# print("Torchvision:", torchvision.__version__)
+# print("CUDA:", torch.version.cuda)
+# print("GPU:", torch.cuda.get_device_name(0))
 print("OpenCV:", cv2.__version__)
 print("Verification passed.")
 VERIFY
 
-CHECKPOINT="$SEGVGGT_DIR/checkpoint/segvggt_scannet200.pt"
-
-if [ ! -f "$CHECKPOINT" ]; then
-  echo "Downloading SegVGGT ScanNet200 checkpoint..."
-
-  HF_HOME="$HF_CACHE" \
-  TMPDIR="$HF_TMP" \
-  HF_HUB_DISABLE_XET=1 \
-  hf download JinyuanQu/SegVGGT \
-    checkpoint/segvggt_scannet200.pt \
-    --repo-type model \
-    --local-dir "$SEGVGGT_DIR"
-else
-  echo "SegVGGT checkpoint already exists; skipping download."
-fi
+# CHECKPOINT="$SEGVGGT_DIR/checkpoint/segvggt_scannet200.pt"
+#
+# if [ ! -f "$CHECKPOINT" ]; then
+#   echo "Downloading SegVGGT ScanNet200 checkpoint..."
+#
+#   HF_HOME="$HF_CACHE" \
+#   TMPDIR="$HF_TMP" \
+#   HF_HUB_DISABLE_XET=1 \
+#   hf download JinyuanQu/SegVGGT \
+#     checkpoint/segvggt_scannet200.pt \
+#     --repo-type model \
+#     --local-dir "$SEGVGGT_DIR"
+# else
+#   echo "SegVGGT checkpoint already exists; skipping download."
+# fi
 
 
 echo
 echo "=== Setup complete ==="
 echo "thinking-in-space: $DATA_ROOT/thinking-in-space"
 echo "VSI-Bench:         $DATA_ROOT/VSI-Bench"
-echo "SegVGGT:           $SEGVGGT_DIR"
-echo "Requirements:      $REQUIREMENTS"
-echo "Checkpoint:        $CHECKPOINT"
+echo "Depth Anything 3:  $DA3_DIR"
+echo "DA3 checkpoint:     $DA3_DIR/checkpoints/DA3-LARGE-1.1"
+echo "SAM3:              $SAM3_DIR"
+echo "SAM3 checkpoint:   $SAM3_DIR/checkpoints/sam3.pt"
+# echo "SegVGGT:           $SEGVGGT_DIR"
+# echo "Requirements:      $REQUIREMENTS"
+# echo "Checkpoint:        $CHECKPOINT"
 echo "Virtual env:       $VENV"
 echo
 

symbolic/launch.py

@@ -1,5 +1,5 @@
 """Runs the symbolic engine (via symbolic/run.py's score_scene()) across EVERY scene that has
-a real spatial code on disk under /workspace/data/spatial codes/ -- the multi-scene
+a real spatial code on disk under /workspace/data/spatial codes/segvggt/ -- the multi-scene
 orchestrator, matching encoder/launch.py's and harness/launch.py's own single-scene-worker vs.
 multi-scene-orchestrator split (symbolic/run.py stays single-scene only; this file is the only
 one that loops over more than one scene). This file contains no scoring logic of its own --
@@ -8,7 +8,7 @@ unmodified vsi_official_eval.py) is symbolic/run.py's score_scene(), called once
 
 Usage:
     python symbolic/launch.py
-        Every scene under /workspace/data/spatial codes/*.json that also has at least one real
+        Every scene under /workspace/data/spatial codes/segvggt/*.json that also has at least one real
         question in test.jsonl -- runs each one (delegating to symbolic/run.py's score_scene()
         for the actual work), prints a per-scene report (including the appearance-order
         diagnostic run.py builds), then one combined aggregate across every scene together.

symbolic/run.py

@@ -6,9 +6,8 @@ orchestrator (matches encoder/launch.py's and harness/launch.py's own single-sce
 multi-scene-orchestrator split: this file never loops over more than one scene on its own).
 
 FETCHES the spatial code from:
-    /workspace/data/spatial codes/<SCENE_ID>.json
-(the flat on-disk layout -- same convention harness/run.py's own load_code() falls back to;
-see that function's "flat layout (spatial_codes_old_float32)" comment). This file does NOT
+    /workspace/data/spatial codes/segvggt/<SCENE_ID>.json
+(the model-specific on-disk layout). This file does NOT
 build spatial codes (that's encoder/render.py's job) and does NOT call any model -- it only
 reads an already-built spatial_code.json and answers/scores against it.
 
@@ -55,24 +54,24 @@ sys.modules["vsi_official_eval"] = _official_vsi_eval
 
 def _find_workspace_root(start):
     """Walks upward from `start` looking for a real 'data' folder containing a 'spatial
-    codes' subfolder -- the actual data root (called /workspace inside this project's
+    codes/segvggt' subfolder -- the actual data root (called /workspace inside this project's
     original Linux-container environment, but this walk works under ANY real folder name --
     'workspace', a OneDrive-synced path, whatever the real machine actually calls it).
 
     This is DELIBERATELY separate from _find_project_root() above: that one finds the CODE
     repository root (needs harness/ + symbolic/ as siblings); this one finds the DATA root
-    (needs data/spatial codes as a descendant). On a real deployment they're often the same
+    (needs data/spatial codes/segvggt as a descendant). On a real deployment they're often the same
     directory (this file's own parent, e.g. your real C:\\...\\workspace), but they don't have
     to be -- someone could keep code and data in genuinely separate trees, so this walk
     doesn't assume the code repo root IS the workspace root, it looks for the real,
-    independent evidence (an actual data/spatial codes folder) instead.
+    independent evidence (an actual data/spatial codes/segvggt folder) instead.
 
     Returns None (never raises) if no such folder is found within a few levels up -- callers
     fall back to the hardcoded /workspace/... default in that case, so a machine that
     genuinely does have /workspace (the original Linux-container case) is unaffected."""
     d = os.path.abspath(start)
     for _ in range(6):
-        candidate = os.path.join(d, "data", "spatial codes")
+        candidate = os.path.join(d, "data", "spatial codes", "segvggt")
         if os.path.isdir(candidate):
             return d
         parent = os.path.dirname(d)
@@ -86,7 +85,7 @@ _AUTO_WORKSPACE = _find_workspace_root(_HERE)
 
 
 def _default_spatial_codes_dir():
-    return "/workspace/data/spatial codes"
+    return "/workspace/data/spatial codes/segvggt"
 
 
 def _default_test_jsonl():
@@ -102,12 +101,12 @@ def _default_results_dir():
 # ==========================================================================================
 # FETCH -- where a scene's spatial code lives on disk, and how to load+render it.
 #
-# Auto-detected from a real 'data/spatial codes' folder found by walking upward from this
+# Auto-detected from a real 'data/spatial codes/segvggt' folder found by walking upward from this
 # file (see _find_workspace_root() above) -- works out of the box on any machine/OS, no setup
-# needed, as long as the real folder structure matches (data/spatial codes/, data/VSI-Bench/
+# needed, as long as the real folder structure matches (data/spatial codes/segvggt/, data/VSI-Bench/
 # or data/vsi benchmark/). Override via environment variables if your layout genuinely
 # differs (PowerShell example):
-#     $env:SYMBOLIC_SPATIAL_CODES_DIR = "D:\some\other\place\spatial codes"
+#     $env:SYMBOLIC_SPATIAL_CODES_DIR = "D:\some\other\place\spatial codes\segvggt"
 #     $env:SYMBOLIC_TEST_JSONL = "D:\some\other\place\test.jsonl"
 #     $env:SYMBOLIC_RESULTS_DIR = "D:\some\other\place\results"
 # ==========================================================================================
@@ -120,7 +119,7 @@ DEFAULT_TEST_JSONL = os.environ.get("SYMBOLIC_TEST_JSONL", _default_test_jsonl()
 
 def spatial_code_path(scene_id):
     """The one place this file looks for a scene's spatial code:
-    /workspace/data/spatial codes/<SCENE_ID>.json (flat layout)."""
+    /workspace/data/spatial codes/segvggt/<SCENE_ID>.json."""
     return os.path.join(SPATIAL_CODES_DIR, f"{scene_id}.json")
 
 

tests/encoder_tests/conftest.py

@@ -4,6 +4,5 @@ from pathlib import Path
 import sys
 
 ROOT = Path(__file__).resolve().parents[2]
-ENCODER_ROOT = ROOT / "encoder"
-if str(ENCODER_ROOT) not in sys.path:
-    sys.path.insert(0, str(ENCODER_ROOT))
+if str(ROOT) not in sys.path:
+    sys.path.insert(0, str(ROOT))

tests/encoder_tests/test_adapters.py

@@ -1,10 +1,49 @@
 import gzip
 import pickle
+import sys
+import types
 
 import numpy as np
 import pytest
 
-import adapters
+from encoder import adapters
+
+
+def test_registry_decodes_native_segvggt_dictionary(tmp_path, monkeypatch):
+    torch = pytest.importorskip("torch")
+    evaluation = types.ModuleType("eval.instance_eval_common")
+    evaluation.predict_by_feat_instance = lambda *args, **kwargs: (
+        torch.tensor([[1, 0, 0, 0], [0, 1, 0, 0]], dtype=torch.bool),
+        torch.tensor([0, 2]),
+        torch.ones(2),
+    )
+    pose = types.ModuleType("segvggt.utils.pose_enc")
+    pose.pose_encoding_to_extri_intri = lambda value, size: (
+        torch.cat(
+            [
+                torch.eye(3).reshape(1, 1, 3, 3),
+                torch.zeros(1, 1, 3, 1),
+            ],
+            dim=-1,
+        ),
+        torch.eye(3).reshape(1, 1, 3, 3),
+    )
+    monkeypatch.setitem(sys.modules, "eval.instance_eval_common", evaluation)
+    monkeypatch.setitem(sys.modules, "segvggt.utils.pose_enc", pose)
+
+    path = tmp_path / "scene.pt"
+    torch.save(
+        {
+            "world_points": torch.zeros(1, 1, 2, 2, 3),
+            "instance_maps": torch.zeros(1, 2, 1, 2, 2),
+            "instance_labels": torch.zeros(1, 2, 4),
+            "pose_enc": torch.zeros(1, 1, 9),
+        },
+        path,
+    )
+    result = adapters.adapt("segvggt", path=path)
+    assert list(result["instances"]) == ["chair"]
+    assert result["instances"]["chair"][0]["n"] == 1
 
 
 def _scene():
@@ -65,6 +104,49 @@ def test_adapt_segvggt_requires_existing_cache(tmp_path):
         adapters.adapt_segvggt(path=str(tmp_path / "missing.npz"))
 
 
+def test_adapter_owned_raw_cache_locations(tmp_path, monkeypatch):
+    seen = {}
+    raw_path = tmp_path / "segvggt" / "scene1.pt"
+    raw_path.parent.mkdir()
+    raw_path.touch()
+
+    def fake_segvggt(path):
+        seen["segvggt"] = str(path)
+        return {
+            "world_points": np.zeros((1, 1, 1, 3), np.float32),
+            "instance_masks": np.ones((1, 1, 1, 1), bool),
+            "labels": np.array(["chair"], dtype=object),
+            "camera_positions": np.zeros((1, 3), np.float32),
+        }
+
+    monkeypatch.setattr(adapters, "_decode_segvggt_raw", fake_segvggt)
+    adapters.adapt_segvggt(root=str(tmp_path), scene="scene1")
+    assert seen["segvggt"] == str(raw_path)
+
+
+def test_fusion_adapter_resolves_two_native_model_directories(tmp_path, monkeypatch):
+    seen = {}
+    depth = np.ones((1, 1, 1), np.float32)
+    intr = np.eye(3, dtype=np.float32)[None]
+    c2w = np.eye(4, dtype=np.float32)[None]
+
+    def fake_da3(path):
+        seen["da3"] = str(path)
+        return depth, intr, c2w, None
+
+    def fake_sam3(path):
+        seen["sam3"] = str(path)
+        return {"object": {0: {0: np.ones((1, 1), bool)}}}
+
+    monkeypatch.setattr(adapters, "_load_native_da3", fake_da3)
+    monkeypatch.setattr(adapters, "_load_native_sam3", fake_sam3)
+    adapters.adapt_da3_sam3(root=str(tmp_path), scene="scene1")
+    assert seen == {
+        "da3": str(tmp_path / "depth-anything-3" / "scene1.pkl"),
+        "sam3": str(tmp_path / "sam3" / "scene1.pt"),
+    }
+
+
 def test_adapt_segvggt_rejects_missing_npz_fields(tmp_path):
     path = tmp_path / "broken.npz"
     np.savez(path, labels=np.array(["chair"], dtype=object))

tests/encoder_tests/test_config.py

@@ -1,6 +1,6 @@
 import pytest
 
-import config as C
+from encoder import config as C
 
 
 def test_cache_and_code_paths_are_flat(tmp_path, monkeypatch):
@@ -10,12 +10,12 @@ def test_cache_and_code_paths_are_flat(tmp_path, monkeypatch):
     assert C.cache_file("scene1", "segvggt") == str(
         tmp_path / "caches/segvggt/scene1.pkl.gz"
     )
-    assert C.segvggt_cache_file("scene1") == str(tmp_path / "caches/segvggt/scene1.npz")
+    assert C.segvggt_cache_file("scene1") == str(tmp_path / "caches/segvggt/scene1.pt")
     assert C.da3_cache_file("scene1") == str(
-        tmp_path / "caches/da3_sam3/scene1.da3.npz"
+        tmp_path / "caches/depth-anything-3/scene1.pkl"
     )
     assert C.sam3_cache_file("scene1") == str(
-        tmp_path / "caches/da3_sam3/scene1.sam3.pkl.gz"
+        tmp_path / "caches/sam3/scene1.pt"
     )
     assert C.spatial_code_path("scene1") == str(tmp_path / "spatial codes/scene1.json")
 

tests/encoder_tests/test_geometric.py

@@ -48,3 +48,35 @@ def test_exact_math_is_integrated_into_geometric_module():
     assert callable(geometric.build_spatial_code_raw)
     assert callable(geometric.dump_spatial_code)
     assert not hasattr(geometric, "_reference")
+
+
+def test_position_reader_accepts_current_and_legacy_formatting():
+    assert geometric.pos3(
+        {
+            "position": {
+                "x coordinate": "1.25 meters",
+                "y coordinate": "-2.0 meters",
+                "height above floor": "0.5 meters",
+            }
+        }
+    ) == [1.25, -2.0, 0.5]
+    assert geometric.pos3(
+        {
+            "position": {
+                "floor_x_meters": 1.25,
+                "floor_y_meters": -2.0,
+                "height_above_floor_meters": 0.5,
+            }
+        }
+    ) == [1.25, -2.0, 0.5]
+
+
+def test_floor_level_v1_v2_math_is_shared(monkeypatch):
+    points = np.array([[0, 0, z] for z in [0, 0, 0, 1, 10]], np.float32)
+    gravity = np.array([0, 0, 1], np.float32)
+    monkeypatch.delenv("VSI_CODE_V2", raising=False)
+    v1 = geometric._floor_level(points, gravity)
+    monkeypatch.setenv("VSI_CODE_V2", "1")
+    v2 = geometric._floor_level(points, gravity)
+    assert 0 <= v1 < 0.2
+    assert v2 == 0.0

tests/encoder_tests/test_launch.py

@@ -3,8 +3,8 @@ import sys
 
 import pytest
 
-import config as C
-import launch
+from encoder import config as C
+from encoder import launch
 
 
 def test_scenes_deduplicates_manifest_in_order(tmp_path, monkeypatch):

tests/encoder_tests/test_render.py

@@ -1,7 +1,7 @@
 import json
 
-import config as C
-import render
+from encoder import config as C
+from encoder import render
 
 
 def test_build_spatial_code_uses_cached_geometry(monkeypatch):

tests/encoder_tests/test_run.py

@@ -1,9 +1,9 @@
 import gzip
 import pickle
 
-import adapters
-import config as C
-import run
+from encoder import adapters
+from encoder import config as C
+from encoder import run
 
 
 def _geometry():
@@ -30,11 +30,7 @@ def test_cache_or_load_reads_flat_cache(tmp_path, monkeypatch):
 
 def test_cache_or_load_builds_and_writes_cache(tmp_path, monkeypatch):
     monkeypatch.setattr(C, "CACHE_ROOT", tmp_path / "caches")
-    monkeypatch.setattr(C, "ADAPTERS", {"fake": "adapt_fake"})
-    monkeypatch.setattr(run, "_adapter_kwargs", lambda scene, model: {"scene": scene})
-    monkeypatch.setattr(
-        adapters, "adapt_fake", lambda **kwargs: _geometry(), raising=False
-    )
+    monkeypatch.setitem(adapters.RAW_ADAPTERS, "fake", lambda **kwargs: _geometry())
 
     result, how = run.cache_or_load("s1", "fake")
 

tests/inference_tests/test_adapter_runtime.py

@@ -1,3 +1,7 @@
+import pickle
+import sys
+from types import SimpleNamespace
+
 import numpy as np
 import pytest
 
@@ -20,7 +24,7 @@ def test_load_model_validates_repository_and_checkpoint(tmp_path):
 def test_run_scene_requires_loaded_model(tmp_path):
     adapter = adapters.SegVGGTAdapter()
     with pytest.raises(RuntimeError, match=r"load_model\(\)"):
-        adapter.run_scene("video.mp4", tmp_path / "scene.npz", 1)
+        adapter.run_scene("video.mp4", tmp_path / "scene.pt", 1)
 
 
 def test_read_video_rejects_unopenable_file():
@@ -28,7 +32,7 @@ def test_read_video_rejects_unopenable_file():
         adapters.SegVGGTAdapter._read_video("/missing/video.mp4", 1)
 
 
-def test_run_scene_writes_expected_npz_atomically(tmp_path, monkeypatch):
+def test_run_scene_preserves_raw_dtypes_and_encoder_geometry(tmp_path, monkeypatch):
     torch = pytest.importorskip("torch")
     adapter = adapters.SegVGGTAdapter()
     adapter.device = torch.device("cpu")
@@ -43,42 +47,116 @@ def test_run_scene_writes_expected_npz_atomically(tmp_path, monkeypatch):
     class Model:
         def __call__(self, images):
             return {
-                "instance_maps": torch.zeros((1, 2, 1, 2, 2)),
+                "instance_maps": torch.zeros(
+                    (1, 2, 1, 2, 2), dtype=torch.bfloat16
+                ),
                 "instance_labels": torch.zeros((1, 2, 3)),
                 "depth": torch.ones((1, 1, 2, 2)),
                 "pose_enc": torch.zeros((1, 1, 4)),
             }
 
-    def predict(labels, logits, **kwargs):
-        masks = torch.tensor([[1, 0, 0, 0], [0, 1, 0, 0]], dtype=torch.bool)
-        return masks, torch.tensor([0, 2]), None
-
-    def decode_pose(pose, shape):
-        return torch.eye(4).reshape(1, 1, 4, 4), torch.eye(3).reshape(1, 1, 3, 3)
+    adapter.model = Model()
+    adapter.runtime = torch
+    output = tmp_path / "nested" / "scene.pt"
+    adapter.run_scene("video.mp4", output, 1)
 
-    def unproject(depth, extrinsics, intrinsics):
-        return np.zeros((1, 2, 2, 3), np.float32)
+    assert output.is_file()
+    assert not output.with_suffix(".pt.tmp").exists()
+    cache = torch.load(output, map_location="cpu", weights_only=False)
+    assert set(cache) == {
+        "instance_maps",
+        "instance_labels",
+        "depth",
+        "pose_enc",
+    }
+    assert cache["instance_maps"].dtype == torch.bfloat16
+    assert cache["depth"].dtype == torch.float32
+    assert all(value.device.type == "cpu" for value in cache.values())
+
+
+def test_da3_preserves_native_prediction_object(tmp_path, monkeypatch):
+    adapter = adapters.DepthAnything3Adapter()
+    prediction = SimpleNamespace(
+        depth=np.ones((2, 3, 4), dtype=np.float32),
+        conf=np.ones((2, 3, 4), dtype=np.float16),
+        is_metric=True,
+    )
 
-    def inverse(extrinsics):
-        return np.eye(4, dtype=np.float32)[None]
+    class Model:
+        def inference(self, images, export_dir):
+            assert images == ["frame"]
+            assert export_dir is None
+            return prediction
 
     adapter.model = Model()
-    adapter.runtime = (
-        torch,
-        torch.nn.functional,
-        predict,
-        unproject,
-        inverse,
-        decode_pose,
-    )
-    output = tmp_path / "nested" / "scene.npz"
+    monkeypatch.setattr(adapter, "_read_video", lambda path, count: ["frame"])
+    output = tmp_path / "depth-anything-3" / "scene.pkl"
     adapter.run_scene("video.mp4", output, 1)
 
-    assert output.is_file()
-    assert not output.with_suffix(".npz.tmp.npz").exists()
-    with np.load(output, allow_pickle=True) as cache:
-        assert cache["world_points"].shape == (1, 2, 2, 3)
-        assert cache["instance_masks"].shape == (1, 1, 2, 2)
-        assert cache["labels"].tolist() == ["chair"]
-        assert cache["frame_times"].tolist() == pytest.approx([0.25])
-        assert cache["camera_positions"].shape == (1, 3)
+    with output.open("rb") as stream:
+        restored = pickle.load(stream)
+    assert vars(restored).keys() == vars(prediction).keys()
+    assert restored.depth.dtype == np.float32
+    assert restored.conf.dtype == np.float16
+    assert restored.is_metric is True
+    assert not output.with_suffix(".pkl.tmp").exists()
+
+
+def test_sam3_preserves_independent_image_responses_without_tracking(
+    tmp_path, monkeypatch
+):
+    states = []
+    monkeypatch.setitem(
+        sys.modules,
+        "PIL",
+        SimpleNamespace(Image=SimpleNamespace(fromarray=lambda frame: frame)),
+    )
+
+    class Processor:
+        def set_image(self, image):
+            state = {"frame": len(states), "shape": image.shape}
+            states.append(state)
+            return state
+
+        def set_text_prompt(self, state, prompt):
+            assert prompt == "chair"
+            return {"state": state, "masks": np.ones((1, 2, 2), np.float32)}
+
+    class InferenceMode:
+        def __enter__(self):
+            return self
+
+        def __exit__(self, *args):
+            return False
+
+    class Runtime:
+        @staticmethod
+        def inference_mode():
+            return InferenceMode()
+
+        @staticmethod
+        def save(value, path):
+            with open(path, "wb") as stream:
+                pickle.dump(value, stream)
+
+    adapter = adapters.SAM3Adapter(prompt="chair")
+    adapter.model = object()
+    adapter.processor = Processor()
+    adapter.runtime = Runtime()
+    monkeypatch.setattr(
+        adapters.DepthAnything3Adapter,
+        "_read_video",
+        lambda path, count: [
+            np.zeros((2, 3, 3), np.uint8),
+            np.ones((2, 3, 3), np.uint8),
+        ],
+    )
+    output = tmp_path / "sam3" / "scene.pt"
+    adapter.run_scene("video.mp4", output, 2)
+
+    with output.open("rb") as stream:
+        restored = pickle.load(stream)
+    assert [response["state"]["frame"] for response in restored] == [0, 1]
+    assert all(response["masks"].dtype == np.float32 for response in restored)
+    assert len(states) == 2
+    assert not output.with_suffix(".pt.tmp").exists()

tests/inference_tests/test_gpu_integration.py

@@ -3,7 +3,6 @@
 import json
 import os
 
-import numpy as np
 import pytest
 
 from inference import adapters
@@ -14,24 +13,29 @@ from inference import run
     os.environ.get("VSI_RUN_GPU_TESTS") != "1",
     reason="set VSI_RUN_GPU_TESTS=1 to run real SegVGGT inference",
 )
-def test_real_segvggt_scene_writes_encoder_compatible_cache(tmp_path):
-    with open(run.encoder_config.JSONL) as manifest:
+def test_real_segvggt_scene_preserves_native_prediction_dictionary(tmp_path):
+    torch = pytest.importorskip("torch")
+    with open(run.inference_config.JSONL) as manifest:
         scene = str(json.loads(next(manifest))["scene_name"])
     adapter = adapters.get_adapter("segvggt")
     adapter.load_model("cuda:0")
-    output = tmp_path / f"{scene}.npz"
+    output = tmp_path / f"{scene}.pt"
     adapter.run_scene(
-        run.encoder_config.video_path(scene),
+        run.inference_config.video_path(scene),
         str(output),
-        run.encoder_config.FRAMES_PER_VIDEO,
+        run.inference_config.FRAMES_PER_VIDEO,
+    )
+    cache = torch.load(output, map_location="cpu", weights_only=False)
+    assert isinstance(cache, dict)
+    assert {
+        "pose_enc",
+        "depth",
+        "world_points",
+        "instance_maps",
+        "instance_labels",
+    }.issubset(cache)
+    assert all(
+        value.device.type == "cpu"
+        for value in cache.values()
+        if isinstance(value, torch.Tensor)
     )
-    with np.load(output, allow_pickle=True) as cache:
-        assert set(cache.files) == {
-            "world_points",
-            "instance_masks",
-            "labels",
-            "frame_times",
-            "camera_positions",
-        }
-        assert cache["world_points"].shape[-1] == 3
-        assert cache["instance_masks"].dtype == bool

tests/inference_tests/test_inference.py

@@ -8,6 +8,8 @@ from inference import run
 
 
 class FakeAdapter:
+    model = object()
+
     def __init__(self):
         self.calls = []
 
@@ -19,21 +21,40 @@ class FakeAdapter:
 
 
 def test_adapter_registry():
-    assert adapters.available_models() == ("segvggt",)
+    assert adapters.available_models() == (
+        "depth-anything-3",
+        "sam3",
+        "segvggt",
+    )
+    assert isinstance(
+        adapters.get_adapter("depth-anything-3"),
+        adapters.DepthAnything3Adapter,
+    )
+    assert isinstance(adapters.get_adapter("sam3"), adapters.SAM3Adapter)
     assert isinstance(adapters.get_adapter("segvggt"), adapters.SegVGGTAdapter)
     with pytest.raises(KeyError, match="unknown inference model"):
         adapters.get_adapter("unknown")
 
 
+def test_native_output_paths(tmp_path, monkeypatch):
+    monkeypatch.setattr(run.inference_config, "CACHE_ROOT", tmp_path)
+    assert run.output_path("scene1", "depth-anything-3") == str(
+        tmp_path / "depth-anything-3" / "scene1.pkl"
+    )
+    assert run.output_path("scene1", "sam3") == str(
+        tmp_path / "sam3" / "scene1.pt"
+    )
+
+
 def test_run_scene_builds_then_skips(tmp_path, monkeypatch):
-    monkeypatch.setattr(run.encoder_config, "CACHE_ROOT", tmp_path)
+    monkeypatch.setattr(run.inference_config, "CACHE_ROOT", tmp_path)
     monkeypatch.setattr(
-        run.encoder_config, "video_path", lambda scene: f"/videos/{scene}.mp4"
+        run.inference_config, "video_path", lambda scene: f"/videos/{scene}.mp4"
     )
     adapter = FakeAdapter()
     assert run.run_scene("scene1", adapter=adapter) == (
         "built",
-        str(tmp_path / "segvggt" / "scene1.npz"),
+        str(tmp_path / "segvggt" / "scene1.pt"),
     )
     assert run.run_scene("scene1", adapter=adapter)[0] == "skipped"
     assert len(adapter.calls) == 1
@@ -44,7 +65,7 @@ def test_scenes_deduplicates_manifest(tmp_path, monkeypatch):
     manifest.write_text(
         '{"scene_name": "s1"}\n{"scene_name": "s2"}\n{"scene_name": "s1"}\n'
     )
-    monkeypatch.setattr(launch.encoder_config, "JSONL", manifest)
+    monkeypatch.setattr(launch.inference_config, "JSONL", manifest)
     assert launch.scenes() == ["s1", "s2"]
 
 

tests/inference_tests/test_launch_runtime.py

@@ -84,9 +84,9 @@ def test_worker_reports_scene_failure_and_continues(monkeypatch):
 
 
 def test_run_scene_rebuild_overwrites_existing_cache(tmp_path, monkeypatch):
-    monkeypatch.setattr(run.encoder_config, "CACHE_ROOT", tmp_path)
-    monkeypatch.setattr(run.encoder_config, "video_path", lambda scene: f"/{scene}.mp4")
-    destination = tmp_path / "segvggt" / "s1.npz"
+    monkeypatch.setattr(run.inference_config, "CACHE_ROOT", tmp_path)
+    monkeypatch.setattr(run.inference_config, "video_path", lambda scene: f"/{scene}.mp4")
+    destination = tmp_path / "segvggt" / "s1.pt"
     destination.parent.mkdir()
     destination.write_bytes(b"old")
     calls = []

tests/symbolic_tests/test_run.py

@@ -7,7 +7,9 @@ import symbolic_run_tests as symbolic_run
 
 def test_find_workspace_root_uses_spatial_codes_folder(tmp_path):
     start = tmp_path / "project" / "symbolic"
-    (tmp_path / "project" / "data" / "spatial codes").mkdir(parents=True)
+    (tmp_path / "project" / "data" / "spatial codes" / "segvggt").mkdir(
+        parents=True
+    )
     start.mkdir()
     assert symbolic_run._find_workspace_root(start) == str(tmp_path / "project")