dataeval 0.69.4__py3-none-any.whl → 0.70.0__py3-none-any.whl

dataeval/_internal/metrics/utils.py

@@ -1,10 +1,10 @@
 from __future__ import annotations
 
-from typing import Any, Callable, Literal, NamedTuple, Sequence
+from typing import Any, Callable, Literal, Mapping, NamedTuple
 
 import numpy as np
 import xxhash as xxh
-from numpy.typing import NDArray
+from numpy.typing import ArrayLike, NDArray
 from PIL import Image
 from scipy.fftpack import dct
 from scipy.signal import convolve2d
@@ -14,6 +14,8 @@ from scipy.spatial.distance import pdist, squareform
 from scipy.stats import entropy as sp_entropy
 from sklearn.neighbors import NearestNeighbors
 
+from dataeval._internal.interop import to_numpy
+
 EPSILON = 1e-5
 EDGE_KERNEL = np.array([[-1, -1, -1], [-1, 8, -1], [-1, -1, -1]], dtype=np.int8)
 BIT_DEPTH = (1, 8, 12, 16, 32)
@@ -162,26 +164,26 @@ def infer_categorical(X: NDArray, threshold: float = 0.2) -> NDArray:
 
 
 def preprocess_metadata(
-    class_labels: Sequence[int], metadata: list[dict], cat_thresh: float = 0.2
+    class_labels: ArrayLike, metadata: Mapping[str, ArrayLike], cat_thresh: float = 0.2
 ) -> tuple[NDArray, list[str], list[bool]]:
-    # convert class_labels and list of metadata dicts to dict of ndarrays
-    metadata_dict: dict[str, NDArray] = {
-        "class_label": np.asarray(class_labels, dtype=int),
-        **{k: np.array([d[k] for d in metadata]) for k in metadata[0]},
-    }
+    # convert class_labels and dict of lists to matrix of metadata values
+    preprocessed_metadata = {"class_label": np.asarray(class_labels, dtype=int)}
 
     # map columns of dict that are not numeric (e.g. string) to numeric values
     # that mutual information and diversity functions can accommodate.  Each
     # unique string receives a unique integer value.
-    for k, v in metadata_dict.items():
+    for k, v in metadata.items():
         # if not numeric
+        v = to_numpy(v)
         if not np.issubdtype(v.dtype, np.number):
             _, mapped_vals = np.unique(v, return_inverse=True)
-            metadata_dict[k] = mapped_vals
+            preprocessed_metadata[k] = mapped_vals
+        else:
+            preprocessed_metadata[k] = v
 
-    data = np.stack(list(metadata_dict.values()), axis=-1)
-    names = list(metadata_dict.keys())
-    is_categorical = [infer_categorical(metadata_dict[var], cat_thresh)[0] for var in names]
+    data = np.stack(list(preprocessed_metadata.values()), axis=-1)
+    names = list(preprocessed_metadata.keys())
+    is_categorical = [infer_categorical(preprocessed_metadata[var], cat_thresh)[0] for var in names]
 
     return data, names, is_categorical
 
@@ -350,6 +352,19 @@ def normalize_image_shape(image: NDArray) -> NDArray:
         raise ValueError("Images must have 2 or more dimensions.")
 
 
