dataeval 0.86.1__py3-none-any.whl → 0.86.3__py3-none-any.whl

dataeval/outputs/_bias.py

@@ -4,7 +4,7 @@ __all__ = []
 
 import contextlib
 from dataclasses import asdict, dataclass
-from typing import Any, Literal, TypeVar, overload
+from typing import Any, Mapping, Sequence, TypeVar
 
 import numpy as np
 import pandas as pd
@@ -39,7 +39,7 @@ class ToDataFrameMixin:
         This method requires `pandas <https://pandas.pydata.org/>`_ to be installed.
         """
         return pd.DataFrame(
-            index=self.factor_names,  # type: ignore - list[str] is documented as acceptable index type
+            index=self.factor_names,  # type: ignore - Sequence[str] is documented as acceptable index type
             data={
                 "score": self.score.round(2),
                 "p-value": self.p_value.round(2),
@@ -58,7 +58,7 @@ class ParityOutput(ToDataFrameMixin, Output):
         chi-squared score(s) of the test
     p_value : NDArray[np.float64]
         p-value(s) of the test
-    factor_names : list[str]
+    factor_names : Sequence[str]
         Names of each metadata factor
     insufficient_data: dict
         Dictionary of metadata factors with less than 5 class occurrences per value
@@ -66,8 +66,8 @@ class ParityOutput(ToDataFrameMixin, Output):
 
     score: NDArray[np.float64]
     p_value: NDArray[np.float64]
-    factor_names: list[str]
-    insufficient_data: dict[str, dict[int, dict[str, int]]]
+    factor_names: Sequence[str]
+    insufficient_data: Mapping[str, Mapping[int, Mapping[str, int]]]
 
 
 @dataclass(frozen=True)
@@ -145,12 +145,15 @@ class CoverageOutput(Output):
         cols = min(3, num_images)
         fig, axs = plt.subplots(rows, cols, figsize=(3 * cols, 3 * rows))
 
-        for image, ax in zip(images[:num_images], axs.flat):
+        # Flatten axes using numpy array explicitly for compatibility
+        axs_flat = np.asarray(axs).flatten()
+
+        for image, ax in zip(images[:num_images], axs_flat):
             image = channels_first_to_last(as_numpy(image))
             ax.imshow(image)
             ax.axis("off")
 
-        for ax in axs.flat[num_images:]:
+        for ax in axs_flat[num_images:]:
             ax.axis("off")
 
         fig.tight_layout()
@@ -187,65 +190,23 @@ class BalanceOutput(Output):
         Estimate of inter/intra-factor mutual information
     classwise : NDArray[np.float64]
         Estimate of mutual information between metadata factors and individual class labels
-    factor_names : list[str]
+    factor_names : Sequence[str]
         Names of each metadata factor
-    class_names : list[str]
+    class_names : Sequence[str]
         List of the class labels present in the dataset
     """
 
     balance: NDArray[np.float64]
     factors: NDArray[np.float64]
     classwise: NDArray[np.float64]
-    factor_names: list[str]
-    class_names: list[str]
-
-    @overload
-    def _by_factor_type(
-        self,
-        attr: Literal["factor_names"],
-        factor_type: Literal["discrete", "continuous", "both"],
-    ) -> list[str]: ...
-
-    @overload
-    def _by_factor_type(
-        self,
-        attr: Literal["balance", "factors", "classwise"],
-        factor_type: Literal["discrete", "continuous", "both"],
-    ) -> NDArray[np.float64]: ...
-
-    def _by_factor_type(
-        self,
-        attr: Literal["balance", "factors", "classwise", "factor_names"],
-        factor_type: Literal["discrete", "continuous", "both"],
-    ) -> NDArray[np.float64] | list[str]:
-        # if not filtering by factor_type then just return the requested attribute without mask
-        if factor_type == "both":
-            return getattr(self, attr)
-
-        # create the mask for the selected factor_type
-        mask_lambda = (
-            (lambda x: "-continuous" not in x) if factor_type == "discrete" else (lambda x: "-discrete" not in x)
-        )
-
-        # return the masked attribute
-        if attr == "factor_names":
-            return [x.replace(f"-{factor_type}", "") for x in self.factor_names if mask_lambda(x)]
-        factor_type_mask = np.asarray([mask_lambda(x) for x in self.factor_names])
-        if attr == "factors":
-            return self.factors[factor_type_mask[1:]][:, factor_type_mask[1:]]
-        if attr == "balance":
-            return self.balance[factor_type_mask]
-        if attr == "classwise":
-            return self.classwise[:, factor_type_mask]
-
-        raise ValueError(f"Unknown attr {attr} specified.")
+    factor_names: Sequence[str]
+    class_names: Sequence[str]
 
     def plot(
         self,
-        row_labels: list[Any] | NDArray[Any] | None = None,
-        col_labels: list[Any] | NDArray[Any] | None = None,
+        row_labels: Sequence[Any] | NDArray[Any] | None = None,
+        col_labels: Sequence[Any] | NDArray[Any] | None = None,
         plot_classwise: bool = False,
-        factor_type: Literal["discrete", "continuous", "both"] = "discrete",
     ) -> Figure:
         """
         Plot a heatmap of balance information.
@@ -258,8 +219,6 @@ class BalanceOutput(Output):
             List/Array containing the labels for columns in the histogram
         plot_classwise : bool, default False
             Whether to plot per-class balance instead of global balance
-        factor_type : "discrete", "continuous", or "both", default "discrete"
-            Whether to plot discretized values, continuous values, or to include both
 
         Returns
         -------
@@ -273,10 +232,10 @@ class BalanceOutput(Output):
             if row_labels is None:
                 row_labels = self.class_names
             if col_labels is None:
-                col_labels = self._by_factor_type("factor_names", factor_type)
+                col_labels = self.factor_names
 
             fig = heatmap(
-                self._by_factor_type("classwise", factor_type),
+                self.classwise,
                 row_labels,
                 col_labels,
                 xlabel="Factors",
@@ -287,8 +246,8 @@ class BalanceOutput(Output):
             # Combine balance and factors results
             data = np.concatenate(
                 [
-                    self._by_factor_type("balance", factor_type)[np.newaxis, 1:],
-                    self._by_factor_type("factors", factor_type),
+                    self.balance[np.newaxis, 1:],
+                    self.factors,
                 ],
                 axis=0,
             )
@@ -297,7 +256,7 @@ class BalanceOutput(Output):
             # Finalize the data for the plot, last row is last factor x last factor so it gets dropped
             heat_data = np.where(mask, np.nan, data)[:-1]
             # Creating label array for heat map axes
-            heat_labels = self._by_factor_type("factor_names", factor_type)
+            heat_labels = self.factor_names
 
             if row_labels is None:
                 row_labels = heat_labels[:-1]
@@ -320,16 +279,16 @@ class DiversityOutput(Output):
         :term:`Diversity` index for classes and factors
     classwise : NDArray[np.double]
         Classwise diversity index [n_class x n_factor]
-    factor_names : list[str]
+    factor_names : Sequence[str]
         Names of each metadata factor
-    class_names : list[str]
+    class_names : Sequence[str]
         Class labels for each value in the dataset
     """
 
     diversity_index: NDArray[np.double]
     classwise: NDArray[np.double]
-    factor_names: list[str]
-    class_names: list[str]
+    factor_names: Sequence[str]
+    class_names: Sequence[str]
 
     def plot(
         self,
@@ -377,7 +336,7 @@ class DiversityOutput(Output):
             import matplotlib.pyplot as plt
 
             fig, ax = plt.subplots(figsize=(8, 8))
-            heat_labels = np.concatenate((["class"], self.factor_names))
+            heat_labels = ["class_labels"] + list(self.factor_names)
             ax.bar(heat_labels, self.diversity_index)
             ax.set_xlabel("Factors")
             plt.setp(ax.get_xticklabels(), rotation=45, ha="right", rotation_mode="anchor")

dataeval/outputs/_estimators.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 __all__ = []
 
 from dataclasses import dataclass
+from typing import Sequence
 
 import numpy as np
 from numpy.typing import NDArray
@@ -64,7 +65,7 @@ class ClustererOutput(Output):
         """
         return np.nonzero(self.clusters == -1)[0]
 
-    def find_duplicates(self) -> tuple[list[list[int]], list[list[int]]]:
+    def find_duplicates(self) -> tuple[Sequence[Sequence[int]], Sequence[Sequence[int]]]:
         """
         Finds duplicate and near duplicate data based on cluster average distance
 

dataeval/outputs/_linters.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 __all__ = []
 
 from dataclasses import dataclass
-from typing import Generic, TypeVar, Union
+from typing import Generic, Mapping, Sequence, TypeVar, Union
 
 import pandas as pd
 from typing_extensions import TypeAlias
@@ -11,13 +11,13 @@ from typing_extensions import TypeAlias
 from dataeval.outputs._base import Output
 from dataeval.outputs._stats import DimensionStatsOutput, LabelStatsOutput, PixelStatsOutput, VisualStatsOutput
 
-DuplicateGroup: TypeAlias = list[int]
-DatasetDuplicateGroupMap: TypeAlias = dict[int, DuplicateGroup]
+DuplicateGroup: TypeAlias = Sequence[int]
+DatasetDuplicateGroupMap: TypeAlias = Mapping[int, DuplicateGroup]
 TIndexCollection = TypeVar("TIndexCollection", DuplicateGroup, DatasetDuplicateGroupMap)
 
-IndexIssueMap: TypeAlias = dict[int, dict[str, float]]
+IndexIssueMap: TypeAlias = Mapping[int, Mapping[str, float]]
 OutlierStatsOutput: TypeAlias = Union[DimensionStatsOutput, PixelStatsOutput, VisualStatsOutput]
-TIndexIssueMap = TypeVar("TIndexIssueMap", IndexIssueMap, list[IndexIssueMap])
+TIndexIssueMap = TypeVar("TIndexIssueMap", IndexIssueMap, Sequence[IndexIssueMap])
 
 
 @dataclass(frozen=True)
@@ -27,9 +27,9 @@ class DuplicatesOutput(Output, Generic[TIndexCollection]):
 
     Attributes
     ----------
-    exact : list[list[int] | dict[int, list[int]]]
+    exact : Sequence[Sequence[int] | Mapping[int, Sequence[int]]]
         Indices of images that are exact matches
-    near: list[list[int] | dict[int, list[int]]]
+    near: Sequence[Sequence[int] | Mapping[int, Sequence[int]]]
         Indices of images that are near matches
 
     Notes
@@ -39,13 +39,13 @@ class DuplicatesOutput(Output, Generic[TIndexCollection]):
       index of the dataset, and the value is the list index groups from that dataset.
     """
 
-    exact: list[TIndexCollection]
-    near: list[TIndexCollection]
+    exact: Sequence[TIndexCollection]
+    near: Sequence[TIndexCollection]
 
 
 def _reorganize_by_class_and_metric(
     result: IndexIssueMap, lstats: LabelStatsOutput
-) -> tuple[dict[str, list[int]], dict[str, dict[str, int]]]:
+) -> tuple[Mapping[str, Sequence[int]], Mapping[str, Mapping[str, int]]]:
     """Flip result from grouping by image to grouping by class and metric"""
     metrics: dict[str, list[int]] = {}
     class_wise: dict[str, dict[str, int]] = {label: {} for label in lstats.class_names}
@@ -61,7 +61,7 @@ def _reorganize_by_class_and_metric(
     return metrics, class_wise
 
 
-def _create_table(metrics: dict[str, list[int]], class_wise: dict[str, dict[str, int]]) -> list[str]:
+def _create_table(metrics: Mapping[str, Sequence[int]], class_wise: Mapping[str, Mapping[str, int]]) -> Sequence[str]:
     """Create table for displaying the results"""
     max_class_length = max(len(str(label)) for label in class_wise) + 2
     max_total = max(len(metrics[group]) for group in metrics) + 2
@@ -71,7 +71,7 @@ def _create_table(metrics: dict[str, list[int]], class_wise: dict[str, dict[str,
         + [f"{group:^{max(5, len(str(group))) + 2}}" for group in sorted(metrics.keys())]
         + [f"{'Total':<{max_total}}"]
     )
-    table_rows: list[str] = []
+    table_rows: Sequence[str] = []
 
     for class_cat, results in class_wise.items():
         table_value = [f"{class_cat:>{max_class_length}}"]
@@ -86,7 +86,7 @@ def _create_table(metrics: dict[str, list[int]], class_wise: dict[str, dict[str,
     return [table_header] + table_rows
 
 
-def _create_pandas_dataframe(class_wise: dict[str, dict[str, int]]) -> list[dict[str, str | int]]:
+def _create_pandas_dataframe(class_wise: Mapping[str, Mapping[str, int]]) -> Sequence[Mapping[str, str | int]]:
     """Create data for pandas dataframe"""
     data = []
     for label, metrics_dict in class_wise.items():
@@ -105,7 +105,7 @@ class OutliersOutput(Output, Generic[TIndexIssueMap]):
 
     Attributes
     ----------
-    issues : dict[int, dict[str, float]] | list[dict[int, dict[str, float]]]
+    issues : Mapping[int, Mapping[str, float]] | Sequence[Mapping[int, Mapping[str, float]]]
         Indices of image Outliers with their associated issue type and calculated values.
 
     - For a single dataset, a dictionary containing the indices of outliers and
@@ -117,7 +117,7 @@ class OutliersOutput(Output, Generic[TIndexIssueMap]):
     issues: TIndexIssueMap
 
     def __len__(self) -> int:
-        if isinstance(self.issues, dict):
+        if isinstance(self.issues, Mapping):
             return len(self.issues)
         return sum(len(d) for d in self.issues)
 
@@ -134,7 +134,7 @@ class OutliersOutput(Output, Generic[TIndexIssueMap]):
         -------
         str
         """
-        if isinstance(self.issues, dict):
+        if isinstance(self.issues, Mapping):
             metrics, classwise = _reorganize_by_class_and_metric(self.issues, labelstats)
             listed_table = _create_table(metrics, classwise)
             table = "\n".join(listed_table)
@@ -165,7 +165,7 @@ class OutliersOutput(Output, Generic[TIndexIssueMap]):
         -----
         This method requires `pandas <https://pandas.pydata.org/>`_ to be installed.
         """
-        if isinstance(self.issues, dict):
+        if isinstance(self.issues, Mapping):
             _, classwise = _reorganize_by_class_and_metric(self.issues, labelstats)
             data = _create_pandas_dataframe(classwise)
             df = pd.DataFrame(data)

dataeval/outputs/_stats.py

@@ -3,7 +3,7 @@ from __future__ import annotations
 __all__ = []
 
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any, Iterable, NamedTuple, Optional, Sequence, Union
+from typing import TYPE_CHECKING, Any, Iterable, Mapping, NamedTuple, Optional, Sequence, Union
 
 import numpy as np
 import pandas as pd
@@ -61,7 +61,7 @@ class BaseStatsOutput(Output):
         The number of detected objects in each image
     """
 
-    source_index: list[SourceIndex]
+    source_index: Sequence[SourceIndex]
     object_count: NDArray[np.uint16]
     image_count: int
 
@@ -80,7 +80,7 @@ class BaseStatsOutput(Output):
         self,
         channel_index: OptionalRange,
         channel_count: OptionalRange = None,
-    ) -> list[bool]:
+    ) -> Sequence[bool]:
         """
         Boolean mask for results filtered to specified channel index and optionally the count
         of the channels per image.
@@ -92,8 +92,8 @@ class BaseStatsOutput(Output):
         channel_count : int | Iterable[int] | None
             Optional count(s) of channels to filter for
         """
-        mask: list[bool] = []
-        cur_mask: list[bool] = []
+        mask: Sequence[bool] = []
+        cur_mask: Sequence[bool] = []
         cur_image = 0
         cur_max_channel = 0
         for source_index in list(self.source_index) + [None]:
@@ -113,7 +113,7 @@ class BaseStatsOutput(Output):
 
     def _get_channels(
         self, channel_limit: int | None = None, channel_index: int | Iterable[int] | None = None
-    ) -> tuple[int, list[bool] | None]:
+    ) -> tuple[int, Sequence[bool] | None]:
         source_index = self.data()[SOURCE_INDEX]
         raw_channels = int(max([si.channel or 0 for si in source_index])) + 1
         if isinstance(channel_index, int):
@@ -140,7 +140,7 @@ class BaseStatsOutput(Output):
         self,
         filter: str | Sequence[str] | None = None,  # noqa: A002
         exclude_constant: bool = False,
-    ) -> dict[str, NDArray[Any]]:
+    ) -> Mapping[str, NDArray[Any]]:
         """
         Returns all 1-dimensional data as a dictionary of numpy arrays.
 
@@ -153,7 +153,7 @@ class BaseStatsOutput(Output):
 
         Returns
         -------
-        dict[str, NDArray[Any]]
+        Mapping[str, NDArray[Any]]
         """
         filter_ = [filter] if isinstance(filter, str) else filter
         return {
@@ -253,8 +253,8 @@ class HashStatsOutput(BaseStatsOutput):
         :term:`Perception-based Hash` of the images as a hex string
     """
 
-    xxhash: list[str]
-    pchash: list[str]
+    xxhash: Sequence[str]
+    pchash: Sequence[str]
 
 
 @dataclass(frozen=True)
@@ -264,15 +264,15 @@ class LabelStatsOutput(Output):
 
     Attributes
     ----------
-    label_counts_per_class : dict[int, int]
+    label_counts_per_class : Mapping[int, int]
         Dictionary whose keys are the different label classes and
         values are total counts of each class
-    label_counts_per_image : list[int]
+    label_counts_per_image : Sequence[int]
         Number of labels per image
-    image_counts_per_class : dict[int, int]
+    image_counts_per_class : Mapping[int, int]
         Dictionary whose keys are the different label classes and
         values are total counts of each image the class is present in
-    image_indices_per_class : dict[int, list]
+    image_indices_per_class : Mapping[int, list]
         Dictionary whose keys are the different label classes and
         values are lists containing the images that have that label
     image_count : int
@@ -281,17 +281,17 @@ class LabelStatsOutput(Output):
         Total number of classes present
     label_count : int
         Total number of labels present
-    class_names : list[str]
+    class_names : Sequence[str]
     """
 
-    label_counts_per_class: list[int]
-    label_counts_per_image: list[int]
-    image_counts_per_class: list[int]
-    image_indices_per_class: list[list[int]]
+    label_counts_per_class: Sequence[int]
+    label_counts_per_image: Sequence[int]
+    image_counts_per_class: Sequence[int]
+    image_indices_per_class: Sequence[Sequence[int]]
     image_count: int
     class_count: int
     label_count: int
-    class_names: list[str]
+    class_names: Sequence[str]
 
     def to_table(self) -> str:
         """

dataeval/outputs/_utils.py

@@ -3,6 +3,7 @@ from __future__ import annotations
 __all__ = []
 
 from dataclasses import dataclass
+from typing import Sequence
 
 import numpy as np
 from numpy.typing import NDArray
@@ -36,9 +37,9 @@ class SplitDatasetOutput(Output):
     ----------
     test: NDArray[np.intp]
         Indices for the test set
-    folds: list[TrainValSplit]
+    folds: Sequence[TrainValSplit]
         List of train and validation split indices
     """
 
     test: NDArray[np.intp]
-    folds: list[TrainValSplit]
+    folds: Sequence[TrainValSplit]

dataeval/outputs/_workflows.py

@@ -177,7 +177,9 @@ def calc_params(p_i: NDArray[Any], n_i: NDArray[Any], niter: int) -> NDArray[Any
     return res.x
 
 
-def get_curve_params(measures: dict[str, NDArray[Any]], ranges: NDArray[Any], niter: int) -> dict[str, NDArray[Any]]:
+def get_curve_params(
+    measures: Mapping[str, NDArray[Any]], ranges: NDArray[Any], niter: int
+) -> Mapping[str, NDArray[Any]]:
     """Calculates and aggregates parameters for both single and multi-class metrics"""
     output = {}
     for name, measure in measures.items():
@@ -208,7 +210,7 @@ class SufficiencyOutput(Output):
     """
 
     steps: NDArray[np.uint32]
-    measures: dict[str, NDArray[np.float64]]
+    measures: Mapping[str, NDArray[np.float64]]
     n_iter: int = 1000
 
     def __post_init__(self) -> None:
@@ -220,7 +222,7 @@ class SufficiencyOutput(Output):
         self._params = None
 
     @property
-    def params(self) -> dict[str, NDArray[Any]]:
+    def params(self) -> Mapping[str, NDArray[Any]]:
         if self._params is None:
             self._params = {}
         if self.n_iter not in self._params:
@@ -270,7 +272,7 @@ class SufficiencyOutput(Output):
         proj._params = self._params
         return proj
 
-    def plot(self, class_names: Sequence[str] | None = None) -> list[Figure]:
+    def plot(self, class_names: Sequence[str] | None = None) -> Sequence[Figure]:
         """
         Plotting function for data :term:`sufficience<Sufficiency>` tasks.
 
@@ -281,7 +283,7 @@ class SufficiencyOutput(Output):
 
         Returns
         -------
-        list[Figure]
+        Sequence[Figure]
             List of Figures for each measure
 
         Raises
@@ -325,7 +327,7 @@ class SufficiencyOutput(Output):
 
     def inv_project(
         self, targets: Mapping[str, ArrayLike], n_iter: int | None = None
-    ) -> dict[str, NDArray[np.float64]]:
+    ) -> Mapping[str, NDArray[np.float64]]:
         """
         Calculate training samples needed to achieve target model metric values.
 
@@ -339,7 +341,7 @@ class SufficiencyOutput(Output):
 
         Returns
         -------
-        dict[str, NDArray]
+        Mapping[str, NDArray]
             List of the number of training samples needed to achieve each
             corresponding entry in targets
         """

dataeval/typing.py

@@ -21,7 +21,7 @@ __all__ = [
 
 
 import sys
-from typing import Any, Generic, Iterator, Protocol, TypedDict, TypeVar, runtime_checkable
+from typing import Any, Generic, Iterator, Mapping, Protocol, TypedDict, TypeVar, runtime_checkable
 
 import numpy.typing
 from typing_extensions import NotRequired, ReadOnly, Required
@@ -159,7 +159,7 @@ class AnnotatedDataset(Dataset[_T_co], Generic[_T_co], Protocol):
 # ========== IMAGE CLASSIFICATION DATASETS ==========
 
 
-ImageClassificationDatum: TypeAlias = tuple[ArrayLike, ArrayLike, dict[str, Any]]
+ImageClassificationDatum: TypeAlias = tuple[ArrayLike, ArrayLike, Mapping[str, Any]]
 """
 Type alias for an image classification datum tuple.
 
@@ -199,7 +199,7 @@ class ObjectDetectionTarget(Protocol):
     def scores(self) -> ArrayLike: ...
 
 
-ObjectDetectionDatum: TypeAlias = tuple[ArrayLike, ObjectDetectionTarget, dict[str, Any]]
+ObjectDetectionDatum: TypeAlias = tuple[ArrayLike, ObjectDetectionTarget, Mapping[str, Any]]
 """
 Type alias for an object detection datum tuple.
 
@@ -240,7 +240,7 @@ class SegmentationTarget(Protocol):
     def scores(self) -> ArrayLike: ...
 
 
-SegmentationDatum: TypeAlias = tuple[ArrayLike, SegmentationTarget, dict[str, Any]]
+SegmentationDatum: TypeAlias = tuple[ArrayLike, SegmentationTarget, Mapping[str, Any]]
 """
 Type alias for an image classification datum tuple.
 

dataeval/utils/_plot.py

@@ -4,7 +4,7 @@ __all__ = []
 
 import contextlib
 import math
-from typing import Any
+from typing import Any, Mapping, Sequence
 
 import numpy as np
 
@@ -134,7 +134,7 @@ def format_text(*args: str) -> str:
 
 
 def histogram_plot(
-    data_dict: dict[str, Any],
+    data_dict: Mapping[str, Any],
     log: bool = True,
     xlabel: str = "values",
     ylabel: str = "counts",
@@ -186,10 +186,10 @@ def histogram_plot(
 
 
 def channel_histogram_plot(
-    data_dict: dict[str, Any],
+    data_dict: Mapping[str, Any],
     log: bool = True,
     max_channels: int = 3,
-    ch_mask: list[bool] | None = None,
+    ch_mask: Sequence[bool] | None = None,
     xlabel: str = "values",
     ylabel: str = "counts",
 ) -> Figure: