euler-eval 2.9.0__tar.gz → 2.11.0__tar.gz

{euler_eval-2.9.0 → euler_eval-2.11.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-eval
-Version: 2.9.0
+Version: 2.11.0
 Summary: Depth map evaluation toolkit with comprehensive metrics
 Author: Depth Eval Contributors
 License: MIT
@@ -239,7 +239,7 @@ Defines GT modalities, prediction datasets to evaluate, and optional euler_train
 }
 ```
 
-Each modality entry can optionally include a `split` field to select a specific split from the dataset (e.g. `{ "path": "/data/gt/depth", "split": "test" }`).
+Each modality entry can optionally include a `split` field to select a specific split from the dataset (e.g. `{ "path": "/data/gt/depth", "split": "test" }`). euler-loading inline selectors are also accepted in `path`, such as `/data/muses.zip:test` or `/data/muses.zip:test#scope=rgb`.
 
 For sparse pointcloud depth evaluation, use `gt.sparse_depth` instead of `gt.depth`. The prediction still uses `datasets[].depth` because the model output is a dense depth map. The evaluator projects the sparse GT point cloud into the prediction image plane using `gt.intrinsics` and `gt.camera_extrinsics`, then computes pointwise depth metrics only at projected valid pixels.
 
@@ -293,7 +293,7 @@ Dataset metadata (e.g. `radial_depth`, `rgb_range`, sparse point columns, and co
 
 ### Dataset Metadata
 
-Each dataset directory must contain ds-crawler metadata artifacts, typically generated under `.ds_crawler/`:
+Each dataset directory or archive must contain ds-crawler metadata artifacts, typically generated under `.ds_crawler/`:
 
 ```text
 dataset-root/
@@ -303,6 +303,8 @@ dataset-root/
     index.json
 ```
 
+When one physical root or archive contains several logical modalities, the artifacts may instead be scoped under `.ds_crawler/<modality>/` with a `.ds_crawler/scopes.json` manifest. `euler-eval` passes modality scopes to euler-loading so paths such as `/data/muses.zip:test` can load `.ds_crawler/rgb/index.json`, `.ds_crawler/depth/index.json`, and related scoped artifacts from the same archive.
+
 GT and prediction datasets are matched by hierarchy path and file ID through `MultiModalDataset`.
 
 ### `metrics_config.json`

{euler_eval-2.9.0 → euler_eval-2.11.0}/README.md

@@ -201,7 +201,7 @@ Defines GT modalities, prediction datasets to evaluate, and optional euler_train
 }
 ```
 
-Each modality entry can optionally include a `split` field to select a specific split from the dataset (e.g. `{ "path": "/data/gt/depth", "split": "test" }`).
+Each modality entry can optionally include a `split` field to select a specific split from the dataset (e.g. `{ "path": "/data/gt/depth", "split": "test" }`). euler-loading inline selectors are also accepted in `path`, such as `/data/muses.zip:test` or `/data/muses.zip:test#scope=rgb`.
 
 For sparse pointcloud depth evaluation, use `gt.sparse_depth` instead of `gt.depth`. The prediction still uses `datasets[].depth` because the model output is a dense depth map. The evaluator projects the sparse GT point cloud into the prediction image plane using `gt.intrinsics` and `gt.camera_extrinsics`, then computes pointwise depth metrics only at projected valid pixels.
 