+def normalize_box_shape(bounding_box: NDArray) -> NDArray:
+    """
+    Normalizes the bounding box shape into (N,4).
+    """
+    ndim = bounding_box.ndim
+    if ndim == 1:
+        return np.expand_dims(bounding_box, axis=0)
+    elif ndim > 2:
+        raise ValueError("Bounding boxes must have 2 dimensions: (# of boxes in an image, [X,Y,W,H]) -> (N,4)")
+    else:
+        return bounding_box
+
+
 def edge_filter(image: NDArray, offset: float = 0.5) -> NDArray:
     """
     Returns the image filtered using a 3x3 edge detection kernel:

dataeval/_internal/output.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 import inspect
 from datetime import datetime, timezone
 from functools import wraps
+from typing import Any
 
 import numpy as np
 
@@ -17,10 +18,10 @@ class OutputMetadata:
     _state: dict[str, str]
     _version: str
 
-    def dict(self) -> dict:
+    def dict(self) -> dict[str, Any]:
         return {k: v for k, v in self.__dict__.items() if not k.startswith("_")}
 
-    def meta(self) -> dict:
+    def meta(self) -> dict[str, Any]:
         return {k.removeprefix("_"): v for k, v in self.__dict__.items() if k.startswith("_")}
 
 
@@ -67,19 +68,3 @@ def set_metadata(module_name: str = "", state_attr: list[str] | None = None):
         return wrapper
 
     return decorator
-
-
-def populate_defaults(d: dict, c: type) -> dict:
-    def default(t):
-        t = (
-            t if isinstance(t, str) else t._name if hasattr(t, "_name") else t.__name__
-        ).lower()  # py3.9 : _name, py3.10 : __name__
-        if t.startswith("dict"):
-            return {}
-        if t.startswith("list"):
-            return []
-        if t.startswith("ndarray"):
-            return np.array([])
-        raise TypeError("Unrecognized annotation type")
-
-    return {k: d[k] if k in d else default(t) for k, t in c.__annotations__.items()}

dataeval/_internal/workflows/sufficiency.py

@@ -42,6 +42,129 @@ class SufficiencyOutput(OutputMetadata):
             if c != c_v:
                 raise ValueError(f"{m} does not contain the expected number ({c}) of data points.")
 
+    @set_metadata("dataeval.workflows.SufficiencyOutput")
+    def project(
+        self,
+        projection: int | Sequence[int] | NDArray[np.uint],
+    ) -> SufficiencyOutput:
+        """Projects the measures for each value of X
+
+        Parameters
+        ----------
+        projection : int | Sequence[int] | NDArray[np.uint]
+            Step or steps to project
+
+        Returns
+        -------
+        SufficiencyOutput
+            Dataclass containing the projected measures per projection
+
+        Raises
+        ------
+        ValueError
+            If the length of data points in the measures do not match
+            If the steps are not int, Sequence[int] or an ndarray
+        """
+        projection = [projection] if isinstance(projection, int) else projection
+        projection = np.array(projection) if isinstance(projection, Sequence) else projection
+        if not isinstance(projection, np.ndarray):
+            raise ValueError("'steps' must be an int, Sequence[int] or ndarray")
+
+        output = {}
+        for name, measures in self.measures.items():
+            if measures.ndim > 1:
+                result = []
+                for i in range(len(measures)):
+                    projected = project_steps(self.params[name][i], projection)
+                    result.append(projected)
+                output[name] = np.array(result)
+            else:
+                output[name] = project_steps(self.params[name], projection)
+        return SufficiencyOutput(projection, self.params, output)
+
+    def plot(self, class_names: Sequence[str] | None = None) -> list[Figure]:
+        """Plotting function for data sufficiency tasks
+
+        Parameters
+        ----------
+        class_names : Sequence[str] | None, default None
+            List of class names
+
+        Returns
+        -------
+        List[plt.Figure]
+            List of Figures for each measure
+
+        Raises
+        ------
+        ValueError
+            If the length of data points in the measures do not match
+        """
+        # Extrapolation parameters
+        last_X = self.steps[-1]
+        geomshape = (0.01 * last_X, last_X * 4, len(self.steps))
+        extrapolated = np.geomspace(*geomshape).astype(np.int64)
+
+        # Stores all plots
+        plots = []
+
+        # Create a plot for each measure on one figure
+        for name, measures in self.measures.items():
+            if measures.ndim > 1:
+                if class_names is not None and len(measures) != len(class_names):
+                    raise IndexError("Class name count does not align with measures")
+                for i, measure in enumerate(measures):
+                    class_name = str(i) if class_names is None else class_names[i]
+                    fig = plot_measure(
+                        f"{name}_{class_name}",
+                        self.steps,
+                        measure,
+                        self.params[name][i],
+                        extrapolated,
+                    )
+                    plots.append(fig)
+
+            else:
+                fig = plot_measure(name, self.steps, measures, self.params[name], extrapolated)
+                plots.append(fig)
+
+        return plots
+
+    def inv_project(self, targets: dict[str, NDArray]) -> dict[str, NDArray]:
+        """
+        Calculate training samples needed to achieve target model metric values.
+
+        Parameters
+        ----------
+        targets : Dict[str, NDArray]
+            Dictionary of target metric scores (from 0.0 to 1.0) that we want
+            to achieve, where the key is the name of the metric.
+
+        Returns
+        -------
+        Dict[str, NDArray]
+            List of the number of training samples needed to achieve each
+            corresponding entry in targets
+        """
+
+        projection = {}
+
+        for name, target in targets.items():
+            if name not in self.measures:
+                continue
+
+            measure = self.measures[name]
+            if measure.ndim > 1:
+                projection[name] = np.zeros((len(measure), len(target)))
+                for i in range(len(measure)):
+                    projection[name][i] = inv_project_steps(
+                        self.params[name][i], target[i] if target.ndim == measure.ndim else target
+                    )
+            else:
+                projection[name] = inv_project_steps(self.params[name], target)
+
+        return projection
+
 
 def f_out(n_i: NDArray, x: NDArray) -> NDArray:
     """
@@ -421,136 +544,3 @@ class Sufficiency:
         measures = {k: (v / self.runs).T for k, v in measures.items()}
         params_output = get_curve_params(measures, ranges, niter)
         return SufficiencyOutput(ranges, params_output, measures)
-
-    @classmethod
-    def project(
-        cls,
-        data: SufficiencyOutput,
-        projection: int | Sequence[int] | NDArray[np.uint],
-    ) -> SufficiencyOutput:
-        """Projects the measures for each value of X
-
-        Parameters
-        ----------
-        data : SufficiencyOutput
-            Dataclass containing the average of each measure per substep
-        projection : int | Sequence[int] | NDArray[np.uint]
-            Step or steps to project
-
-        Returns
-        -------
-        SufficiencyOutput
-            Dataclass containing the projected measures per projection
-
-        Raises
-        ------
-        ValueError
-            If the length of data points in the measures do not match
-            If the steps are not int, Sequence[int] or an ndarray
-        """
-        projection = [projection] if isinstance(projection, int) else projection
-        projection = np.array(projection) if isinstance(projection, Sequence) else projection
-        if not isinstance(projection, np.ndarray):
-            raise ValueError("'steps' must be an int, Sequence[int] or ndarray")
-
-        output = {}
-        for name, measures in data.measures.items():
-            if measures.ndim > 1:
-                result = []
-                for i in range(len(measures)):
-                    projected = project_steps(data.params[name][i], projection)
-                    result.append(projected)
-                output[name] = np.array(result)
-            else:
-                output[name] = project_steps(data.params[name], projection)
-        return SufficiencyOutput(projection, data.params, output)
-
-    @classmethod
-    def plot(cls, data: SufficiencyOutput, class_names: Sequence[str] | None = None) -> list[Figure]:
-        """Plotting function for data sufficiency tasks
-
-        Parameters
-        ----------
-        data : SufficiencyOutput
-            Dataclass containing the average of each measure per substep
-        class_names : Sequence[str] | None, default None
-            List of class names
-
-        Returns
-        -------
-        List[plt.Figure]
-            List of Figures for each measure
-
-        Raises
-        ------
-        ValueError
-            If the length of data points in the measures do not match
-        """
-        # Extrapolation parameters
-        last_X = data.steps[-1]
-        geomshape = (0.01 * last_X, last_X * 4, len(data.steps))
-        extrapolated = np.geomspace(*geomshape).astype(np.int64)
-
-        # Stores all plots
-        plots = []
-
-        # Create a plot for each measure on one figure
-        for name, measures in data.measures.items():
-            if measures.ndim > 1:
-                if class_names is not None and len(measures) != len(class_names):
-                    raise IndexError("Class name count does not align with measures")
-                for i, measure in enumerate(measures):
-                    class_name = str(i) if class_names is None else class_names[i]
-                    fig = plot_measure(
-                        f"{name}_{class_name}",
-                        data.steps,
-                        measure,
-                        data.params[name][i],
-                        extrapolated,
-                    )
-                    plots.append(fig)
-
-            else:
-                fig = plot_measure(name, data.steps, measures, data.params[name], extrapolated)
-                plots.append(fig)
-
-        return plots
-
-    @classmethod
-    def inv_project(cls, targets: dict[str, NDArray], data: SufficiencyOutput) -> dict[str, NDArray]:
-        """
-        Calculate training samples needed to achieve target model metric values.
-
-        Parameters
-        ----------
-        targets : Dict[str, NDArray]
-            Dictionary of target metric scores (from 0.0 to 1.0) that we want
-            to achieve, where the key is the name of the metric.
-
-        data : SufficiencyOutput
-            Dataclass containing the average of each measure per substep
-
-        Returns
-        -------
-        Dict[str, NDArray]
-            List of the number of training samples needed to achieve each
-            corresponding entry in targets
-        """
-
-        projection = {}
-
-        for name, target in targets.items():
-            if name not in data.measures:
-                continue
-
-            measure = data.measures[name]
-            if measure.ndim > 1:
-                projection[name] = np.zeros((len(measure), len(target)))
-                for i in range(len(measure)):
-                    projection[name][i] = inv_project_steps(
-                        data.params[name][i], target[i] if target.ndim == measure.ndim else target
-                    )
-            else:
-                projection[name] = inv_project_steps(data.params[name], target)
-
-        return projection

dataeval/metrics/stats/__init__.py

@@ -1,6 +1,17 @@
-from dataeval._internal.metrics.stats import channelstats, imagestats
+from dataeval._internal.metrics.stats.boxratiostats import boxratiostats
+from dataeval._internal.metrics.stats.datasetstats import datasetstats
+from dataeval._internal.metrics.stats.dimensionstats import dimensionstats
+from dataeval._internal.metrics.stats.hashstats import hashstats
+from dataeval._internal.metrics.stats.labelstats import labelstats
+from dataeval._internal.metrics.stats.pixelstats import pixelstats
+from dataeval._internal.metrics.stats.visualstats import visualstats
 
 __all__ = [
-    "channelstats",
-    "imagestats",
+    "boxratiostats",
+    "datasetstats",
+    "dimensionstats",
+    "hashstats",
+    "labelstats",
+    "pixelstats",
+    "visualstats",
 ]

dataeval/workflows/__init__.py

@@ -1,6 +1,6 @@
 from dataeval import _IS_TORCH_AVAILABLE
 
 if _IS_TORCH_AVAILABLE:  # pragma: no cover
-    from dataeval._internal.workflows.sufficiency import Sufficiency
+    from dataeval._internal.workflows.sufficiency import Sufficiency, SufficiencyOutput
 
-    __all__ = ["Sufficiency"]
+    __all__ = ["Sufficiency", "SufficiencyOutput"]

{dataeval-0.69.4.dist-info → dataeval-0.70.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dataeval
-Version: 0.69.4
+Version: 0.70.0
 Summary: DataEval provides a simple interface to characterize image data and its impact on model performance across classification and object-detection tasks
 Home-page: https://dataeval.ai/
 License: MIT
@@ -32,8 +32,8 @@ Requires-Dist: scipy (>=1.10)
 Requires-Dist: tensorflow (>=2.14.1,<2.16) ; extra == "tensorflow" or extra == "all"
 Requires-Dist: tensorflow-io-gcs-filesystem (>=0.35.0,<0.37) ; extra == "tensorflow" or extra == "all"
 Requires-Dist: tensorflow_probability (>=0.22.1,<0.24) ; extra == "tensorflow" or extra == "all"
-Requires-Dist: torch (>=2.0.1,!=2.2.0) ; extra == "torch" or extra == "all"
-Requires-Dist: torchvision (>=0.16.0) ; extra == "torch" or extra == "all"
+Requires-Dist: torch (>=2.2.0) ; extra == "torch" or extra == "all"
+Requires-Dist: torchvision (>=0.17.0) ; extra == "torch" or extra == "all"
 Requires-Dist: xxhash (>=3.3)
 Project-URL: Documentation, https://dataeval.readthedocs.io/
 Project-URL: Repository, https://github.com/aria-ml/dataeval/

{dataeval-0.69.4.dist-info → dataeval-0.70.0.dist-info}/RECORD

@@ -1,36 +1,42 @@
-dataeval/__init__.py,sha256=KOZnb9SovSSuD2UrqV-NS_b5vpfWdQlsweB55fned58,590
+dataeval/__init__.py,sha256=rWQRN8WyjzjUUZhNkCFFySptSFPM4f67tabVBDly84k,574
 dataeval/_internal/datasets.py,sha256=MwN6xgZW1cA5yIxXZ05qBBz4aO3bjKzIEbZZfa1HkQo,9790
 dataeval/_internal/detectors/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dataeval/_internal/detectors/clusterer.py,sha256=hJwELUeAdZZ3OVLIfwalw2P7Zz13q2ZqrV6gx90s44E,20695
 dataeval/_internal/detectors/drift/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dataeval/_internal/detectors/drift/base.py,sha256=XSX1VVUxvFFKVFQVsc2WWeaRRmIxuYaIgD_c5H4OraA,15930
+dataeval/_internal/detectors/drift/base.py,sha256=6L66aGWUGAbWylT_aHmZUSrvx6wM6Fzzlcie98KdNiY,15900
 dataeval/_internal/detectors/drift/cvm.py,sha256=xiyZlf0rAQGG8Z6ZBLPVri805aPRkERrUySwRN8cTZQ,4010
 dataeval/_internal/detectors/drift/ks.py,sha256=aoDx7ps-5vrSI8Q9ii6cwmKnAyaD8tjG69wI-7R3MVQ,4098
-dataeval/_internal/detectors/drift/mmd.py,sha256=j85bwzCiFLNS27WlUFlgpHDMD9yga41ILt-yAr-LABc,7493
+dataeval/_internal/detectors/drift/mmd.py,sha256=0TD0BpIJkwdjU0i3ndlvYp1ItCNrvSO7gT8r4bEdHXc,7493
 dataeval/_internal/detectors/drift/torch.py,sha256=YhIN85MbUV3C4IJcRvqYdXSWLj5lUeEOb05T5DgB3xo,11552
 dataeval/_internal/detectors/drift/uncertainty.py,sha256=Ot8L42AnFbkij4J3Tis7VzXLv3hfBxoOWBP4UoCEnVs,5125
-dataeval/_internal/detectors/duplicates.py,sha256=qkzbdWuJuUozFLqpnD6CYAGXQb7-aWw2mHr_cxXAfPo,4922
-dataeval/_internal/detectors/merged_stats.py,sha256=WVPxz7n5fUkFKW3kobD_TkKkof51YjfIz4M_4CHh-1s,2517
+dataeval/_internal/detectors/duplicates.py,sha256=VLDEhXWhdNyU3aA6S7dQmCBDAz0uQY5E_RjJYE1wkcw,5268
+dataeval/_internal/detectors/merged_stats.py,sha256=okXGrqAgsqfANMxfIjiUQlZWlaIh5TVvIB9UPsOJZ7k,1351
 dataeval/_internal/detectors/ood/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dataeval/_internal/detectors/ood/ae.py,sha256=k8pZP7oPwVyQlv6YcoacNMzpmQZy7W222yYrdXGTYZI,2031
+dataeval/_internal/detectors/ood/ae.py,sha256=-nFw3taJ2IWU74o8Yks48J2x7aBoxXeL1vP_Ye_60M4,2031
 dataeval/_internal/detectors/ood/aegmm.py,sha256=pffThqXRoLx3GuZXEQBd-xEy5DjAZHV7WSeP2HgM_TI,2403
 dataeval/_internal/detectors/ood/base.py,sha256=Pw34uFEWOJZiG4ciM0ArUkqhiM8WCGl2rc0BwFPu3xM,8240
 dataeval/_internal/detectors/ood/llr.py,sha256=tCo8G7V8VaVuIZ09rg0ZXZmdE0N_zGm7vCfFUnGbGvo,10102
 dataeval/_internal/detectors/ood/vae.py,sha256=WbQugS-bBUTTqQ9PRLHBmSUtk7O2_PN4PBLJE9ieMjw,2921
 dataeval/_internal/detectors/ood/vaegmm.py,sha256=pVUSlVF2jo8uokyks2QzfBJnNtcFWmcF8EQl-azs2Bg,2832
-dataeval/_internal/detectors/outliers.py,sha256=oS8lsCPIM6WtLzUjpMZDfiopZA2fJhsHakmSzZUhqHU,7614
-dataeval/_internal/flags.py,sha256=5hZ5AHXjXRKbWtFC45-J7M9NvJHsT4LKRsPzPMksgfQ,2323
-dataeval/_internal/interop.py,sha256=x4qj4EiBt5NthSxe8prSLrPDAEcipAdyyLwbNyCBaFk,1059
+dataeval/_internal/detectors/outliers.py,sha256=du4Kd5XrrBlBXyno8K5COkNKP0ByQnGRSsfaTq4ywm0,10345
+dataeval/_internal/interop.py,sha256=FLXJY-5hwJcKCtruyvaarqynXCMfcLbQSFvGnrWQDPo,1338
 dataeval/_internal/metrics/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dataeval/_internal/metrics/balance.py,sha256=eAHvgjiGCH893XSQLqh9j9wgvAECoNPVT8k0u_9Ijzg,6097
-dataeval/_internal/metrics/ber.py,sha256=Onsi47AbT9rMvng-Pbu8LIrYRfLpI13En1FxkFoMKQs,4668
+dataeval/_internal/metrics/balance.py,sha256=veAeFFmbyDLW6VlQ-NrLfJbQl0AOA3hFD239NSej078,6134
+dataeval/_internal/metrics/ber.py,sha256=MUpYivU-klsg2019YLyeV9aWDEGyXhcqYg05Vg_pffk,4668
 dataeval/_internal/metrics/coverage.py,sha256=EZVES1rbZW2j_CtQv1VFfSO-UmWcrt5nmqxDErtrG14,3473
-dataeval/_internal/metrics/divergence.py,sha256=nmMUfr9FGnH798eb6xzEiMj4C42rQVthh5HeexiY6EE,4119
-dataeval/_internal/metrics/diversity.py,sha256=_oT0FHsgfLOoe_TLD2Aax4r4jmH6WnOPVIkcl_YjaoY,7582
-dataeval/_internal/metrics/parity.py,sha256=VszQNbHWjct2bCqrIXUZC_qFi4ZIq2Lm-vs-DiarBFo,16244
-dataeval/_internal/metrics/stats.py,sha256=ILKteVMGjrp1s2CECPL_hbLsijIKR2d6II2-8w9oxW8,18105
-dataeval/_internal/metrics/uap.py,sha256=w-wvXXnX16kUq-weaZD2SrJi22LJ8EjOFbOhPxeGejI,2043
-dataeval/_internal/metrics/utils.py,sha256=mSYa-3cHGcsQwPr7zbdpzrnK_8jIXCiAcu2HCcvrtaY,13007
+dataeval/_internal/metrics/divergence.py,sha256=WTQ1Xx453DH8aCpEmN1Zn6zuCy7NnsHfVphvTYA0L_o,4119
+dataeval/_internal/metrics/diversity.py,sha256=Us0Nww3wvDH0kvVhDd3KEGXbkY_4-XxmD-ew9fFhqag,7618
+dataeval/_internal/metrics/parity.py,sha256=TRm4GObItaku3OvxJj1vfxE1fGpwW_N020Nqfs-uFBw,16458
+dataeval/_internal/metrics/stats/base.py,sha256=dgXAuuFYK0vrl3VPmU5BhjThRBHD6ykE_M2uyCuKDl4,8556
+dataeval/_internal/metrics/stats/boxratiostats.py,sha256=Ac6nB41q43xHCJRDEXHNgsJF80VE8MpH8_kySxA84BE,6342
+dataeval/_internal/metrics/stats/datasetstats.py,sha256=zJnBzIthaJPbQFvE0RRx-KvvU0Du7ZSvERW56zeowBU,3703
+dataeval/_internal/metrics/stats/dimensionstats.py,sha256=RYI8PbiCtlPdli1z4jJ4t05ddDszB9dsnKDJfidaK-c,3789
+dataeval/_internal/metrics/stats/hashstats.py,sha256=3PUPPmHe2t8VIgfmu9hkyMq7zvxmcdXdLtEqQJvHs5M,2034
+dataeval/_internal/metrics/stats/labelstats.py,sha256=LTvQTqCnKVOx3ufmHAZIQOI9xYhIoZS-1TAgEjKhYC0,4056
+dataeval/_internal/metrics/stats/pixelstats.py,sha256=cSOjJ2yTaH_nWd4jqiu96wA39HmU3GkIs1XY2MW4mSw,4367
+dataeval/_internal/metrics/stats/visualstats.py,sha256=4tIkFE2LNxYEyseb5Lj7BmgueFCwHbwA2JJ9-YsA9QI,4659
+dataeval/_internal/metrics/uap.py,sha256=EhyEjYtWs1RiXlVrvvGI4gEcMygpu8QHUeOHxfceacY,2043
+dataeval/_internal/metrics/utils.py,sha256=P3KOybaorAD8Zu4j-3jygKEJld5rwQlgqxMljbVk1Oo,13477
 dataeval/_internal/models/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dataeval/_internal/models/pytorch/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dataeval/_internal/models/pytorch/autoencoder.py,sha256=gmnAHUzzn-fXTUU63SR4ZBjGBLEALWPxmZ_wPzvF_dg,8365
@@ -43,21 +49,20 @@ dataeval/_internal/models/tensorflow/losses.py,sha256=pZH5RnlM9R0RrBde9Lgq32muwA
 dataeval/_internal/models/tensorflow/pixelcnn.py,sha256=lRpRNebMgkCJUnEk1xouVaTfS_YGMQgQhI01wNKAjeM,48420
 dataeval/_internal/models/tensorflow/trainer.py,sha256=xNY0Iw7Qa1TnCuy9N1b77_VduFoW_BhbZjfQCxOVby4,4082
 dataeval/_internal/models/tensorflow/utils.py,sha256=l6jXKMWyQAEI4LpAONq95Xwr7CPgrs408ypf9TuNxkY,8732
-dataeval/_internal/output.py,sha256=bFC2qJxXUc_daQwJHHa9KfFNLuxZANGb7Dpget_TXYs,3049
+dataeval/_internal/output.py,sha256=qVbOi41dvfQICQ4uxysHPWBRKo1XR61kXHPL_vKOPm0,2545
 dataeval/_internal/utils.py,sha256=gK0z4buuQoUYblkrCiRV9pIESzyikcY-3a08XsQkD7E,1585
 dataeval/_internal/workflows/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-dataeval/_internal/workflows/sufficiency.py,sha256=0k7Dbk3QmEGkZp2IW4OcZBcrxb4zAp9hC9nXGN1v1cY,18199
+dataeval/_internal/workflows/sufficiency.py,sha256=jLGfp-d0plfV-M8j7W4W71yNjEMutrVzN7pMA9qLHD0,17807
 dataeval/detectors/__init__.py,sha256=WVlwapZtKXVvrW41Sq30sFd8j2phS8JMsCaLeXfbQ7k,204
 dataeval/detectors/drift/__init__.py,sha256=XtSjoTy6P_lwRzC9Klmd9BYZ3v4qZrATJ-p7gvvHPGk,598
 dataeval/detectors/drift/kernels/__init__.py,sha256=qV_r740iRPw39_kHOttmk3VNikDFKCvF9i1IGbgjf3A,186
 dataeval/detectors/drift/updates/__init__.py,sha256=uwkRV-4WVg0XFX_9futvQ0ggGOEvduDedgCno_eIi4U,149
 dataeval/detectors/linters/__init__.py,sha256=1yxsJw8CFpHsZwn_YUlWpb-4YBet5U6uB--MeRgB6io,234
 dataeval/detectors/ood/__init__.py,sha256=ybWhwbMmWygIwE1A-nYihDfugrj3j0GiuABmVvD7264,583
-dataeval/flags/__init__.py,sha256=qo06_Tk0ul4lOhKSEs0HE2G6WBFvMwNJq77vRX1ynww,72
 dataeval/metrics/__init__.py,sha256=42szGyZrLekNU-T-rwJu-pUoDBdOoStuScB-mnGzjw4,81
 dataeval/metrics/bias/__init__.py,sha256=xqpxCttgzz-hMZQI7_IlaNn4OGZaGVz3KKRd26GbSKE,335
 dataeval/metrics/estimators/__init__.py,sha256=fWQZUIxu88u5POYXN1yoFc-Hxx5B1fveEiiSXmK5kPk,210
-dataeval/metrics/stats/__init__.py,sha256=N5UvO7reDkYX1xFdAQjwALyJwcC2FAbruzd7ZYYW_4I,123
+dataeval/metrics/stats/__init__.py,sha256=HqorGcA6GSlvLnYALnKduXzJzQo2GPMVpdirXNWB2pY,637
 dataeval/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 dataeval/tensorflow/__init__.py,sha256=IH_ELFP9CwKPk_br8_dKi6HeAlwmmV2vgsWdD8IFKXU,72
 dataeval/tensorflow/loss/__init__.py,sha256=E9eB87LNh0o5nUCqssB027EXBsOfEayNHPcNW0QGFdA,101
@@ -67,8 +72,8 @@ dataeval/torch/__init__.py,sha256=ZNGSJJmatdGzbrazw86yNveEXm8smmW63xD-ReA8Nfg,63
 dataeval/torch/models/__init__.py,sha256=YnDnePYpRIKHyYn3F5qR1OObMSb-g0FGvI8X-uTB09E,162
 dataeval/torch/trainer/__init__.py,sha256=Te-qElt8h-Zv8NN0r-VJOEdCPHTQ2yO3rd2MhRiZGZs,93
 dataeval/utils/__init__.py,sha256=ExQ1xj62MjcM9uIu1-g1P2fW0EPJpcIofnvxjQ908c4,172
-dataeval/workflows/__init__.py,sha256=gkU2B6yUiefexcYrBwqfZKNl8BvX8abUjfeNvVBXF4E,186
-dataeval-0.69.4.dist-info/LICENSE.txt,sha256=Kpzcfobf1HlqafF-EX6dQLw9TlJiaJzfgvLQFukyXYw,1060
-dataeval-0.69.4.dist-info/METADATA,sha256=R_YlthIsAkOizGWkgXiOCEsD_6F5wJm8qjU4hjhL_c8,4292
-dataeval-0.69.4.dist-info/WHEEL,sha256=sP946D7jFCHeNz5Iq4fL4Lu-PrWrFsgfLXbbkciIZwg,88
-dataeval-0.69.4.dist-info/RECORD,,
+dataeval/workflows/__init__.py,sha256=Yl6YYgHFwUM1porR3yT6ELyoUw5Op9e6QpQACdXoKBU,226
+dataeval-0.70.0.dist-info/LICENSE.txt,sha256=Kpzcfobf1HlqafF-EX6dQLw9TlJiaJzfgvLQFukyXYw,1060
+dataeval-0.70.0.dist-info/METADATA,sha256=qdgzLlvHmmQNTQqUVkPcaCZJL9QlxUbzPipHcIaSFsI,4284
+dataeval-0.70.0.dist-info/WHEEL,sha256=Nq82e9rUAnEjt98J6MlVmMCZb-t9cYE2Ir1kpBmnWfs,88
+dataeval-0.70.0.dist-info/RECORD,,

{dataeval-0.69.4.dist-info → dataeval-0.70.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: poetry-core 1.9.0
+Generator: poetry-core 1.9.1
 Root-Is-Purelib: true
 Tag: py3-none-any

dataeval/_internal/flags.py

@@ -1,77 +0,0 @@
-from __future__ import annotations
-
-from enum import IntFlag, auto
-from functools import reduce
-from typing import Iterable, TypeVar, cast
-
-TFlag = TypeVar("TFlag", bound=IntFlag)
-
-
-class ImageStat(IntFlag):
-    """
-    Flags for calculating image and channel statistics
-    """
-
-    # HASHES
-    XXHASH = auto()
-    PCHASH = auto()
-
-    # PROPERTIES
-    WIDTH = auto()
-    HEIGHT = auto()
-    SIZE = auto()
-    ASPECT_RATIO = auto()
-    CHANNELS = auto()
-    DEPTH = auto()
-
-    # VISUALS
-    BRIGHTNESS = auto()
-    BLURRINESS = auto()
-    CONTRAST = auto()
-    DARKNESS = auto()
-    MISSING = auto()
-    ZEROS = auto()
-
-    # PIXEL STATS
-    MEAN = auto()
-    STD = auto()
-    VAR = auto()
-    SKEW = auto()
-    KURTOSIS = auto()
-    ENTROPY = auto()
-    PERCENTILES = auto()
-    HISTOGRAM = auto()
-
-    # JOINT FLAGS
-    ALL_HASHES = XXHASH | PCHASH
-    ALL_PROPERTIES = WIDTH | HEIGHT | SIZE | ASPECT_RATIO | CHANNELS | DEPTH
-    ALL_VISUALS = BRIGHTNESS | BLURRINESS | CONTRAST | DARKNESS | MISSING | ZEROS
-    ALL_PIXELSTATS = MEAN | STD | VAR | SKEW | KURTOSIS | ENTROPY | PERCENTILES | HISTOGRAM
-    ALL_CHANNEL_STATS = BRIGHTNESS | CONTRAST | DARKNESS | ZEROS | ALL_PIXELSTATS
-    ALL_STATS = ALL_PROPERTIES | ALL_VISUALS | ALL_PIXELSTATS
-    ALL = ALL_HASHES | ALL_STATS
-
-
-def is_distinct(flag: IntFlag) -> bool:
-    return (flag & (flag - 1) == 0) and flag != 0
-
-
-def to_distinct(flag: TFlag) -> dict[TFlag, str]:
-    """
-    Returns a distinct set of all flags set on the input flag and their names
-
-    NOTE: this is supported natively in Python 3.11, but for earlier versions we need
-    to use a combination of list comprehension and bit fiddling to determine distinct
-    flag values from joint aliases.
-    """
-    if isinstance(flag, Iterable):  # >= py311
-        return {f: f.name.lower() for f in flag if f.name}
-    else:  # < py311
-        return {f: f.name.lower() for f in list(flag.__class__) if f & flag and is_distinct(f) and f.name}
-
-
-def verify_supported(flag: TFlag, flags: TFlag | Iterable[TFlag]):
-    supported = flags if isinstance(flags, flag.__class__) else cast(TFlag, reduce(lambda a, b: a | b, flags))  # type: ignore
-    unsupported = flag & ~supported
-    if unsupported:
-        raise ValueError(f"Unsupported flags {unsupported} called.  Only {supported} flags are supported.")