dataeval 0.65.0__py3-none-any.whl → 0.66.0__py3-none-any.whl

dataeval/_internal/models/tensorflow/utils.py

@@ -6,8 +6,10 @@ Original code Copyright (c) 2023 Seldon Technologies Ltd
 Licensed under Apache Software License (Apache 2.0)
 """
 
+from __future__ import annotations
+
 import math
-from typing import Callable, Optional, Tuple, Type, Union, cast
+from typing import Callable, Union, cast
 
 import keras as keras
 import numpy as np
@@ -29,12 +31,12 @@ from dataeval._internal.models.tensorflow.pixelcnn import PixelCNN
 
 
 def predict_batch(
-    x: Union[list, NDArray, tf.Tensor],
-    model: Union[Callable, keras.Model],
+    x: list | NDArray | tf.Tensor,
+    model: Callable | keras.Model,
     batch_size: int = int(1e10),
-    preprocess_fn: Optional[Callable] = None,
-    dtype: Union[Type[np.generic], tf.DType] = np.float32,
-) -> Union[NDArray, tf.Tensor, tuple, list]:
+    preprocess_fn: Callable | None = None,
+    dtype: type[np.generic] | tf.DType = np.float32,
+) -> NDArray | tf.Tensor | tuple | list:
     """
     Make batch predictions on a model.
 
