dataeval 0.74.0__py3-none-any.whl → 0.74.2__py3-none-any.whl

dataeval/metrics/stats/datasetstats.py

@@ -15,11 +15,11 @@ from dataeval.metrics.stats.dimensionstats import (
 from dataeval.metrics.stats.labelstats import LabelStatsOutput, labelstats
 from dataeval.metrics.stats.pixelstats import PixelStatsOutput, PixelStatsProcessor
 from dataeval.metrics.stats.visualstats import VisualStatsOutput, VisualStatsProcessor
-from dataeval.output import OutputMetadata, set_metadata
+from dataeval.output import Output, set_metadata
 
 
 @dataclass(frozen=True)
-class DatasetStatsOutput(OutputMetadata):
+class DatasetStatsOutput(Output):
     """
     Output class for :func:`datasetstats` stats metric
 
@@ -41,7 +41,7 @@ class DatasetStatsOutput(OutputMetadata):
     visualstats: VisualStatsOutput
     labelstats: LabelStatsOutput | None = None
 
-    def _outputs(self) -> list[OutputMetadata]:
+    def _outputs(self) -> list[Output]:
         return [s for s in (self.dimensionstats, self.pixelstats, self.visualstats, self.labelstats) if s is not None]
 
     def dict(self) -> dict[str, Any]:
@@ -54,7 +54,7 @@ class DatasetStatsOutput(OutputMetadata):
 
 
 @dataclass(frozen=True)
-class ChannelStatsOutput(OutputMetadata):
+class ChannelStatsOutput(Output):
     """
     Output class for :func:`channelstats` stats metric
 
@@ -84,7 +84,7 @@ class ChannelStatsOutput(OutputMetadata):
             raise ValueError("All StatsOutput classes must contain the same number of image sources.")
 
 
-@set_metadata()
+@set_metadata
 def datasetstats(
     images: Iterable[ArrayLike],
     bboxes: Iterable[ArrayLike] | None = None,
@@ -131,7 +131,7 @@ def datasetstats(
     return DatasetStatsOutput(*outputs, labelstats=labelstats(labels) if labels else None)  # type: ignore
 
 
-@set_metadata()
+@set_metadata
 def channelstats(
     images: Iterable[ArrayLike],
     bboxes: Iterable[ArrayLike] | None = None,

dataeval/metrics/stats/dimensionstats.py

@@ -73,7 +73,7 @@ class DimensionStatsProcessor(StatsProcessor[DimensionStatsOutput]):
     }
 
 
-@set_metadata()
+@set_metadata
 def dimensionstats(
     images: Iterable[ArrayLike],
     bboxes: Iterable[ArrayLike] | None = None,

dataeval/metrics/stats/hashstats.py

@@ -116,7 +116,7 @@ class HashStatsProcessor(StatsProcessor[HashStatsOutput]):
     }
 
 
-@set_metadata()
+@set_metadata
 def hashstats(
     images: Iterable[ArrayLike],
     bboxes: Iterable[ArrayLike] | None = None,

dataeval/metrics/stats/labelstats.py

@@ -9,11 +9,11 @@ from typing import Any, Iterable, Mapping, TypeVar
 from numpy.typing import ArrayLike
 
 from dataeval.interop import to_numpy
-from dataeval.output import OutputMetadata, set_metadata
+from dataeval.output import Output, set_metadata
 
 
 @dataclass(frozen=True)
-class LabelStatsOutput(OutputMetadata):
+class LabelStatsOutput(Output):
     """
     Output class for :func:`labelstats` stats metric
 
@@ -57,7 +57,7 @@ def sort(d: Mapping[TKey, Any]) -> dict[TKey, Any]:
     return dict(sorted(d.items(), key=lambda x: x[0]))
 
 
-@set_metadata()
+@set_metadata
 def labelstats(
     labels: Iterable[ArrayLike],
 ) -> LabelStatsOutput:

dataeval/metrics/stats/pixelstats.py

@@ -67,7 +67,7 @@ class PixelStatsProcessor(StatsProcessor[PixelStatsOutput]):
     }
 
 
-@set_metadata()
+@set_metadata
 def pixelstats(
     images: Iterable[ArrayLike],
     bboxes: Iterable[ArrayLike] | None = None,

dataeval/metrics/stats/visualstats.py

@@ -74,7 +74,7 @@ class VisualStatsProcessor(StatsProcessor[VisualStatsOutput]):
     }
 
 
-@set_metadata()
+@set_metadata
 def visualstats(
     images: Iterable[ArrayLike],
     bboxes: Iterable[ArrayLike] | None = None,

dataeval/output.py

@@ -4,9 +4,10 @@ __all__ = []
 
 import inspect
 import sys
+from collections.abc import Mapping
 from datetime import datetime, timezone
-from functools import wraps
-from typing import Any, Callable, Iterable, TypeVar
+from functools import partial, wraps
+from typing import Any, Callable, Iterator, TypeVar
 
 import numpy as np
 
@@ -18,7 +19,7 @@ else:
 from dataeval import __version__
 
 
-class OutputMetadata:
+class Output:
     _name: str
     _execution_time: datetime
     _execution_duration: float
@@ -26,6 +27,9 @@ class OutputMetadata:
     _state: dict[str, str]
     _version: str
 
+    def __str__(self) -> str:
+        return f"{self.__class__.__name__}: {str(self.dict())}"
+
     def dict(self) -> dict[str, Any]:
         return {k: v for k, v in self.__dict__.items() if not k.startswith("_")}
 
@@ -33,58 +37,78 @@ class OutputMetadata:
         return {k.removeprefix("_"): v for k, v in self.__dict__.items() if k.startswith("_")}
 
 
+TKey = TypeVar("TKey", str, int, float, set)
+TValue = TypeVar("TValue")
+
+
+class MappingOutput(Mapping[TKey, TValue], Output):
+    __slots__ = ["_data"]
+
+    def __init__(self, data: Mapping[TKey, TValue]):
+        self._data = data
+
+    def __getitem__(self, key: TKey) -> TValue:
+        return self._data.__getitem__(key)
+
+    def __iter__(self) -> Iterator[TKey]:
+        return self._data.__iter__()
+
+    def __len__(self) -> int:
+        return self._data.__len__()
+
+    def dict(self) -> dict[str, TValue]:
+        return {str(k): v for k, v in self._data.items()}
+
+
 P = ParamSpec("P")
-R = TypeVar("R", bound=OutputMetadata)
-
-
-def set_metadata(
-    state_attr: Iterable[str] | None = None,
-) -> Callable[[Callable[P, R]], Callable[P, R]]:
-    """Decorator to stamp OutputMetadata classes with runtime metadata"""
-
-    def decorator(fn: Callable[P, R]) -> Callable[P, R]:
-        @wraps(fn)
-        def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
-            def fmt(v):
-                if np.isscalar(v):
-                    return v
-                if hasattr(v, "shape"):
-                    return f"{v.__class__.__name__}: shape={getattr(v, 'shape')}"
-                if hasattr(v, "__len__"):
-                    return f"{v.__class__.__name__}: len={len(v)}"
-                return f"{v.__class__.__name__}"
-
-            time = datetime.now(timezone.utc)
-            result = fn(*args, **kwargs)
-            duration = (datetime.now(timezone.utc) - time).total_seconds()
-            fn_params = inspect.signature(fn).parameters
-            # set all params with defaults then update params with mapped arguments and explicit keyword args
-            arguments = {k: None if v.default is inspect.Parameter.empty else v.default for k, v in fn_params.items()}
-            arguments.update(zip(fn_params, args))
-            arguments.update(kwargs)
-            arguments = {k: fmt(v) for k, v in arguments.items()}
-            state = (
-                {k: fmt(getattr(args[0], k)) for k in state_attr if "self" in arguments}
-                if "self" in arguments and state_attr
-                else {}
-            )
-            name = (
-                f"{args[0].__class__.__module__}.{args[0].__class__.__name__}.{fn.__name__}"
-                if "self" in arguments
-                else f"{fn.__module__}.{fn.__qualname__}"
-            )
-            metadata = {
-                "_name": name,
-                "_execution_time": time,
-                "_execution_duration": duration,
-                "_arguments": {k: v for k, v in arguments.items() if k != "self"},
-                "_state": state,
-                "_version": __version__,
-            }
-            for k, v in metadata.items():
-                object.__setattr__(result, k, v)
-            return result
-
-        return wrapper
-
-    return decorator
+R = TypeVar("R", bound=Output)
+
+
+def set_metadata(fn: Callable[P, R] | None = None, *, state: list[str] | None = None) -> Callable[P, R]:
+    """Decorator to stamp Output classes with runtime metadata"""
+
+    if fn is None:
+        return partial(set_metadata, state=state)  # type: ignore
+
+    @wraps(fn)
+    def wrapper(*args: P.args, **kwargs: P.kwargs) -> R:
+        def fmt(v):
+            if np.isscalar(v):
+                return v
+            if hasattr(v, "shape"):
+                return f"{v.__class__.__name__}: shape={getattr(v, 'shape')}"
+            if hasattr(v, "__len__"):
+                return f"{v.__class__.__name__}: len={len(v)}"
+            return f"{v.__class__.__name__}"
+
+        time = datetime.now(timezone.utc)
+        result = fn(*args, **kwargs)
+        duration = (datetime.now(timezone.utc) - time).total_seconds()
+        fn_params = inspect.signature(fn).parameters
+
+        # set all params with defaults then update params with mapped arguments and explicit keyword args
+        arguments = {k: None if v.default is inspect.Parameter.empty else v.default for k, v in fn_params.items()}
+        arguments.update(zip(fn_params, args))
+        arguments.update(kwargs)
+        arguments = {k: fmt(v) for k, v in arguments.items()}
+        state_attrs = (
+            {k: fmt(getattr(args[0], k)) for k in state if "self" in arguments} if "self" in arguments and state else {}
+        )
+        name = (
+            f"{args[0].__class__.__module__}.{args[0].__class__.__name__}.{fn.__name__}"
+            if "self" in arguments
+            else f"{fn.__module__}.{fn.__qualname__}"
+        )
+        metadata = {
+            "_name": name,
+            "_execution_time": time,
+            "_execution_duration": duration,
+            "_arguments": {k: v for k, v in arguments.items() if k != "self"},
+            "_state": state_attrs,
+            "_version": __version__,
+        }
+        for k, v in metadata.items():
+            object.__setattr__(result, k, v)
+        return result
+
+    return wrapper

dataeval/utils/__init__.py

@@ -4,7 +4,7 @@ in setting up architectures that are guaranteed to work with applicable DataEval
 metrics. Currently DataEval supports both :term:`TensorFlow` and PyTorch backends.
 """
 
-from dataeval import _IS_TENSORFLOW_AVAILABLE, _IS_TORCH_AVAILABLE
+from dataeval import _IS_TORCH_AVAILABLE
 from dataeval.utils.metadata import merge_metadata
 from dataeval.utils.split_dataset import split_dataset
 
@@ -15,10 +15,4 @@ if _IS_TORCH_AVAILABLE:
 
     __all__ += ["torch"]
 
-if _IS_TENSORFLOW_AVAILABLE:
-    from dataeval.utils import tensorflow
-
-    __all__ += ["tensorflow"]
-
-del _IS_TENSORFLOW_AVAILABLE
 del _IS_TORCH_AVAILABLE