euler-loading 2.2.1__tar.gz → 2.3.0__tar.gz

{euler_loading-2.2.1 → euler_loading-2.3.0}/PKG-INFO

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

{euler_loading-2.2.1 → euler_loading-2.3.0}/README.md

@@ -218,6 +218,19 @@ def mask_sky_in_depth(sample: dict) -> dict:
     return sample
 ```
 
+For common mask-driven replacements, `MaskedValueOverride` can do the same
+without writing a custom callable:
+
+```python
+from euler_loading import MaskedValueOverride
+
+replace_sky_depth = MaskedValueOverride(
+    target_key="depth",
+    mask_key="sky_mask",
+    value=300.0,
+)
+```
+
 ### Built-in spatial preprocessing
 
 `euler_loading.SamplePreprocessor` applies shared spatial ops such as resize and crop

{euler_loading-2.2.1 → euler_loading-2.3.0}/euler_loading/__init__.py

@@ -9,6 +9,7 @@ from .loaders.contracts import DenseDepthCodec, DenseDepthLoader, DenseDepthWrit
 from .preprocessing import (
     Crop,
     FieldSpec,
+    MaskedValueOverride,
     Resize,
     SamplePreprocessor,
     crop_intrinsics,
@@ -23,6 +24,7 @@ __all__ = [
     "FileRecord",
     "Crop",
     "FieldSpec",
+    "MaskedValueOverride",
     "Modality",
     "MultiModalDataset",
     "Resize",

{euler_loading-2.2.1 → euler_loading-2.3.0}/euler_loading/dataset.py

@@ -471,16 +471,16 @@ class MultiModalDataset(_BaseDataset):
             if callable(bind):
                 bind(self)
         if self._transforms:
-            logger.info("Configured %d sample transform(s):", len(self._transforms))
+            logger.warning("Configured %d sample transform(s):", len(self._transforms))
             for idx, transform in enumerate(self._transforms, start=1):
-                logger.info(
+                logger.warning(
                     "Transform %d/%d: %s",
                     idx,
                     len(self._transforms),
                     _describe_transform(transform),
                 )
         else:
-            logger.info("Configured 0 sample transforms.")
+            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.1 → euler_loading-2.3.0}/euler_loading/preprocessing.py

@@ -17,6 +17,7 @@ except ImportError:  # pragma: no cover - exercised in CPU-only environments
 
 __all__ = [
     "FieldSpec",
+    "MaskedValueOverride",
     "Resize",
     "Crop",
     "SamplePreprocessor",
@@ -310,6 +311,111 @@ class Crop:
         return top, left, target_h, target_w
 
 
+@dataclass(frozen=True)
+class MaskedValueOverride:
+    """Set values in one sample field wherever a boolean mask field is true."""
+
+    target_key: str
+    mask_key: str
+    value: Any
+    invert_mask: bool = False
+    copy: bool = True
+    ignore_missing: bool = False
+
+    @classmethod
+    def from_config(cls, cfg: Mapping[str, Any]) -> "MaskedValueOverride":
+        if not isinstance(cfg, Mapping):
+            raise TypeError(
+                "MaskedValueOverride config must be a mapping, "
+                f"got {type(cfg).__name__}."
+            )
+        return cls(
+            target_key=str(cfg.get("target_key", cfg.get("target", ""))),
+            mask_key=str(cfg.get("mask_key", cfg.get("mask", ""))),
+            value=cfg.get("value"),
+            invert_mask=bool(cfg.get("invert_mask", False)),
+            copy=bool(cfg.get("copy", True)),
+            ignore_missing=bool(cfg.get("ignore_missing", False)),
+        )
+
+    def __post_init__(self) -> None:
+        if not self.target_key:
+            raise ValueError("MaskedValueOverride requires target_key.")
+        if not self.mask_key:
+            raise ValueError("MaskedValueOverride requires mask_key.")
+
+    def describe(self) -> str:
+        parts = [
+            f"masked_value_override(target={self.target_key}",
+            f"mask={self.mask_key}",
+            f"value={self.value!r}",
+        ]
+        if self.invert_mask:
+            parts.append("invert_mask=True")
+        if not self.copy:
+            parts.append("copy=False")
+        if self.ignore_missing:
+            parts.append("ignore_missing=True")
+        return ", ".join(parts) + ")"
+
+    def _missing(self, key: str) -> None:
+        if self.ignore_missing:
+            return
+        raise KeyError(f"MaskedValueOverride missing sample key: {key!r}")
+
+    def __call__(self, sample: dict[str, Any]) -> dict[str, Any]:
+        if self.target_key not in sample:
+            self._missing(self.target_key)
+            return sample
+        if self.mask_key not in sample:
+            self._missing(self.mask_key)
+            return sample
+
+        target = sample[self.target_key]
+        mask = sample[self.mask_key]
+
+        processed = dict(sample) if self.copy else sample
+
+        if _is_torch_tensor(target):
+            if _is_torch_tensor(mask):
+                mask_tensor = mask.to(device=target.device, dtype=torch.bool)
+            else:
+                mask_tensor = torch.as_tensor(
+                    mask,
+                    device=target.device,
+                    dtype=torch.bool,
+                )
+            if self.invert_mask:
+                mask_tensor = ~mask_tensor
+            if tuple(mask_tensor.shape) != tuple(target.shape):
+                mask_tensor = torch.broadcast_to(mask_tensor, target.shape)
+            value_tensor = torch.as_tensor(
+                self.value,
+                device=target.device,
+                dtype=target.dtype,
+            )
+            result = target.clone() if self.copy else target
+            result[mask_tensor] = value_tensor
+            processed[self.target_key] = result
+            return processed
+
+        if isinstance(target, np.ndarray):
+            mask_array = np.asarray(mask, dtype=np.bool_)
+            if self.invert_mask:
+                mask_array = ~mask_array
+            if tuple(mask_array.shape) != tuple(target.shape):
+                mask_array = np.broadcast_to(mask_array, target.shape)
+            result = np.array(target, copy=self.copy)
+            result[mask_array] = self.value
+            processed[self.target_key] = result
+            return processed
+
+        raise TypeError(
+            f"MaskedValueOverride target {self.target_key!r} must be a torch.Tensor "
+            f"or numpy.ndarray, got {type(target).__name__}."
+        )
+
+
 def infer_field_spec(name: str, value: Any | None = None) -> FieldSpec | None:
     """Best-effort field inference for common modality names."""
 

{euler_loading-2.2.1 → euler_loading-2.3.0}/pyproject.toml

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

{euler_loading-2.2.1 → euler_loading-2.3.0}/tests/test_preprocessing.py

@@ -9,7 +9,7 @@ import numpy as np
 import pytest
 import torch
 
-from euler_loading import Modality, MultiModalDataset
+from euler_loading import MaskedValueOverride, Modality, MultiModalDataset
 from euler_loading.preprocessing import SamplePreprocessor
 
 
@@ -143,6 +143,63 @@ class TestSamplePreprocessorNumpy:
         assert np.allclose(processed["intrinsics"], expected_intrinsics)
 
 
+class TestMaskedValueOverride:
+    def test_overrides_torch_target_with_broadcast_mask(self):
+        depth = torch.tensor(
+            [
+                [[1.0, 2.0], [3.0, 4.0]],
+                [[5.0, 6.0], [7.0, 8.0]],
+            ],
+            dtype=torch.float32,
+        )
+        sky_mask = torch.tensor([[[True, False], [False, True]]])
+
+        transform = MaskedValueOverride(
+            target_key="depth",
+            mask_key="sky_mask",
+            value=0.5,
+        )
+        processed = transform({"depth": depth, "sky_mask": sky_mask})
+
+        expected = torch.tensor(
+            [
+                [[0.5, 2.0], [3.0, 0.5]],
+                [[0.5, 6.0], [7.0, 0.5]],
+            ],
+            dtype=torch.float32,
+        )
+        assert torch.equal(processed["depth"], expected)
+        assert torch.equal(
+            depth,
+            torch.tensor(
+                [
+                    [[1.0, 2.0], [3.0, 4.0]],
+                    [[5.0, 6.0], [7.0, 8.0]],
+                ],
+                dtype=torch.float32,
+            ),
+        )
+
+    def test_overrides_numpy_target_with_inverted_mask(self):
+        depth = np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32)
+        valid_mask = np.array([[True, False], [False, True]], dtype=np.bool_)
+
+        transform = MaskedValueOverride(
+            target_key="depth",
+            mask_key="valid_mask",
+            value=9.0,
+            invert_mask=True,
+        )
+        processed = transform({"depth": depth, "valid_mask": valid_mask})
+
+        expected = np.array([[1.0, 9.0], [9.0, 4.0]], dtype=np.float32)
+        assert np.array_equal(processed["depth"], expected)
+        assert np.array_equal(
+            depth,
+            np.array([[1.0, 2.0], [3.0, 4.0]], dtype=np.float32),
+        )
+
+
 class TestDatasetTransformBinding:
     def test_dataset_binds_modality_types_into_preprocessor(self):
         rgb_index = _flat_index("rgb", ["f001"])
@@ -208,7 +265,7 @@ class TestDatasetTransformBinding:
         with patch(
             "euler_loading.dataset.index_dataset_from_path",
             return_value=rgb_index,
-        ), caplog.at_level(logging.INFO, logger="euler_loading.dataset"):
+        ), caplog.at_level(logging.WARNING, logger="euler_loading.dataset"):
             MultiModalDataset(
                 modalities={
                     "rgb": Modality(
@@ -222,6 +279,7 @@ class TestDatasetTransformBinding:
 
         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