@@ -59,7 +61,7 @@ def predict_batch(
     n_minibatch = int(np.ceil(n / batch_size))
     return_np = not isinstance(dtype, tf.DType)
     return_list = False
-    preds: Union[list, tuple] = []
+    preds: list | tuple = []
     for i in range(n_minibatch):
         istart, istop = i * batch_size, min((i + 1) * batch_size, n)
         x_batch = x[istart:istop]  # type: ignore
@@ -93,7 +95,7 @@ def predict_batch(
     return out
 
 
-def _get_default_encoder_net(input_shape: Tuple[int, int, int], encoding_dim: int):
+def _get_default_encoder_net(input_shape: tuple[int, int, int], encoding_dim: int):
     return Sequential(
         [
             InputLayer(input_shape=input_shape),
@@ -106,7 +108,7 @@ def _get_default_encoder_net(input_shape: Tuple[int, int, int], encoding_dim: in
     )
 
 
-def _get_default_decoder_net(input_shape: Tuple[int, int, int], encoding_dim: int):
+def _get_default_decoder_net(input_shape: tuple[int, int, int], encoding_dim: int):
     return Sequential(
         [
             InputLayer(input_shape=(encoding_dim,)),
@@ -122,26 +124,26 @@ def _get_default_decoder_net(input_shape: Tuple[int, int, int], encoding_dim: in
 
 
 def create_model(
-    model_type: Union[AE, AEGMM, PixelCNN, VAE, VAEGMM],
-    input_shape: Tuple[int, int, int],
-    encoding_dim: Optional[int] = None,
-    n_gmm: Optional[int] = None,
-    gmm_latent_dim: Optional[int] = None,
+    model_type: AE | AEGMM | PixelCNN | VAE | VAEGMM,
+    input_shape: tuple[int, int, int],
+    encoding_dim: int | None = None,
+    n_gmm: int | None = None,
+    gmm_latent_dim: int | None = None,
 ):
     """
     Create a default model for the specified model type.
 
     Parameters
     ----------
-    model_type
+    model_type : Union[AE, AEGMM, PixelCNN, VAE, VAEGMM]
         The model type to create.
-    input_shape
+    input_shape : Tuple[int, int, int]
         The input shape of the data used.
-    encoding_dim
+    encoding_dim : int, optional - default None
         The target encoding dimensionality.
-    n_gmm
+    n_gmm : int, optional - default None
         Number of components used in the GMM layer.
-    gmm_latent_dim
+    gmm_latent_dim : int, optional - default None
         Latent dimensionality of the GMM layer.
     """
     input_dim = math.prod(input_shape)

dataeval/_internal/output.py

@@ -1,7 +1,8 @@
+from __future__ import annotations
+
 import inspect
 from datetime import datetime, timezone
 from functools import wraps
-from typing import Dict, List, Optional
 
 import numpy as np
 
@@ -12,18 +13,18 @@ class OutputMetadata:
     _name: str
     _execution_time: str
     _execution_duration: float
-    _arguments: Dict[str, str]
-    _state: Dict[str, str]
+    _arguments: dict[str, str]
+    _state: dict[str, str]
     _version: str
 
-    def dict(self) -> Dict:
+    def dict(self) -> dict:
         return {k: v for k, v in self.__dict__.items() if not k.startswith("_")}
 
-    def meta(self) -> Dict:
+    def meta(self) -> dict:
         return {k.removeprefix("_"): v for k, v in self.__dict__.items() if k.startswith("_")}
 
 
-def set_metadata(module_name: str = "", state_attr: Optional[List[str]] = None):
+def set_metadata(module_name: str = "", state_attr: list[str] | None = None):
     def decorator(fn):
         @wraps(fn)
         def wrapper(*args, **kwargs):
@@ -70,12 +71,14 @@ def set_metadata(module_name: str = "", state_attr: Optional[List[str]] = None):
 
 def populate_defaults(d: dict, c: type) -> dict:
     def default(t):
-        name = t._name if hasattr(t, "_name") else t.__name__  # py3.9 : _name, py3.10 : __name__
-        if name == "Dict":
+        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 name == "List":
+        if t.startswith("list"):
             return []
-        if name == "ndarray":
+        if t.startswith("ndarray"):
             return np.array([])
         raise TypeError("Unrecognized annotation type")
 

dataeval/_internal/utils.py

@@ -1,10 +1,12 @@
+from __future__ import annotations
+
 from collections import defaultdict
-from typing import Any, Dict, List
+from typing import Any
 
 from torch.utils.data import Dataset
 
 
-def read_dataset(dataset: Dataset) -> List[List[Any]]:
+def read_dataset(dataset: Dataset) -> list[list[Any]]:
     """
     Extract information from a dataset at each index into a individual lists of each information position
 
@@ -51,7 +53,7 @@ def read_dataset(dataset: Dataset) -> List[List[Any]]:
     True
     """
 
-    ddict: Dict[int, List] = defaultdict(list)
+    ddict: dict[int, list] = defaultdict(list)
 
     for data in dataset:
         # Convert to tuple if single return (e.g. images only)

dataeval/_internal/workflows/sufficiency.py

@@ -1,6 +1,8 @@
+from __future__ import annotations
+
 import warnings
 from dataclasses import dataclass
-from typing import Any, Callable, Dict, List, Optional, Sequence, Union, cast
+from typing import Any, Callable, Sequence, cast
 
 import matplotlib.pyplot as plt
 import numpy as np
@@ -19,17 +21,17 @@ class SufficiencyOutput(OutputMetadata):
     """
     Attributes
     ----------
-    steps : NDArray[np.uint32]
+    steps : NDArray
         Array of sample sizes
-    params : Dict[str, NDArray[np.float64]]
+    params : Dict[str, NDArray]
         Inverse power curve coefficients for the line of best fit for each measure
-    measures : Dict[str, NDArray[np.float64]]
+    measures : Dict[str, NDArray]
         Average of values observed for each sample size step for each measure
     """
 
     steps: NDArray[np.uint32]
-    params: Dict[str, NDArray[np.float64]]
-    measures: Dict[str, NDArray[np.float64]]
+    params: dict[str, NDArray[np.float64]]
+    measures: dict[str, NDArray[np.float64]]
 
     def __post_init__(self):
         c = len(self.steps)
@@ -73,7 +75,7 @@ def f_inv_out(y_i: NDArray, x: NDArray) -> NDArray[np.uint64]:
 
     Returns
     -------
-    NDArray[np.uint64]
+    NDArray
         Array of sample sizes
     """
     n_i = ((y_i - x[2]) / x[0]) ** (-1 / x[1])
@@ -183,7 +185,7 @@ def inv_project_steps(params: NDArray, targets: NDArray) -> NDArray[np.uint64]:
 
     Returns
     -------
-    NDArray[np.uint64]
+    NDArray
         Array of sample sizes, or 0 if overflow
     """
     steps = f_inv_out(1 - np.array(targets), params)
@@ -191,7 +193,7 @@ def inv_project_steps(params: NDArray, targets: NDArray) -> NDArray[np.uint64]:
     return np.ceil(steps)
 
 
-def get_curve_params(measures: Dict[str, NDArray], ranges: NDArray, niter: int) -> Dict[str, NDArray]:
+def get_curve_params(measures: dict[str, NDArray], ranges: NDArray, niter: int) -> dict[str, NDArray]:
     """Calculates and aggregates parameters for both single and multi-class metrics"""
     output = {}
     for name, measure in measures.items():
@@ -246,15 +248,15 @@ class Sufficiency:
     ----------
     model : nn.Module
         Model that will be trained for each subset of data
-    train_ds : Dataset
+    train_ds : torch.Dataset
         Full training data that will be split for each run
-    test_ds : Dataset
+    test_ds : torch.Dataset
         Data that will be used for every run's evaluation
     train_fn : Callable[[nn.Module, Dataset, Sequence[int]], None]
         Function which takes a model (torch.nn.Module), a dataset
         (torch.utils.data.Dataset), indices to train on and executes model
         training against the data.
-    eval_fn : Callable[[nn.Module, Dataset], Dict[str, float]]
+    eval_fn : Callable[[nn.Module, Dataset], Dict[str, float | NDArray]]
         Function which takes a model (torch.nn.Module), a dataset
         (torch.utils.data.Dataset) and returns a dictionary of metric
         values (Dict[str, float]) which is used to assess model performance
@@ -263,9 +265,9 @@ class Sufficiency:
         Number of models to run over all subsets
     substeps : int, default 5
         Total number of dataset partitions that each model will train on
-    train_kwargs : Dict[str, Any] | None, default None
+    train_kwargs : Dict | None, default None
         Additional arguments required for custom training function
-    eval_kwargs : Dict[str, Any] | None, default None
+    eval_kwargs : Dict | None, default None
         Additional arguments required for custom evaluation function
     """
 
@@ -275,11 +277,11 @@ class Sufficiency:
         train_ds: Dataset,
         test_ds: Dataset,
         train_fn: Callable[[nn.Module, Dataset, Sequence[int]], None],
-        eval_fn: Callable[[nn.Module, Dataset], Union[Dict[str, float], Dict[str, NDArray]]],
+        eval_fn: Callable[[nn.Module, Dataset], dict[str, float] | dict[str, NDArray]],
         runs: int = 1,
         substeps: int = 5,
-        train_kwargs: Optional[Dict[str, Any]] = None,
-        eval_kwargs: Optional[Dict[str, Any]] = None,
+        train_kwargs: dict[str, Any] | None = None,
+        eval_kwargs: dict[str, Any] | None = None,
     ):
         self.model = model
         self.train_ds = train_ds
@@ -322,42 +324,42 @@ class Sufficiency:
     @property
     def eval_fn(
         self,
-    ) -> Callable[[nn.Module, Dataset], Union[Dict[str, float], Dict[str, NDArray]]]:
+    ) -> Callable[[nn.Module, Dataset], dict[str, float] | dict[str, NDArray]]:
         return self._eval_fn
 
     @eval_fn.setter
     def eval_fn(
         self,
-        value: Callable[[nn.Module, Dataset], Union[Dict[str, float], Dict[str, NDArray]]],
+        value: Callable[[nn.Module, Dataset], dict[str, float] | dict[str, NDArray]],
     ):
         if not callable(value):
             raise TypeError("Must provide a callable for eval_fn.")
         self._eval_fn = value
 
     @property
-    def train_kwargs(self) -> Dict[str, Any]:
+    def train_kwargs(self) -> dict[str, Any]:
         return self._train_kwargs
 
     @train_kwargs.setter
-    def train_kwargs(self, value: Optional[Dict[str, Any]]):
+    def train_kwargs(self, value: dict[str, Any] | None):
         self._train_kwargs = {} if value is None else value
 
     @property
-    def eval_kwargs(self) -> Dict[str, Any]:
+    def eval_kwargs(self) -> dict[str, Any]:
         return self._eval_kwargs
 
     @eval_kwargs.setter
-    def eval_kwargs(self, value: Optional[Dict[str, Any]]):
+    def eval_kwargs(self, value: dict[str, Any] | None):
         self._eval_kwargs = {} if value is None else value
 
     @set_metadata("dataeval.workflows", ["runs", "substeps"])
-    def evaluate(self, eval_at: Optional[NDArray] = None, niter: int = 1000) -> SufficiencyOutput:
+    def evaluate(self, eval_at: NDArray | None = None, niter: int = 1000) -> SufficiencyOutput:
         """
         Creates data indices, trains models, and returns plotting data
 
         Parameters
         ----------
-        eval_at : Optional[NDArray]
+        eval_at : NDArray | None, default None
             Specify this to collect accuracies over a specific set of dataset lengths, rather
             than letting Sufficiency internally create the lengths to evaluate at.
         niter : int, default 1000
@@ -367,7 +369,15 @@ class Sufficiency:
         -------
         SufficiencyOutput
             Dataclass containing the average of each measure per substep
-        """
+
+        Examples
+        --------
+        >>> suff = Sufficiency(
+        ...     model=model, train_ds=train_ds, test_ds=test_ds, train_fn=train_fn, eval_fn=eval_fn, runs=3, substeps=5
+        ... )
+        >>> suff.evaluate()
+        SufficiencyOutput(steps=array([  1,   3,  10,  31, 100], dtype=uint32), params={'test': array([ 0., 42.,  0.])}, measures={'test': array([1., 1., 1., 1., 1.])})
+        """  # noqa: E501
         if eval_at is not None:
             ranges = eval_at
         else:
@@ -416,7 +426,7 @@ class Sufficiency:
     def project(
         cls,
         data: SufficiencyOutput,
-        projection: Union[int, Sequence[int], NDArray[np.uint]],
+        projection: int | Sequence[int] | NDArray[np.uint],
     ) -> SufficiencyOutput:
         """Projects the measures for each value of X
 
@@ -424,7 +434,7 @@ class Sufficiency:
         ----------
         data : SufficiencyOutput
             Dataclass containing the average of each measure per substep
-        projection : Union[int, Sequence[int], NDArray[np.uint]]
+        projection : int | Sequence[int] | NDArray[np.uint]
             Step or steps to project
 
         Returns
@@ -456,13 +466,15 @@ class Sufficiency:
         return SufficiencyOutput(projection, data.params, output)
 
     @classmethod
-    def plot(cls, data: SufficiencyOutput, class_names: Optional[Sequence[str]] = None) -> List[Figure]:
+    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
         -------
@@ -505,7 +517,7 @@ class Sufficiency:
         return plots
 
     @classmethod
-    def inv_project(cls, targets: Dict[str, NDArray], data: SufficiencyOutput) -> Dict[str, NDArray]:
+    def inv_project(cls, targets: dict[str, NDArray], data: SufficiencyOutput) -> dict[str, NDArray]:
         """
         Calculate training samples needed to achieve target model metric values.
 

dataeval/detectors/__init__.py

@@ -1,29 +1,10 @@
-from importlib.util import find_spec
+from dataeval import _IS_TENSORFLOW_AVAILABLE
 
-from dataeval._internal.detectors.clusterer import Clusterer
-from dataeval._internal.detectors.drift.base import LastSeenUpdate, ReservoirSamplingUpdate
-from dataeval._internal.detectors.drift.cvm import DriftCVM
-from dataeval._internal.detectors.drift.ks import DriftKS
-from dataeval._internal.detectors.duplicates import Duplicates
-from dataeval._internal.detectors.linter import Linter
+from . import drift, linters
 
-__all__ = ["Clusterer", "Duplicates", "Linter", "DriftCVM", "DriftKS", "LastSeenUpdate", "ReservoirSamplingUpdate"]
+__all__ = ["drift", "linters"]
 
-if find_spec("torch") is not None:  # pragma: no cover
-    from dataeval._internal.detectors.drift.mmd import DriftMMD
-    from dataeval._internal.detectors.drift.torch import GaussianRBF, preprocess_drift
-    from dataeval._internal.detectors.drift.uncertainty import DriftUncertainty
+if _IS_TENSORFLOW_AVAILABLE:  # pragma: no cover
+    from . import ood
 
-    __all__ += ["DriftMMD", "GaussianRBF", "DriftUncertainty", "preprocess_drift"]
-
-if find_spec("tensorflow") is not None and find_spec("tensorflow_probability") is not None:  # pragma: no cover
-    from dataeval._internal.detectors.ood.ae import OOD_AE
-    from dataeval._internal.detectors.ood.aegmm import OOD_AEGMM
-    from dataeval._internal.detectors.ood.base import OODScore
-    from dataeval._internal.detectors.ood.llr import OOD_LLR
-    from dataeval._internal.detectors.ood.vae import OOD_VAE
-    from dataeval._internal.detectors.ood.vaegmm import OOD_VAEGMM
-
-    __all__ += ["OOD_AE", "OOD_AEGMM", "OOD_LLR", "OODScore", "OOD_VAE", "OOD_VAEGMM"]
-
-del find_spec
+    __all__ += ["ood"]

dataeval/detectors/drift/__init__.py

@@ -0,0 +1,16 @@
+from dataeval import _IS_TORCH_AVAILABLE
+from dataeval._internal.detectors.drift.cvm import DriftCVM
+from dataeval._internal.detectors.drift.ks import DriftKS
+
+from . import updates
+
+__all__ = ["DriftCVM", "DriftKS", "updates"]
+
+if _IS_TORCH_AVAILABLE:  # pragma: no cover
+    from dataeval._internal.detectors.drift.mmd import DriftMMD
+    from dataeval._internal.detectors.drift.torch import preprocess_drift
+    from dataeval._internal.detectors.drift.uncertainty import DriftUncertainty
+
+    from . import kernels
+
+    __all__ += ["DriftMMD", "DriftUncertainty", "kernels", "preprocess_drift"]

dataeval/detectors/drift/kernels/__init__.py

@@ -0,0 +1,6 @@
+from dataeval import _IS_TORCH_AVAILABLE
+
+if _IS_TORCH_AVAILABLE:  # pragma: no cover
+    from dataeval._internal.detectors.drift.torch import GaussianRBF
+
+    __all__ = ["GaussianRBF"]

dataeval/detectors/drift/updates/__init__.py

@@ -0,0 +1,3 @@
+from dataeval._internal.detectors.drift.base import LastSeenUpdate, ReservoirSamplingUpdate
+
+__all__ = ["LastSeenUpdate", "ReservoirSamplingUpdate"]

dataeval/detectors/linters/__init__.py

@@ -0,0 +1,5 @@
+from dataeval._internal.detectors.clusterer import Clusterer
+from dataeval._internal.detectors.duplicates import Duplicates
+from dataeval._internal.detectors.outliers import Outliers
+
+__all__ = ["Clusterer", "Duplicates", "Outliers"]

dataeval/detectors/ood/__init__.py

@@ -0,0 +1,11 @@
+from dataeval import _IS_TENSORFLOW_AVAILABLE
+
+if _IS_TENSORFLOW_AVAILABLE:  # pragma: no cover
+    from dataeval._internal.detectors.ood.ae import OOD_AE
+    from dataeval._internal.detectors.ood.aegmm import OOD_AEGMM
+    from dataeval._internal.detectors.ood.base import OODOutput, OODScore
+    from dataeval._internal.detectors.ood.llr import OOD_LLR
+    from dataeval._internal.detectors.ood.vae import OOD_VAE
+    from dataeval._internal.detectors.ood.vaegmm import OOD_VAEGMM
+
+    __all__ = ["OODOutput", "OODScore", "OOD_AE", "OOD_AEGMM", "OOD_LLR", "OOD_VAE", "OOD_VAEGMM"]

dataeval/metrics/__init__.py

@@ -1,27 +1,3 @@
-from typing import List
+from . import bias, estimators, stats
 
-__all__: List[str] = []
-
-from dataeval._internal.metrics.balance import balance, balance_classwise
-from dataeval._internal.metrics.ber import ber
-from dataeval._internal.metrics.coverage import coverage
-from dataeval._internal.metrics.divergence import divergence
-from dataeval._internal.metrics.diversity import diversity, diversity_classwise
-from dataeval._internal.metrics.parity import parity, parity_metadata
-from dataeval._internal.metrics.stats import channelstats, imagestats
-from dataeval._internal.metrics.uap import uap
-
-__all__ += [
-    "balance",
-    "balance_classwise",
-    "ber",
-    "channelstats",
-    "coverage",
-    "divergence",
-    "diversity",
-    "diversity_classwise",
-    "imagestats",
-    "parity",
-    "parity_metadata",
-    "uap",
-]
+__all__ = ["bias", "estimators", "stats"]

dataeval/metrics/bias/__init__.py

@@ -0,0 +1,14 @@
+from dataeval._internal.metrics.balance import balance, balance_classwise
+from dataeval._internal.metrics.coverage import coverage
+from dataeval._internal.metrics.diversity import diversity, diversity_classwise
+from dataeval._internal.metrics.parity import label_parity, parity
+
+__all__ = [
+    "balance",
+    "balance_classwise",
+    "coverage",
+    "diversity",
+    "diversity_classwise",
+    "label_parity",
+    "parity",
+]

dataeval/metrics/estimators/__init__.py

@@ -0,0 +1,9 @@
+from dataeval._internal.metrics.ber import ber
+from dataeval._internal.metrics.divergence import divergence
+from dataeval._internal.metrics.uap import uap
+
+__all__ = [
+    "ber",
+    "divergence",
+    "uap",
+]

dataeval/metrics/stats/__init__.py

@@ -0,0 +1,6 @@
+from dataeval._internal.metrics.stats import channelstats, imagestats
+
+__all__ = [
+    "channelstats",
+    "imagestats",
+]

dataeval/tensorflow/__init__.py

@@ -0,0 +1,3 @@
+from . import loss, models, recon
+
+__all__ = ["loss", "models", "recon"]

dataeval/tensorflow/loss/__init__.py

@@ -0,0 +1,3 @@
+from dataeval._internal.models.tensorflow.losses import Elbo, LossGMM
+
+__all__ = ["Elbo", "LossGMM"]

dataeval/tensorflow/models/__init__.py

@@ -0,0 +1,5 @@
+from dataeval._internal.models.tensorflow.autoencoder import AE, AEGMM, VAE, VAEGMM
+from dataeval._internal.models.tensorflow.pixelcnn import PixelCNN
+from dataeval._internal.models.tensorflow.utils import create_model
+
+__all__ = ["create_model", "AE", "AEGMM", "PixelCNN", "VAE", "VAEGMM"]

dataeval/tensorflow/recon/__init__.py

@@ -0,0 +1,3 @@
+from dataeval._internal.models.tensorflow.autoencoder import eucl_cosim_features
+
+__all__ = ["eucl_cosim_features"]

dataeval/torch/__init__.py

@@ -0,0 +1,3 @@
+from . import models, trainer
+
+__all__ = ["models", "trainer"]

dataeval/{models/torch → torch/models}/__init__.py

@@ -1,8 +1,7 @@
 from dataeval._internal.models.pytorch.autoencoder import (
-    AETrainer,
     AriaAutoencoder,
     Decoder,
     Encoder,
 )
 
-__all__ = ["AETrainer", "AriaAutoencoder", "Decoder", "Encoder"]
+__all__ = ["AriaAutoencoder", "Decoder", "Encoder"]

dataeval/torch/trainer/__init__.py

@@ -0,0 +1,3 @@
+from dataeval._internal.models.pytorch.autoencoder import AETrainer
+
+__all__ = ["AETrainer"]

dataeval/utils/__init__.py

@@ -1,9 +1,6 @@
-from importlib.util import find_spec
-from typing import List
+from dataeval import _IS_TORCH_AVAILABLE
 
-__all__: List[str] = []
-
-if find_spec("torch") is not None:  # pragma: no cover
+if _IS_TORCH_AVAILABLE:  # pragma: no cover
     from dataeval._internal.utils import read_dataset
 
-    __all__ += ["read_dataset"]
+    __all__ = ["read_dataset"]

dataeval/workflows/__init__.py

@@ -1,8 +1,6 @@
-from importlib.util import find_spec
+from dataeval import _IS_TORCH_AVAILABLE
 
-if find_spec("torch") is not None:  # pragma: no cover
+if _IS_TORCH_AVAILABLE:  # pragma: no cover
     from dataeval._internal.workflows.sufficiency import Sufficiency
 
     __all__ = ["Sufficiency"]
-
-del find_spec

{dataeval-0.65.0.dist-info → dataeval-0.66.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: dataeval
-Version: 0.65.0
+Version: 0.66.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