dataeval-flow 0.1.1__tar.gz → 0.1.2__tar.gz

{dataeval_flow-0.1.1 → dataeval_flow-0.1.2}/.gitignore

@@ -34,6 +34,9 @@ output/
 # Generated notebooks (source of truth is MyST markdown)
 *.ipynb
 
+# Jupyter execution cache (stored in docs-artifacts/<branch> orphan branch instead)
+.jupyter_cache/
+
 # Nox
 .nox/
 .cuda-version

{dataeval_flow-0.1.1 → dataeval_flow-0.1.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataeval-flow
-Version: 0.1.1
+Version: 0.1.2
 Summary: DataEval Workflows container for data evaluation
 Project-URL: Repository, https://gitlab.jatic.net/jatic/aria/dataeval-flow
 License-Expression: MIT

{dataeval_flow-0.1.1 → dataeval_flow-0.1.2}/pyproject.toml

@@ -257,6 +257,9 @@ output = "output/coverage.xml"
 
 [tool.pyright]
 reportMissingImports = false
+# torch's stubs omit many runtime symbols (zeros, arange, equal, dtype, ...)
+# from __all__, so pyright flags valid usage as private imports. Upstream defect.
+reportPrivateImportUsage = false
 
 # --- Ruff [CR-3-G-2] ---
 

{dataeval_flow-0.1.1 → dataeval_flow-0.1.2}/src/dataeval_flow/_app/_model/_discover.py

@@ -1,7 +1,8 @@
 """Runtime discovery of available transforms and selection classes.
 
-Introspects torchvision.transforms.v2 and dataeval.selection to provide
-dropdown options and parameter schemas for the builder TUI.
+Introspects dataeval_flow.preprocessors, torchvision.transforms.v2, and
+dataeval.selection to provide dropdown options and parameter schemas for the
+builder TUI.
 """
 
 from __future__ import annotations
@@ -102,9 +103,16 @@ def _introspect_params(cls: type) -> list[ParamInfo]:
 
 @lru_cache(maxsize=1)
 def list_transforms() -> list[str]:
-    """Return sorted names of available torchvision.transforms.v2 classes."""
+    """Return sorted names of available transforms.
+
+    Includes the custom named preprocessors (``dataeval_flow.preprocessors``)
+    alongside ``torchvision.transforms.v2`` classes, mirroring how
+    ``build_preprocessing`` resolves step names.
+    """
     from torchvision.transforms import v2
 
+    from dataeval_flow.preprocessors import CUSTOM_PREPROCESSORS
+
     skip = {
         "Transform",
         "Compose",
@@ -116,7 +124,7 @@ def list_transforms() -> list[str]:
         "InterpolationMode",
         "Lambda",
     }
-    names = []
+    names = list(CUSTOM_PREPROCESSORS)
     for name, obj in inspect.getmembers(v2):
         if (
             inspect.isclass(obj)
@@ -151,10 +159,16 @@ def list_selection_classes() -> list[str]:
 
 @lru_cache(maxsize=64)
 def get_transform_params(name: str) -> list[ParamInfo]:
-    """Get parameter info for a torchvision.transforms.v2 class."""
+    """Get parameter info for a transform.
+
+    Resolves custom preprocessors first, then ``torchvision.transforms.v2``,
+    matching ``build_preprocessing``'s resolution order.
+    """
     from torchvision.transforms import v2
 
-    cls = getattr(v2, name, None)
+    from dataeval_flow.preprocessors import resolve_custom
+
+    cls = resolve_custom(name) or getattr(v2, name, None)
     if cls is None:
         return []
     return _introspect_params(cls)

{dataeval_flow-0.1.1 → dataeval_flow-0.1.2}/src/dataeval_flow/_version.py

@@ -18,7 +18,7 @@ version_tuple: tuple[int | str, ...]
 commit_id: str | None
 __commit_id__: str | None
 
-__version__ = version = '0.1.1'
-__version_tuple__ = version_tuple = (0, 1, 1)
+__version__ = version = '0.1.2'
+__version_tuple__ = version_tuple = (0, 1, 2)
 
 __commit_id__ = commit_id = None

{dataeval_flow-0.1.1 → dataeval_flow-0.1.2}/src/dataeval_flow/preprocessing.py

@@ -1,7 +1,9 @@
 """Preprocessing utilities for image transforms.
 
 Provides configuration-driven preprocessing using torchvision.transforms.v2.
-Any v2 transform can be specified by name in YAML config.
+Any v2 transform can be specified by name in YAML config, plus the custom named
+preprocessors in ``dataeval_flow.preprocessors`` (e.g. ``ToRGB``). Custom names
+are resolved first but are distinct from torchvision names and never shadow them.
 
 The returned callable accepts a numpy CHW array, converts to a torch tensor
 for torchvision transforms, then converts back to a numpy CHW array so that
@@ -33,6 +35,7 @@ from numpy.typing import NDArray
 from pydantic import BaseModel, Field
 
 from dataeval_flow._logging import LogMessage
+from dataeval_flow.preprocessors import CUSTOM_PREPROCESSORS, resolve_custom
 
 _logger: logging.Logger = logging.getLogger(__name__)
 
@@ -133,10 +136,14 @@ def build_preprocessing(steps: Sequence[PreprocessingStep]) -> _PreprocessingTra
             if key in params:
                 params[key] = converter(params[key])
 
-        # Get transform class and instantiate
-        transform_cls = getattr(v2, step.step, None)
+        # Resolve custom preprocessors first, then torchvision. Custom names are
+        # distinct from torchvision names and never shadow them.
+        transform_cls = resolve_custom(step.step) or getattr(v2, step.step, None)
         if transform_cls is None:
-            raise ValueError(f"Unknown transform: '{step.step}'. Check torchvision.transforms.v2 docs.")
+            raise ValueError(
+                f"Unknown transform: '{step.step}'. Must be a custom preprocessor "
+                f"({', '.join(CUSTOM_PREPROCESSORS)}) or a torchvision.transforms.v2 transform."
+            )
         ops.append(transform_cls(**params))
 
     composed = v2.Compose(ops)

dataeval_flow-0.1.2/src/dataeval_flow/preprocessors.py

@@ -0,0 +1,56 @@
+"""Custom named preprocessors resolved alongside torchvision transforms.
+
+These supplement ``torchvision.transforms.v2``: ``build_preprocessing`` checks
+this registry first, then falls back to torchvision. Custom preprocessors use
+**distinct names** and do **not** shadow or override any torchvision ``v2``
+transform — by design the names never collide.
+
+Each preprocessor is a tensor -> tensor callable composed into ``v2.Compose``
+exactly like a torchvision transform.
+"""
+
+from typing import Any
+
+__all__ = ["ToRGB", "CUSTOM_PREPROCESSORS", "resolve_custom"]
+
+
+class ToRGB:
+    """Coerce a CHW tensor image to 3 channels (repeat grayscale, drop alpha).
+
+    torchvision's ``v2.RGB`` expands 1->3 channels but leaves 4-channel RGBA
+    untouched, so models expecting 3-channel input still fail on RGBA inputs.
+    This handles both: 1/2-channel -> repeat luma to RGB, >=4-channel -> keep
+    the first three (drop alpha); 3-channel passes through. The stable ``repr``
+    keeps the preprocessing cache key deterministic.
+    """
+
+    __slots__ = ()
+
+    def __call__(self, image: Any) -> Any:
+        """Coerce a CHW (or HW) tensor image to exactly 3 channels."""
+        if image.ndim == 2:  # HW -> 1HW
+            image = image.unsqueeze(0)
+        channels = image.shape[0]
+        if channels == 3:
+            return image
+        if channels > 3:  # RGBA (or more) -> drop alpha/extra channels
+            return image[:3]
+        return image[:1].repeat(3, 1, 1)  # gray (or gray+alpha) -> RGB
+
+    def __repr__(self) -> str:
+        """Return a deterministic repr for preprocessing cache-key stability."""
+        return "ToRGB()"
+
+
+# Registry of custom preprocessors. Names here MUST be distinct from torchvision
+# v2 transform names — custom preprocessors never shadow/override torchvision.
+CUSTOM_PREPROCESSORS: dict[str, type] = {"ToRGB": ToRGB}
+
+
+def resolve_custom(name: str) -> type | None:
+    """Return the registered custom preprocessor class for ``name``, else ``None``.
+
+    A ``None`` result signals the caller to fall back to torchvision. Custom
+    names do not shadow torchvision transforms; the two name spaces are disjoint.
+    """
+    return CUSTOM_PREPROCESSORS.get(name)