@@ -255,7 +255,7 @@ Dataset metadata (e.g. `radial_depth`, `rgb_range`, sparse point columns, and co
 
 ### Dataset Metadata
 
-Each dataset directory must contain ds-crawler metadata artifacts, typically generated under `.ds_crawler/`:
+Each dataset directory or archive must contain ds-crawler metadata artifacts, typically generated under `.ds_crawler/`:
 
 ```text
 dataset-root/
@@ -265,6 +265,8 @@ dataset-root/
     index.json
 ```
 
+When one physical root or archive contains several logical modalities, the artifacts may instead be scoped under `.ds_crawler/<modality>/` with a `.ds_crawler/scopes.json` manifest. `euler-eval` passes modality scopes to euler-loading so paths such as `/data/muses.zip:test` can load `.ds_crawler/rgb/index.json`, `.ds_crawler/depth/index.json`, and related scoped artifacts from the same archive.
+
 GT and prediction datasets are matched by hierarchy path and file ID through `MultiModalDataset`.
 
 ### `metrics_config.json`

{euler_eval-2.9.0 → euler_eval-2.11.0}/euler_eval/cli.py

@@ -14,6 +14,7 @@ from pathlib import Path
 
 import torch
 
+from .config_paths import normalize_modality_path
 from .data import (
     build_depth_eval_dataset,
     build_rays_eval_dataset,
@@ -599,7 +600,10 @@ def validate_gt_config(gt: dict) -> None:
         "camera_extrinsics",
     ):
         if modality in gt and "path" in gt[modality]:
-            p = Path(gt[modality]["path"])
+            p = normalize_modality_path(
+                gt[modality]["path"],
+                split=gt[modality].get("split"),
+            )
             if not p.exists():
                 raise ValueError(f"gt.{modality}.path does not exist: {p}")
 
@@ -624,7 +628,10 @@ def validate_dataset_entry(entry: dict, index: int) -> None:
 
     for modality in ("rgb", "depth", "rays"):
         if modality in entry and "path" in entry[modality]:
-            p = Path(entry[modality]["path"])
+            p = normalize_modality_path(
+                entry[modality]["path"],
+                split=entry[modality].get("split"),
+            )
             if not p.exists():
                 raise ValueError(f"{label}.{modality}.path does not exist: {p}")
 
@@ -749,12 +756,24 @@ def save_results(
             and modality in dataset_config
             and "path" in dataset_config[modality]
         ):
-            output_file = Path(dataset_config[modality]["path"]) / "eval.json"
+            output_file = (
+                normalize_modality_path(
+                    dataset_config[modality]["path"],
+                    split=dataset_config[modality].get("split"),
+                )
+                / "eval.json"
+            )
         else:
             # Default: save alongside first available modality path
             for mod in ("depth", "rgb", "rays"):
                 if mod in dataset_config and "path" in dataset_config[mod]:
-                    output_file = Path(dataset_config[mod]["path"]) / "eval.json"
+                    output_file = (
+                        normalize_modality_path(
+                            dataset_config[mod]["path"],
+                            split=dataset_config[mod].get("split"),
+                        )
+                        / "eval.json"
+                    )
                     break
         if output_file is None:
             output_file = Path("eval.json")

euler_eval-2.11.0/euler_eval/config_paths.py

@@ -0,0 +1,125 @@
+"""Helpers for euler-loading modality path selectors in config files."""
+
+from __future__ import annotations
+
+from dataclasses import dataclass
+from pathlib import Path
+from urllib.parse import parse_qsl
+
+from ds_crawler import validate_metadata_scope
+from ds_crawler.zip_utils import validate_split_name
+from euler_loading import Modality
+
+
+@dataclass(frozen=True)
+class ModalityPath:
+    path: str
+    split: str | None = None
+    metadata_scope: str | None = None
+
+
+def _parse_inline_scope(path: str) -> tuple[str, str | None]:
+    candidate_path, sep, fragment = path.rpartition("#")
+    if not sep:
+        return path, None
+
+    params = parse_qsl(fragment, keep_blank_values=True)
+    scope_values = [value for key, value in params if key == "scope"]
+    if not scope_values:
+        return path, None
+
+    unsupported = [key for key, _ in params if key != "scope"]
+    if unsupported:
+        raise ValueError(
+            "Unsupported modality path fragment parameter(s): "
+            f"{', '.join(sorted(set(unsupported)))}. "
+            "Only '#scope=<metadata_scope>' is supported."
+        )
+    if len(scope_values) > 1:
+        raise ValueError("Modality path may contain at most one '#scope=' selector.")
+
+    return candidate_path, validate_metadata_scope(scope_values[0])
+
+
+def _parse_inline_split(path: str) -> tuple[str, str | None]:
+    colon_pos = path.rfind(":")
+    if colon_pos <= 1:
+        return path, None
+
+    candidate_split = path[colon_pos + 1 :]
+    candidate_path = path[:colon_pos]
+
+    try:
+        split = validate_split_name(candidate_split)
+    except ValueError:
+        return path, None
+
+    return candidate_path, split
+
+
+def parse_modality_path(
+    path: str | Path,
+    *,
+    split: str | None = None,
+    metadata_scope: str | None = None,
+) -> ModalityPath:
+    """Parse euler-loading inline split/scope selectors from a config path."""
+    raw_path = str(path)
+    parsed_path, inline_scope = _parse_inline_scope(raw_path)
+    parsed_path, inline_split = _parse_inline_split(parsed_path)
+
+    if inline_split is not None and split is not None:
+        raise ValueError(
+            f"Modality path {raw_path!r} contains an inline split "
+            f"({inline_split!r}) but an explicit split={split!r} was also "
+            "provided. Use one or the other, not both."
+        )
+
+    normalized_scope = (
+        validate_metadata_scope(metadata_scope)
+        if metadata_scope is not None
+        else None
+    )
+    if inline_scope is not None:
+        if normalized_scope is not None and normalized_scope != inline_scope:
+            raise ValueError(
+                f"Modality path {raw_path!r} contains an inline metadata scope "
+                f"({inline_scope!r}) but an explicit "
+                f"metadata_scope={metadata_scope!r} was also provided. Use one "
+                "metadata scope selector."
+            )
+        normalized_scope = inline_scope
+
+    return ModalityPath(
+        path=parsed_path,
+        split=split if split is not None else inline_split,
+        metadata_scope=normalized_scope,
+    )
+
+
+def normalize_modality_path(path: str | Path, *, split: str | None = None) -> Path:
+    """Return the filesystem/archive root for a config modality path."""
+    return Path(parse_modality_path(path, split=split).path)
+
+
+def build_modality(
+    *,
+    path: str | Path,
+    modality_key: str,
+    split: str | None = None,
+    loader=None,
+    used_as: str | None = None,
+) -> Modality:
+    """Create a Modality after parsing inline config selectors locally."""
+    parsed = parse_modality_path(
+        path,
+        split=split,
+    )
+    return Modality(
+        path=parsed.path,
+        loader=loader,
+        used_as=used_as,
+        modality_type=modality_key,
+        metadata_scope=parsed.metadata_scope or modality_key,
+        split=parsed.split,
+    )

{euler_eval-2.9.0 → euler_eval-2.11.0}/euler_eval/data.py

@@ -13,6 +13,7 @@ import torch
 from ds_crawler import get_dataset_contract, index_dataset_from_path
 from euler_loading import Modality, MultiModalDataset, resolve_loader_module
 
+from .config_paths import build_modality
 from .metrics.utils import convert_planar_to_radial
 
 # ---------------------------------------------------------------------------
@@ -525,13 +526,14 @@ def _resolve_sky_mask_loader(segmentation_path: str) -> Callable[..., Any]:
     its ``sky_mask`` function so that raw class-segmentation data is
     converted to a boolean sky mask at load time.
     """
+    modality = _modality(path=segmentation_path, modality_key="segmentation")
     try:
         index = index_dataset_from_path(
-            segmentation_path,
-            metadata_scope="segmentation",
+            modality.path,
+            metadata_scope=modality.metadata_scope,
         )
     except FileNotFoundError:
-        index = index_dataset_from_path(segmentation_path)
+        index = index_dataset_from_path(modality.path)
     # Resolve euler_loading metadata the same way euler-loading does:
     # try the contract addon API first (handles addons.euler_loading),
     # then fall back to top-level euler_loading for legacy indices.
@@ -546,14 +548,14 @@ def _resolve_sky_mask_loader(segmentation_path: str) -> Callable[..., Any]:
     loader_name = euler_meta.get("loader")
     if loader_name is None:
         raise ValueError(
-            f"Segmentation dataset at {segmentation_path!r} does not declare "
+            f"Segmentation dataset at {modality.path!r} does not declare "
             f"an 'euler_loading.loader' in its ds-crawler index."
         )
     module = resolve_loader_module(loader_name)
     sky_fn = getattr(module, "sky_mask", None)
     if sky_fn is None or not callable(sky_fn):
         raise ValueError(
-            f"Loader module {loader_name!r} (resolved from {segmentation_path!r}) "
+            f"Loader module {loader_name!r} (resolved from {modality.path!r}) "
             f"does not expose a 'sky_mask' function."
         )
     return sky_fn
@@ -573,12 +575,11 @@ def _modality(
     used_as: Optional[str] = None,
 ) -> Modality:
     """Create an euler-loading modality with an explicit metadata selector."""
-    return Modality(
+    return build_modality(
         path=path,
         loader=loader,
         used_as=used_as,
-        modality_type=modality_key,
-        metadata_scope=modality_key,
+        modality_key=modality_key,
         split=split,
     )
 

{euler_eval-2.9.0 → euler_eval-2.11.0}/euler_eval.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-eval
-Version: 2.9.0
+Version: 2.11.0
 Summary: Depth map evaluation toolkit with comprehensive metrics
 Author: Depth Eval Contributors
 License: MIT
@@ -239,7 +239,7 @@ Defines GT modalities, prediction datasets to evaluate, and optional euler_train
 }
 ```
 
-Each modality entry can optionally include a `split` field to select a specific split from the dataset (e.g. `{ "path": "/data/gt/depth", "split": "test" }`).
+Each modality entry can optionally include a `split` field to select a specific split from the dataset (e.g. `{ "path": "/data/gt/depth", "split": "test" }`). euler-loading inline selectors are also accepted in `path`, such as `/data/muses.zip:test` or `/data/muses.zip:test#scope=rgb`.
 
 For sparse pointcloud depth evaluation, use `gt.sparse_depth` instead of `gt.depth`. The prediction still uses `datasets[].depth` because the model output is a dense depth map. The evaluator projects the sparse GT point cloud into the prediction image plane using `gt.intrinsics` and `gt.camera_extrinsics`, then computes pointwise depth metrics only at projected valid pixels.
 
@@ -293,7 +293,7 @@ Dataset metadata (e.g. `radial_depth`, `rgb_range`, sparse point columns, and co
 
 ### Dataset Metadata
 
-Each dataset directory must contain ds-crawler metadata artifacts, typically generated under `.ds_crawler/`:
+Each dataset directory or archive must contain ds-crawler metadata artifacts, typically generated under `.ds_crawler/`:
 
 ```text
 dataset-root/
@@ -303,6 +303,8 @@ dataset-root/
     index.json
 ```
 
+When one physical root or archive contains several logical modalities, the artifacts may instead be scoped under `.ds_crawler/<modality>/` with a `.ds_crawler/scopes.json` manifest. `euler-eval` passes modality scopes to euler-loading so paths such as `/data/muses.zip:test` can load `.ds_crawler/rgb/index.json`, `.ds_crawler/depth/index.json`, and related scoped artifacts from the same archive.
+
 GT and prediction datasets are matched by hierarchy path and file ID through `MultiModalDataset`.
 
 ### `metrics_config.json`

{euler_eval-2.9.0 → euler_eval-2.11.0}/euler_eval.egg-info/SOURCES.txt

@@ -3,6 +3,7 @@ init_cache.py
 pyproject.toml
 euler_eval/__init__.py
 euler_eval/cli.py
+euler_eval/config_paths.py
 euler_eval/data.py
 euler_eval/evaluate.py
 euler_eval/sanity_checker.py

{euler_eval-2.9.0 → euler_eval-2.11.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "euler-eval"
-version = "2.9.0"
+version = "2.11.0"
 description = "Depth map evaluation toolkit with comprehensive metrics"
 readme = "README.md"
 requires-python = ">=3.9"

{euler_eval-2.9.0 → euler_eval-2.11.0}/tests/test_config.py

@@ -1,6 +1,7 @@
 """Tests for main.py config validation."""
 
 import json
+import zipfile
 import pytest
 
 from euler_eval.cli import load_config, validate_dataset_entry, validate_gt_config
@@ -50,6 +51,39 @@ class TestValidateGtConfig:
         gt = {"rgb": {"path": str(rgb_path)}}
         validate_gt_config(gt)
 
+    def test_inline_zip_split_gt_path_is_valid(self, tmp_path):
+        rgb_path = tmp_path / "reference.zip"
+        with zipfile.ZipFile(rgb_path, "w") as zf:
+            zf.writestr("dummy.txt", "x")
+        gt = {"rgb": {"path": f"{rgb_path}:fog_day"}}
+        validate_gt_config(gt)
+
+    def test_inline_scope_gt_path_is_valid(self, tmp_path):
+        rgb_path = tmp_path / "reference.zip"
+        with zipfile.ZipFile(rgb_path, "w") as zf:
+            zf.writestr("dummy.txt", "x")
+        gt = {"rgb": {"path": f"{rgb_path}#scope=rgb"}}
+        validate_gt_config(gt)
+
+    def test_inline_scope_intrinsics_gt_path_is_valid(self, tmp_path):
+        depth_path = tmp_path / "depth"
+        depth_path.mkdir()
+        intrinsics_path = tmp_path / "frame_camera_trainvaltest.zip"
+        with zipfile.ZipFile(intrinsics_path, "w") as zf:
+            zf.writestr("dummy.txt", "x")
+        gt = {
+            "depth": {"path": str(depth_path)},
+            "intrinsics": {"path": f"{intrinsics_path}#scope=intrinsics"},
+        }
+        validate_gt_config(gt)
+
+    def test_inline_split_and_scope_gt_path_is_valid(self, tmp_path):
+        rgb_path = tmp_path / "reference.zip"
+        with zipfile.ZipFile(rgb_path, "w") as zf:
+            zf.writestr("dummy.txt", "x")
+        gt = {"rgb": {"path": f"{rgb_path}:fog_day#scope=rgb"}}
+        validate_gt_config(gt)
+
     def test_sparse_depth_requires_projection_modalities(self, tmp_path):
         sparse_path = tmp_path / "sparse_depth"
         sparse_path.mkdir()
@@ -132,6 +166,16 @@ class TestValidateDatasetEntry:
         with pytest.raises(ValueError, match="does not exist"):
             validate_dataset_entry(entry, 0)
 
+    def test_inline_zip_split_dataset_path_is_valid(self, tmp_path):
+        rgb_path = tmp_path / "prediction.zip"
+        with zipfile.ZipFile(rgb_path, "w") as zf:
+            zf.writestr("dummy.txt", "x")
+        entry = {
+            "name": "model_a",
+            "rgb": {"path": f"{rgb_path}:fog_day"},
+        }
+        validate_dataset_entry(entry, 0)
+
     def test_index_in_error_message(self, tmp_path):
         entry = {"name": "test"}
         with pytest.raises(ValueError, match=r"datasets\[3\]"):

{euler_eval-2.9.0 → euler_eval-2.11.0}/tests/test_data_builders.py

@@ -169,3 +169,37 @@ def test_sky_mask_loader_resolution_uses_segmentation_scope(monkeypatch):
     assert calls == [
         ("/datasets/shared", {"metadata_scope": "segmentation"}),
     ]
+
+
+def test_sky_mask_loader_resolution_strips_inline_split(monkeypatch):
+    calls = []
+
+    def fake_index_dataset_from_path(path, **kwargs):
+        calls.append((path, kwargs))
+        return {"euler_loading": {"loader": "vkitti2"}}
+
+    def sky_mask(path, meta=None):
+        return None
+
+    monkeypatch.setattr(data, "index_dataset_from_path", fake_index_dataset_from_path)
+    monkeypatch.setattr(
+        data,
+        "resolve_loader_module",
+        lambda name: SimpleNamespace(sky_mask=sky_mask),
+    )
+
+    assert data._resolve_sky_mask_loader("/datasets/shared.zip:fog_day") is sky_mask
+    assert calls == [
+        ("/datasets/shared.zip", {"metadata_scope": "segmentation"}),
+    ]
+
+
+def test_modality_parses_inline_split_and_scope():
+    modality = data._modality(
+        path="/datasets/frame_camera_trainvaltest.zip:fog_day#scope=intrinsics",
+        modality_key="intrinsics",
+    )
+
+    assert modality.path == "/datasets/frame_camera_trainvaltest.zip"
+    assert modality.split == "fog_day"
+    assert modality.metadata_scope == "intrinsics"

{euler_eval-2.9.0 → euler_eval-2.11.0}/tests/test_save_results.py

@@ -214,6 +214,36 @@ class TestSaveResultsZip:
             stored = json.loads(zf.read("eval.json"))
             assert stored == results
 
+    def test_inline_zip_split_writes_eval_json_into_zip(self, tmp_path):
+        zp = tmp_path / "dataset.zip"
+        with zipfile.ZipFile(zp, "w") as zf:
+            zf.writestr("image_001.png", b"\x89PNG")
+
+        results = {"depth": {"rmse": 0.42}}
+        config = {"name": "model", "depth": {"path": f"{zp}:fog_day"}}
+        out = save_results(results, config)
+
+        assert out == zp / "eval.json"
+        with zipfile.ZipFile(zp, "r") as zf:
+            assert "eval.json" in zf.namelist()
+            stored = json.loads(zf.read("eval.json"))
+            assert stored == results
+
+    def test_inline_zip_scope_writes_eval_json_into_zip(self, tmp_path):
+        zp = tmp_path / "dataset.zip"
+        with zipfile.ZipFile(zp, "w") as zf:
+            zf.writestr("image_001.png", b"\x89PNG")
+
+        results = {"rgb": {"psnr": 30.0}}
+        config = {"name": "model", "rgb": {"path": f"{zp}#scope=rgb"}}
+        out = save_results(results, config, modality="rgb")
+
+        assert out == zp / "eval.json"
+        with zipfile.ZipFile(zp, "r") as zf:
+            assert "eval.json" in zf.namelist()
+            stored = json.loads(zf.read("eval.json"))
+            assert stored == results
+
     def test_preserves_existing_zip_contents(self, tmp_path):
         zp = tmp_path / "dataset.zip"
         with zipfile.ZipFile(zp, "w") as zf: