dataeval 1.0.3__tar.gz → 1.0.5__tar.gz

{dataeval-1.0.3 → dataeval-1.0.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dataeval
-Version: 1.0.3
+Version: 1.0.5
 Summary: DataEval provides a simple interface to characterize image data and its impact on model performance across classification and object-detection tasks
 Project-URL: Homepage, https://dataeval.ai/
 Project-URL: Repository, https://github.com/aria-ml/dataeval/

{dataeval-1.0.3 → dataeval-1.0.5}/pyproject.toml

@@ -118,6 +118,14 @@ docs = [
   "markupsafe>=3,<3.0.2",
   "jupytext>=1.19.1",
 ]
+security = [  # keep in sync with [tool.uv.constraint-dependencies]
+  "cryptography>=46.0.5",    # CVE-2026-26007: Missing Subgroup Validation for SECT Curves
+  "filelock>=3.20.3",        # GHSA-w853-jp5j-5j7f, GHSA-qmgc-5h2g-mvrw
+  "pillow>=12.1.1",          # CVE-2026-25990: OOB write via PSD image
+  "protobuf>=6.33.5",        # GHSA-7gcm-g887-7qv7
+  "setuptools>=82.0.0",      # CVE-2026-23949: (jaraco_context) path traversal in tarball()
+                             # CVE-2026-24049: (wheel) privilege escalation via unpack
+]
 dev = [
   { include-group = "base" },
   { include-group = "lint" },
@@ -141,7 +149,9 @@ conflicts = [
 ]
 constraint-dependencies = [
     "cryptography>=46.0.5",    # CVE-2026-26007: Missing Subgroup Validation for SECT Curves
+    "filelock>=3.20.3",        # GHSA-w853-jp5j-5j7f, GHSA-qmgc-5h2g-mvrw
     "pillow>=12.1.1",          # CVE-2026-25990: OOB write via PSD image
+    "protobuf>=6.33.5",        # GHSA-7gcm-g887-7qv7
     "setuptools>=82.0.0",      # CVE-2026-23949: (jaraco_context) path traversal in tarball()
                                # CVE-2026-24049: (wheel) privilege escalation via unpack
 ]
@@ -262,20 +272,23 @@ exclude = [
   ".jupyter_cache",
   "*env*",
   "output",
+  "_build",
   "build",
   ".nox",
   ".tox",
+  "prototype",
   "src/dataeval/_version.py",
 ]
 line-length = 120
 indent-width = 4
 target-version = "py310"
+extend-include = ["*.ipynb"]
 
 [tool.ruff.lint]
 select = ["F", "E", "W", "C90", "I", "N", "D", "UP", "YTT", "ANN", "S", "BLE", "B", "A",
           "COM", "C4", "T10", "ISC", "ICN", "PYI", "PT", "Q", "RSE", "RET", "SLF", "SIM",
-          "TID252", "ARG", "FIX", "PD", "FLY", "NPY", "RUF100", "PERF"]
-ignore = ["ANN401", "COM812", "NPY002", "SLF001"]
+          "TID252", "ARG", "FIX", "PD", "FLY", "NPY", "RUF027", "RUF100", "PERF"]
+ignore = ["ANN101", "ANN102", "ANN401", "C408", "C416", "COM812", "NPY002", "SLF001"]
 fixable = ["ALL"]
 unfixable = []
 dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
@@ -287,6 +300,9 @@ builtins-strict-checking = false
 [tool.ruff.lint.isort]
 known-first-party = ["dataeval"]
 
+[tool.ruff.lint.mccabe]
+max-complexity = 5
+
 [tool.ruff.lint.pydocstyle]
 convention = "numpy"
 

{dataeval-1.0.3 → dataeval-1.0.5}/src/dataeval/_embeddings.py

@@ -509,7 +509,7 @@ class Embeddings(Array, FeatureExtractor):
             images.append(image)
         return images
 
-    def _batch(self, indices: Sequence[int]) -> Iterator[NDArray[Any]]:
+    def _batch(self, indices: Sequence[int]) -> Iterator[NDArray[Any]]:  # noqa: C901
         """Process indices in batches using the extractor."""
         if self._dataset is None:
             raise NotFittedError("No dataset bound. Call bind() first.")
@@ -559,7 +559,7 @@ class Embeddings(Array, FeatureExtractor):
             batch_indices = list(indices[batch_start : batch_start + self._batch_size])
             yield self._embeddings[batch_indices]
 
-    def __getitem__(self, key: int | Iterable[int] | slice, /) -> NDArray[Any]:
+    def __getitem__(self, key: int | Iterable[int] | slice, /) -> NDArray[Any]:  # noqa: C901
         """
         Access embeddings by index, indices or slice.
 

{dataeval-1.0.3 → dataeval-1.0.5}/src/dataeval/_experimental.py

@@ -13,7 +13,7 @@ from dataeval.exceptions import DeprecatedWarning, ExperimentalWarning
 F = TypeVar("F", bound=Callable[..., Any])
 
 
-def _make_warning_message(
+def _make_warning_message(  # noqa: C901
     name: str,
     kind: str,
     *,
@@ -51,7 +51,7 @@ def _prepend_doc_note(doc: str | None, note: str) -> str:
 def experimental(_target: F) -> F: ...
 @overload
 def experimental(*, alternative: str | None = None, details: str | None = None) -> Callable[[F], F]: ...
-def experimental(
+def experimental(  # noqa: C901
     _target: F | None = None,
     *,
     alternative: str | None = None,
@@ -72,7 +72,7 @@ def experimental(
         def my_func(): ...
     """
 
-    def decorator(target: F) -> F:
+    def decorator(target: F) -> F:  # noqa: C901
         name = getattr(target, "__qualname__", getattr(target, "__name__", str(target)))
         msg = _make_warning_message(name, "experimental", alternative=alternative, details=details)
         warned = False
@@ -118,7 +118,7 @@ def deprecated(
     alternative: str | None = None,
     details: str | None = None,
 ) -> Callable[[F], F]: ...
-def deprecated(
+def deprecated(  # noqa: C901
     _target: F | None = None,
     *,
     since: str | None = None,
@@ -141,7 +141,7 @@ def deprecated(
         def old_func(): ...
     """
 
-    def decorator(target: F) -> F:
+    def decorator(target: F) -> F:  # noqa: C901
         name = getattr(target, "__qualname__", getattr(target, "__name__", str(target)))
         msg = _make_warning_message(
             name,

{dataeval-1.0.3 → dataeval-1.0.5}/src/dataeval/_metadata.py

@@ -39,6 +39,7 @@ class FactorInfo:
     factor_type: Literal["categorical", "continuous", "discrete"]
     is_binned: bool = False
     is_digitized: bool = False
+    level: Literal["image", "target"] = "image"
 
 
 def _to_col(name: str, info: FactorInfo, binned: bool = True) -> str:
@@ -110,8 +111,8 @@ class Metadata(Array, FeatureExtractor):
         *,
         continuous_factor_bins: Mapping[str, int | Sequence[float]] | None = None,
         auto_bin_method: Literal["uniform_width", "uniform_count", "clusters"] = "uniform_width",
-        exclude: Sequence[str] | None = None,
-        include: Sequence[str] | None = None,
+        exclude: str | Sequence[str] | None = None,
+        include: str | Sequence[str] | None = None,
     ) -> None:
         self._class_labels: NDArray[np.intp]
         self._item_indices: NDArray[np.intp]
@@ -132,8 +133,8 @@ class Metadata(Array, FeatureExtractor):
         if exclude is not None and include is not None:
             raise ValueError("Filters for `exclude` and `include` are mutually exclusive.")
 
-        self._exclude = set(exclude or ())
-        self._include = set(include or ())
+        self._exclude = {exclude} if isinstance(exclude, str) else set(exclude or ())
+        self._include = {include} if isinstance(include, str) else set(include or ())
         self._target_factors_only = False
 
     def __repr__(self) -> str:
@@ -281,7 +282,7 @@ class Metadata(Array, FeatureExtractor):
             raise NotFittedError("No dataset bound. Call bind() first.")
         yield from self.factor_data
 
-    def __getitem__(self, index: int | str | slice) -> Array:
+    def __getitem__(self, index: int | str | slice) -> Array:  # noqa: C901
         """Get binned metadata for specific indices or factors.
 
         Parameters
@@ -423,17 +424,17 @@ class Metadata(Array, FeatureExtractor):
         return self._exclude
 
     @exclude.setter
-    def exclude(self, value: Sequence[str]) -> None:
+    def exclude(self, value: str | Sequence[str]) -> None:
         """Set factor names to exclude from processing.
 
         Automatically clears include filter and resets binning state when exclusion list changes.
 
         Parameters
         ----------
-        value : Sequence[str]
-            Factor names to exclude from metadata analysis.
+        value : str | Sequence[str]
+            Factor name or names to exclude from metadata analysis.
         """
-        exclude = set(value)
+        exclude = {value} if isinstance(value, str) else set(value)
         if self._exclude != exclude:
             self._exclude = exclude
             self._include = set()
@@ -451,7 +452,7 @@ class Metadata(Array, FeatureExtractor):
         return self._include
 
     @include.setter
-    def include(self, value: Sequence[str]) -> None:
+    def include(self, value: str | Sequence[str]) -> None:
         """Set factor names to include in processing.
 
         Automatically clears exclude filter and resets binning state when
@@ -459,10 +460,10 @@ class Metadata(Array, FeatureExtractor):
 
         Parameters
         ----------
-        value : Sequence[str]
-            Factor names to include in metadata analysis.
+        value : str | Sequence[str]
+            Factor name or names to include in metadata analysis.
         """
-        include = set(value)
+        include = {value} if isinstance(value, str) else set(value)
         if self._include != include:
             self._include = include
             self._exclude = set()
@@ -933,7 +934,7 @@ class Metadata(Array, FeatureExtractor):
         factor = factor[0] if isinstance(factor, tuple) else factor
         return factor in self.include if self.include else factor not in self.exclude
 
-    def _reset_bins(self, cols: Iterable[str] | None = None) -> None:
+    def _reset_bins(self, cols: Iterable[str] | None = None) -> None:  # noqa: C901
         if self._is_binned:
             columns = self._dataframe.columns
             for col in cols or columns:
@@ -1005,7 +1006,7 @@ class Metadata(Array, FeatureExtractor):
             )
         return target_rows
 
-    def _get_target_factor_values(
+    def _get_target_factor_values(  # noqa: C901
         self,
         factor_name: str,
         factor_values: Any,
@@ -1115,13 +1116,26 @@ class Metadata(Array, FeatureExtractor):
             raise ValueError(f"Invalid level: {level}. Must be 'image', 'target', or 'auto'")
 
     def _create_factor_column(self, data_array: NDArray, level: str, num_image_rows: int) -> list:
-        """Create a factor column with values at the appropriate level."""
+        """Create a factor column with values at the appropriate level.
+
+        For OD datasets with image-level factors, values are stored in image rows
+        and replicated to target rows using item_index mapping, so that bias
+        evaluators can access them via target_data.
+        """
         if level == "image":
-            # Create column: image-level values in image rows, None in target rows
-            full_data = [None] * len(self.dataframe)
-            for idx, val in enumerate(data_array):
-                full_data[idx] = val  # Image rows come first in our structure
-            return full_data
+            # Image rows get the values directly
+            image_values: list = data_array.tolist()
+
+            if self.has_targets():
+                # For OD datasets, replicate image-level values to target rows
+                # using the item_index column which maps each target to its source image
+                target_df = self._dataframe.filter(pl.col("target_index").is_not_null())
+                target_image_indices = target_df["item_index"].to_numpy()
+                target_values = data_array[target_image_indices].tolist()
+            else:
+                target_values = []
+
+            return image_values + target_values
         # level == "target"
         # Create column: None in image rows, target-level values in target rows
         return [None] * num_image_rows + list(data_array)
@@ -1138,7 +1152,7 @@ class Metadata(Array, FeatureExtractor):
             self._structure()
         return bool(self._has_targets)
 
-    def _process_targets(
+    def _process_targets(  # noqa: C901
         self,
         raw: list,
         labels: list,
@@ -1267,9 +1281,10 @@ class Metadata(Array, FeatureExtractor):
             k for k in factors if not isinstance(self._dataframe.schema.get(k), pl.List | pl.Struct | pl.Array)
         }
 
-        self._factors = dict.fromkeys(usable_factors, None)
+        existing = self._factors if hasattr(self, "_factors") else {}
+        self._factors = {k: existing.get(k) for k in usable_factors}
 
-    def _structure(
+    def _structure(  # noqa: C901
         self,
         *,
         progress_callback: ProgressCallback | None = None,
@@ -1463,7 +1478,7 @@ class Metadata(Array, FeatureExtractor):
         df = self._add_column_with_padding(df, col_dg, ordinal.astype(np.int64), is_od)
         return df, FactorInfo("discrete", is_digitized=True)
 
-    def _bin(
+    def _bin(  # noqa: C901
         self,
         *,
         progress_callback: ProgressCallback | None = None,
@@ -1492,9 +1507,12 @@ class Metadata(Array, FeatureExtractor):
         factors_to_process = [col for col in self.factor_names if not {_binned(col), _digitized(col)} & column_set]
         total_factors = len(factors_to_process)
 
+        target_only = self._target_factors - self._image_factors if is_od else set()
         for i, col in enumerate(factors_to_process):
             data = data_df[col].to_numpy()
             df, info = self._process_factor(df, col, data, factor_bins, is_od)
+            if is_od and col in target_only:
+                info.level = "target"
             factor_info[col] = info
 
             if progress_callback:
@@ -1505,7 +1523,7 @@ class Metadata(Array, FeatureExtractor):
         self._factors.update(factor_info)
         self._is_binned = True
 
-    def add_factors(
+    def add_factors(  # noqa: C901
         self,
         factors: Mapping[str, Array1D[Any]],
         level: Literal["image", "target", "auto"] = "auto",

dataeval-1.0.5/src/dataeval/_version.py

@@ -0,0 +1,24 @@
+# file generated by vcs-versioning
+# don't change, don't track in version control
+from __future__ import annotations
+
+__all__ = [
+    "__version__",
+    "__version_tuple__",
+    "version",
+    "version_tuple",
+    "__commit_id__",
+    "commit_id",
+]
+
+version: str
+__version__: str
+__version_tuple__: tuple[int | str, ...]
+version_tuple: tuple[int | str, ...]
+commit_id: str | None
+__commit_id__: str | None
+
+__version__ = version = '1.0.5'
+__version_tuple__ = version_tuple = (1, 0, 5)
+
+__commit_id__ = commit_id = None

{dataeval-1.0.3 → dataeval-1.0.5}/src/dataeval/bias/_balance.py

@@ -3,6 +3,7 @@ __all__ = []
 from dataclasses import dataclass
 from typing import Any, Literal
 
+import numpy as np
 import polars as pl
 
 from dataeval import Metadata
@@ -146,7 +147,7 @@ class Balance(Evaluator):
         super().__init__(locals())
 
     @set_metadata(state=["num_neighbors", "class_imbalance_threshold", "factor_correlation_threshold"])
-    def evaluate(self, data: AnnotatedDataset[Any] | MetadataLike) -> BalanceOutput:
+    def evaluate(self, data: AnnotatedDataset[Any] | MetadataLike) -> BalanceOutput:  # noqa: C901
         """
         Compute mutual information between factors and identify imbalanced classes.
 
@@ -269,8 +270,9 @@ class Balance(Evaluator):
         # Include class_label as the first factor (index 0), then all metadata factors
         all_factor_names = ["class_label"] + factor_names
 
+        u_classes = np.unique(self.metadata.class_labels)
         for class_idx in range(classwise.shape[0]):
-            class_name = index2label.get(class_idx, str(class_idx))
+            class_name = index2label.get(int(u_classes[class_idx]), str(u_classes[class_idx]))
             for factor_idx in range(classwise.shape[1]):
                 mi_value = classwise[class_idx, factor_idx]
                 class_name_col.append(class_name)

{dataeval-1.0.3 → dataeval-1.0.5}/src/dataeval/bias/_diversity.py

@@ -135,7 +135,7 @@ class Diversity(Evaluator):
         super().__init__(locals())
 
     @set_metadata(state=["method", "threshold"])
-    def evaluate(self, data: AnnotatedDataset[Any] | MetadataLike) -> DiversityOutput:
+    def evaluate(self, data: AnnotatedDataset[Any] | MetadataLike) -> DiversityOutput:  # noqa: C901
         """
         Compute diversity and classwise diversity for the dataset.
 
@@ -251,7 +251,7 @@ class Diversity(Evaluator):
         is_low_diversity_col: list[bool] = []
 
         for class_idx in range(classwise_div.shape[0]):
-            class_name = index2label.get(class_idx, str(class_idx))
+            class_name = index2label.get(int(u_classes[class_idx]), str(u_classes[class_idx]))
             for factor_idx in range(num_factors):
                 div_value = classwise_div[class_idx, factor_idx]
                 if not np.isnan(div_value):

{dataeval-1.0.3 → dataeval-1.0.5}/src/dataeval/config.py

@@ -23,7 +23,7 @@ from pydantic import BaseModel, ConfigDict, field_validator
 
 from dataeval.protocols import DeviceLike
 
-### GLOBAL CONFIG ###
+# GLOBAL CONFIG ###
 
 
 class GlobalConfig(BaseModel):
@@ -77,7 +77,7 @@ class GlobalConfig(BaseModel):
 _config = GlobalConfig()
 
 
-### CONTEXT MANAGER ###
+# CONTEXT MANAGER ###
 
 
 class _ConfigContextManager:
@@ -96,7 +96,7 @@ class _ConfigContextManager:
         setattr(_config, self._attr_name, self._old)
 
 
-### FUNCS ###
+# FUNCS ###
 
 
 def _todevice(device: DeviceLike) -> torch.device:

{dataeval-1.0.3 → dataeval-1.0.5}/src/dataeval/core/_bin.py

@@ -92,7 +92,7 @@ def bin_data(data: NDArray[Any], bin_method: str) -> NDArray[np.intp]:
     return np.digitize(data, bin_edges)
 
 
-def is_continuous(data: NDArray[np.number[Any]], image_indices: NDArray[np.number[Any]] | None = None) -> bool:
+def is_continuous(data: NDArray[np.number[Any]], image_indices: NDArray[np.number[Any]] | None = None) -> bool:  # noqa: C901
     """
     Determine whether the data is continuous or discrete using the Wasserstein distance.
 
@@ -144,7 +144,7 @@ def is_continuous(data: NDArray[np.number[Any]], image_indices: NDArray[np.numbe
     return bool(shift < DISCRETE_MIN_WD)  # if NNN is close enough to uniform, consider the sample continuous.
 
 
-def _bin_by_clusters(data: NDArray[np.number[Any]]) -> NDArray[np.float64]:
+def _bin_by_clusters(data: NDArray[np.number[Any]]) -> NDArray[np.float64]:  # noqa: C901
     """
     Bin continuous data by using the Clusterer to identify clusters.
 

{dataeval-1.0.3 → dataeval-1.0.5}/src/dataeval/core/_calculators/_cache.py

@@ -22,7 +22,13 @@ class CalculatorCache:
     This class adapts based on the data type passed in.
     """
 
-    def __init__(self, datum: Any, box: BoundingBox | None = None, per_channel: bool = False) -> None:
+    def __init__(
+        self,
+        datum: Any,
+        box: BoundingBox | None = None,
+        per_channel: bool = False,
+        normalize_pixel_values: bool = False,
+    ) -> None:
         is_spatial = len(datum.shape) >= 2
         self.raw = datum
         # Assume image data for now (will be generic in future)
@@ -30,6 +36,7 @@ class CalculatorCache:
         self.height: int = datum.shape[-2] if is_spatial else 0
         self.shape: tuple[int, ...] = datum.shape
         self.per_channel_mode = per_channel
+        self.normalize_pixel_values = normalize_pixel_values
         self.has_box = box is not None
 
         # Ensure bounding box
@@ -54,7 +61,9 @@ class CalculatorCache:
 
     @cached_property
     def scaled(self) -> NDArray[Any]:
-        return rescale(self.image)
+        if self.normalize_pixel_values:
+            return rescale(self.image)
+        return self.image
 
     @cached_property
     def per_channel(self) -> NDArray[Any]:

{dataeval-1.0.3 → dataeval-1.0.5}/src/dataeval/core/_calculators/_pixelstats.py

@@ -39,11 +39,23 @@ class PixelStatCalculator(Calculator[ImageStats]):
     def _var_func(self, data: NDArray[Any], **kw: Any) -> Any:
         return np.nanvar(data, **kw) if self._has_nan else np.var(data, **kw)
 
+    @cached_property
+    def _histogram_range(self) -> tuple[float, float]:
+        if self.cache.normalize_pixel_values:
+            return (0.0, 1.0)
+        from dataeval.utils.preprocessing import get_bitdepth
+
+        bitdepth = get_bitdepth(self.cache.scaled)
+        if bitdepth.depth == 0:
+            return (0.0, 1.0)
+        return (0.0, float(bitdepth.pmax))
+
     @cached_property
     def histogram(self) -> NDArray[np.float64]:
+        r = self._histogram_range
         if self.per_channel_mode:
-            return np.apply_along_axis(lambda y: np.histogram(y, bins=256, range=(0, 1))[0], 1, self.cache.per_channel)
-        return np.histogram(self.cache.scaled, bins=256, range=(0, 1))[0]
+            return np.apply_along_axis(lambda y: np.histogram(y, bins=256, range=r)[0], 1, self.cache.per_channel)
+        return np.histogram(self.cache.scaled, bins=256, range=r)[0]
 
     def get_applicable_flags(self) -> ImageStats:
         """Return which flags this calculator handles."""

{dataeval-1.0.3 → dataeval-1.0.5}/src/dataeval/core/_clusterer.py

@@ -99,7 +99,7 @@ class _Clusters:
         prob: NDArray[np.float64] = exp / np.sum(exp)
         return prob
 
-    def _sort_by_weights(self, embeddings: NDArray[np.float64]) -> NDArray[np.intp]:
+    def _sort_by_weights(self, embeddings: NDArray[np.float64]) -> NDArray[np.intp]:  # noqa: C901
         """Sort samples using complexity-based weighted sampling."""
         labels = self._get_labels(embeddings)
         pr = self._complexity(embeddings)
@@ -356,7 +356,7 @@ class _HDBSCAN:
         self.cluster_selection_epsilon = 0.0
         self.cluster_selection_method = "eom"
 
-    def fit(self, embeddings: NDArray[np.floating]) -> "_HDBSCAN":
+    def fit(self, embeddings: NDArray[np.floating]) -> "_HDBSCAN":  # noqa: C901
         """
         Find clusters based on hierarchical density-based clustering.
 
@@ -541,7 +541,7 @@ class ClusterStats(TypedDict):
     nearest_cluster_idx: NDArray[np.int64]
 
 
-def compute_cluster_stats(
+def compute_cluster_stats(  # noqa: C901
     embeddings: NDArray[np.floating],
     cluster_labels: _Clusters | NDArray[np.int64],
 ) -> ClusterStats:
@@ -642,7 +642,7 @@ def compute_cluster_stats(
     )
 
 
-def cluster(
+def cluster(  # noqa: C901
     embeddings: ArrayND[float],
     algorithm: Literal["kmeans", "hdbscan"] = "hdbscan",
     n_clusters: int | None = None,

{dataeval-1.0.3 → dataeval-1.0.5}/src/dataeval/core/_compute_ratios.py

@@ -101,7 +101,7 @@ def _build_image_lookup(source_indices: Sequence[SourceIndex]) -> dict[tuple[int
     return lookup
 
 
-def _calculate_ratio_for_stat(
+def _calculate_ratio_for_stat(  # noqa: C901
     stat_name: str,
     box_value: Any,
     img_value: Any,
@@ -160,7 +160,7 @@ def _calculate_ratio_for_stat(
         return box_value
 
 
-def _validate_separate_inputs(
+def _validate_separate_inputs(  # noqa: C901
     stats_output: StatsResult,
     box_stats_output: StatsResult,
 ) -> tuple[Sequence[SourceIndex], Sequence[SourceIndex]]:
@@ -241,7 +241,7 @@ def _validate_unified_input(source_indices: Sequence[SourceIndex]) -> None:
         )
 
 
-def compute_ratios(
+def compute_ratios(  # noqa: C901
     stats_output: StatsResult,
     *,
     target_stats_output: StatsResult | None = None,