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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-eval
-Version: 2.10.0
+Version: 2.11.0
 Summary: Depth map evaluation toolkit with comprehensive metrics
 Author: Depth Eval Contributors
 License: MIT

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

@@ -13,8 +13,8 @@ import zipfile
 from pathlib import Path
 
 import torch
-from euler_loading import Modality
 
+from .config_paths import normalize_modality_path
 from .data import (
     build_depth_eval_dataset,
     build_rays_eval_dataset,
@@ -41,22 +41,6 @@ except ImportError:
 from euler_metric_naming import AxisDeclaration, MetricDescription, MetricNamespace
 
 
-def _normalize_modality_path(
-    path: str | Path,
-    *,
-    modality_key: str,
-    split: str | None = None,
-) -> Path:
-    """Return the filesystem/archive root for an euler-loading modality path."""
-    modality = Modality(
-        str(path),
-        modality_type=modality_key,
-        metadata_scope=modality_key,
-        split=split,
-    )
-    return Path(modality.path)
-
-
 # ── Eval namespace ──────────────────────────────────────────────────────────
 # MetricNamespace subclass for eval context with custom axis declarations,
 # following the Normed Metric Namespacing convention (§3.6, §4, §5.2).
@@ -616,9 +600,8 @@ def validate_gt_config(gt: dict) -> None:
         "camera_extrinsics",
     ):
         if modality in gt and "path" in gt[modality]:
-            p = _normalize_modality_path(
+            p = normalize_modality_path(
                 gt[modality]["path"],
-                modality_key=modality,
                 split=gt[modality].get("split"),
             )
             if not p.exists():
@@ -645,9 +628,8 @@ 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 = _normalize_modality_path(
+            p = normalize_modality_path(
                 entry[modality]["path"],
-                modality_key=modality,
                 split=entry[modality].get("split"),
             )
             if not p.exists():
@@ -775,9 +757,8 @@ def save_results(
             and "path" in dataset_config[modality]
         ):
             output_file = (
-                _normalize_modality_path(
+                normalize_modality_path(
                     dataset_config[modality]["path"],
-                    modality_key=modality,
                     split=dataset_config[modality].get("split"),
                 )
                 / "eval.json"
@@ -787,9 +768,8 @@ def save_results(
             for mod in ("depth", "rgb", "rays"):
                 if mod in dataset_config and "path" in dataset_config[mod]:
                     output_file = (
-                        _normalize_modality_path(
+                        normalize_modality_path(
                             dataset_config[mod]["path"],
-                            modality_key=mod,
                             split=dataset_config[mod].get("split"),
                         )
                         / "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.10.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
 
 # ---------------------------------------------------------------------------
@@ -574,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.10.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.10.0
+Version: 2.11.0
 Summary: Depth map evaluation toolkit with comprehensive metrics
 Author: Depth Eval Contributors
 License: MIT

{euler_eval-2.10.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.10.0 → euler_eval-2.11.0}/pyproject.toml

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

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

@@ -65,6 +65,25 @@ class TestValidateGtConfig:
         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()

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

@@ -192,3 +192,14 @@ def test_sky_mask_loader_resolution_strips_inline_split(monkeypatch):
     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.10.0 → euler_eval-2.11.0}/tests/test_save_results.py

@@ -229,6 +229,21 @@ class TestSaveResultsZip:
             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: