euler-loading 2.2.0__tar.gz → 2.2.2__tar.gz

{euler_loading-2.2.0 → euler_loading-2.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: euler-loading
-Version: 2.2.0
+Version: 2.2.2
 Summary: Multi-modal PyTorch dataloader using ds-crawler indices
 Requires-Python: >=3.9
 Requires-Dist: ds-crawler

{euler_loading-2.2.0 → euler_loading-2.2.2}/euler_loading/dataset.py

@@ -59,6 +59,32 @@ __all__ = [
 ]
 
 
+def _callable_name(value: Any) -> str:
+    module = getattr(value, "__module__", None)
+    qualname = getattr(value, "__qualname__", None)
+    if module and qualname:
+        return f"{module}.{qualname}"
+    name = getattr(value, "__name__", None)
+    if module and name:
+        return f"{module}.{name}"
+    cls = value.__class__
+    return f"{cls.__module__}.{cls.__qualname__}"
+
+
+def _describe_transform(transform: Any) -> str:
+    describe = getattr(transform, "describe", None)
+    if callable(describe):
+        try:
+            return str(describe())
+        except Exception:
+            logger.debug(
+                "Failed to describe transform %s; falling back to callable name.",
+                _callable_name(transform),
+                exc_info=True,
+            )
+    return _callable_name(transform)
+
+
 def _get_index_tree(index_output: Mapping[str, Any]) -> dict[str, Any]:
     """Return the dataset tree from a ds-crawler output payload."""
     index_tree = index_output.get("index")
@@ -444,6 +470,17 @@ class MultiModalDataset(_BaseDataset):
             bind = getattr(transform, "bind_to_dataset", None)
             if callable(bind):
                 bind(self)
+        if self._transforms:
+            logger.warning("Configured %d sample transform(s):", len(self._transforms))
+            for idx, transform in enumerate(self._transforms, start=1):
+                logger.warning(
+                    "Transform %d/%d: %s",
+                    idx,
+                    len(self._transforms),
+                    _describe_transform(transform),
+                )
+        else:
+            logger.warning("Configured 0 sample transforms.")
 
     def get_modality_metadata(self, modality_name: str) -> dict[str, Any]:
         """Return the metadata dict for a given modality name."""

{euler_loading-2.2.0 → euler_loading-2.2.2}/euler_loading/preprocessing.py

@@ -186,6 +186,30 @@ class FieldSpec:
     def is_passthrough(self) -> bool:
         return self.kind == "passthrough"
 
+    def describe(self, *, include_defaults: bool = True) -> str:
+        """Return a concise human-readable description of this field policy."""
+        parts = [f"kind={self.kind}"]
+        if self.layout is not None:
+            parts.append(f"layout={self.layout}")
+
+        interpolation = self.interpolation
+        if include_defaults and interpolation is None:
+            interpolation = _DEFAULT_INTERPOLATION[self.kind]
+        if interpolation is not None:
+            parts.append(f"interpolation={interpolation}")
+
+        normalize_vectors = self.normalize_vectors
+        if include_defaults and normalize_vectors is None:
+            normalize_vectors = self.kind == "ray_map"
+        if normalize_vectors is not None:
+            parts.append(f"normalize_vectors={bool(normalize_vectors)}")
+
+        if self.kind == "mask" or self.threshold != 0.5:
+            parts.append(f"threshold={self.threshold:g}")
+        if self.reduce is not None:
+            parts.append(f"reduce={self.reduce}")
+        return ", ".join(parts)
+
 
 @dataclass(frozen=True)
 class Resize:
@@ -202,6 +226,10 @@ class Resize:
     def from_config(cls, cfg: Any) -> "Resize":
         return cls(size=_parse_size(cfg, context="Resize"))
 
+    def describe(self) -> str:
+        height, width = self.size
+        return f"resize({height}x{width})"
+
 
 @dataclass(frozen=True)
 class Crop:
@@ -246,6 +274,13 @@ class Crop:
             )
         return cls(size=_parse_size(cfg, context="Crop"))
 
+    def describe(self) -> str:
+        height, width = self.size
+        parts = [f"crop({height}x{width})", f"anchor={self.anchor}"]
+        if self.offset is not None:
+            parts.append(f"offset={self.offset}")
+        return ", ".join(parts)
+
     def resolve_box(self, source_size: tuple[int, int]) -> tuple[int, int, int, int]:
         source_h, source_w = source_size
         target_h, target_w = self.size
@@ -687,6 +722,34 @@ class SamplePreprocessor:
         bind_group(getattr(dataset, "_hierarchical_modalities", {}))
         self._bound_field_specs = bound_specs
 
+    def describe(self) -> str:
+        """Return a concise summary suitable for initialization logging."""
+        operations = ", ".join(
+            operation.describe() if hasattr(operation, "describe") else repr(operation)
+            for operation in self.operations
+        ) or "none"
+
+        active_specs = self._bound_field_specs or self.field_specs
+        if active_specs:
+            field_parts = [
+                f"{name}: {spec.describe()}"
+                for name, spec in sorted(active_specs.items())
+            ]
+            fields_text = "; ".join(field_parts)
+        elif self.infer_fields:
+            fields_text = "inferred from modality_type/name heuristics"
+        else:
+            fields_text = "none"
+
+        reference = self.reference_field or "auto"
+        return (
+            "SamplePreprocessor("
+            f"operations=[{operations}], "
+            f"reference_field={reference}, "
+            f"infer_fields={self.infer_fields}, "
+            f"fields={fields_text})"
+        )
+
     def _resolve_field_spec(self, key: str, value: Any) -> FieldSpec | None:
         if key in self._bound_field_specs:
             return self._bound_field_specs[key]

{euler_loading-2.2.0 → euler_loading-2.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "euler-loading"
-version = "2.2.0"
+version = "2.2.2"
 description = "Multi-modal PyTorch dataloader using ds-crawler indices"
 requires-python = ">=3.9"
 dependencies = [

{euler_loading-2.2.0 → euler_loading-2.2.2}/tests/test_preprocessing.py

@@ -2,6 +2,7 @@
 
 from __future__ import annotations
 
+import logging
 from unittest.mock import patch
 
 import numpy as np
@@ -183,3 +184,52 @@ class TestDatasetTransformBinding:
         sample = dataset[0]
         assert sample["rgb"].shape == (3, 2, 3)
         assert sample["metric_depth"].shape == (1, 2, 3)
+
+    def test_dataset_logs_transform_behaviour_once_on_init(self, caplog):
+        rgb_index = _flat_index("rgb", ["f001"])
+
+        def rgb_loader(path, meta=None):
+            return torch.ones((3, 4, 6), dtype=torch.float32)
+
+        def identity(sample):
+            return sample
+
+        preprocessor = SamplePreprocessor.from_config(
+            {
+                "resize": [2, 3],
+                "infer_fields": False,
+                "fields": {
+                    "valid_mask": {"kind": "mask"},
+                    "intrinsics": {"kind": "intrinsics", "reduce": "first"},
+                },
+            }
+        )
+
+        with patch(
+            "euler_loading.dataset.index_dataset_from_path",
+            return_value=rgb_index,
+        ), caplog.at_level(logging.WARNING, logger="euler_loading.dataset"):
+            MultiModalDataset(
+                modalities={
+                    "rgb": Modality(
+                        "/data/rgb",
+                        loader=rgb_loader,
+                        modality_type="rgb",
+                    ),
+                },
+                transforms=[preprocessor, identity],
+            )
+
+        messages = [record.message for record in caplog.records]
+        assert messages.count("Configured 2 sample transform(s):") == 1
+        assert all(record.levelno == logging.WARNING for record in caplog.records)
+
+        joined = "\n".join(messages)
+        assert "SamplePreprocessor(" in joined
+        assert "resize(2x3)" in joined
+        assert "rgb: kind=image" in joined
+        assert "valid_mask: kind=mask" in joined
+        assert "interpolation=nearest" in joined
+        assert "intrinsics: kind=intrinsics" in joined
+        assert "reduce=first" in joined
+        assert "identity" in joined