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

dataeval/__init__.py

@@ -1,18 +1,22 @@
-__version__ = "0.65.0"
+__version__ = "0.66.0"
 
 from importlib.util import find_spec
 
-from . import detectors, flags, metrics
+_IS_TORCH_AVAILABLE = find_spec("torch") is not None
+_IS_TENSORFLOW_AVAILABLE = find_spec("tensorflow") is not None and find_spec("tensorflow_probability") is not None
+
+del find_spec
+
+from . import detectors, flags, metrics  # noqa: E402
 
 __all__ = ["detectors", "flags", "metrics"]
 
-if find_spec("torch") is not None:  # pragma: no cover
-    from . import models, utils, workflows
+if _IS_TORCH_AVAILABLE:  # pragma: no cover
+    from . import torch, utils, workflows
 
-    __all__ += ["models", "utils", "workflows"]
-elif find_spec("tensorflow") is not None:  # pragma: no cover
-    from . import models
+    __all__ += ["torch", "utils", "workflows"]
 
-    __all__ += ["models"]
+if _IS_TENSORFLOW_AVAILABLE:  # pragma: no cover
+    from . import tensorflow
 
-del find_spec
+    __all__ += ["tensorflow"]

dataeval/_internal/detectors/clusterer.py

@@ -1,5 +1,7 @@
+from __future__ import annotations
+
 from dataclasses import dataclass
-from typing import Dict, Iterable, List, NamedTuple, Tuple, Union, cast
+from typing import Iterable, NamedTuple, cast
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -26,10 +28,10 @@ class ClustererOutput(OutputMetadata):
         Groups of indices which are not exact but closely related data points
     """
 
-    outliers: List[int]
-    potential_outliers: List[int]
-    duplicates: List[List[int]]
-    potential_duplicates: List[List[int]]
+    outliers: list[int]
+    potential_outliers: list[int]
+    duplicates: list[list[int]]
+    potential_duplicates: list[list[int]]
 
 
 def extend_linkage(link_arr: NDArray) -> NDArray:
@@ -59,7 +61,7 @@ def extend_linkage(link_arr: NDArray) -> NDArray:
 class Cluster:
     __slots__ = "merged", "samples", "sample_dist", "is_copy", "count", "dist_avg", "dist_std", "out1", "out2"
 
-    def __init__(self, merged: int, samples: NDArray, sample_dist: Union[float, NDArray], is_copy: bool = False):
+    def __init__(self, merged: int, samples: NDArray, sample_dist: float | NDArray, is_copy: bool = False):
         self.merged = merged
         self.samples = np.array(samples, dtype=np.int32)
         self.sample_dist = np.array([sample_dist] if np.isscalar(sample_dist) else sample_dist)
@@ -81,7 +83,7 @@ class Cluster:
             self.out1 = dist > out1
             self.out2 = dist > out2
 
-    def copy(self) -> "Cluster":
+    def copy(self) -> Cluster:
         return Cluster(False, self.samples, self.sample_dist, True)
 
     def __repr__(self) -> str:
@@ -94,7 +96,7 @@ class Cluster:
         return f"{self.__class__.__name__}(**{repr(_params)})"
 
 
-class Clusters(Dict[int, Dict[int, Cluster]]):
+class Clusters(dict[int, dict[int, Cluster]]):
     def __init__(self, *args, **kwargs):
         super().__init__(*args, **kwargs)
         self.max_level: int = 1
@@ -116,10 +118,10 @@ class ClusterMergeEntry:
         self.inner_cluster = inner_cluster
         self.status = status
 
-    def __lt__(self, value: "ClusterMergeEntry") -> bool:
+    def __lt__(self, value: ClusterMergeEntry) -> bool:
         return self.level.__lt__(value.level)
 
-    def __gt__(self, value: "ClusterMergeEntry") -> bool:
+    def __gt__(self, value: ClusterMergeEntry) -> bool:
         return self.level.__gt__(value.level)
 
 
@@ -184,7 +186,7 @@ class Clusterer:
         return self._clusters
 
     @property
-    def last_good_merge_levels(self) -> Dict[int, int]:
+    def last_good_merge_levels(self) -> dict[int, int]:
         if self._last_good_merge_levels is None:
             self._last_good_merge_levels = self._get_last_merge_levels()
         return self._last_good_merge_levels
@@ -208,7 +210,7 @@ class Clusterer:
     def _create_clusters(self) -> Clusters:
         """Generates clusters based on linkage matrix"""
         next_cluster_id = 0
-        cluster_map: Dict[int, ClusterPosition] = {}  # Dictionary to associate new cluster ids with actual clusters
+        cluster_map: dict[int, ClusterPosition] = {}  # Dictionary to associate new cluster ids with actual clusters
         clusters: Clusters = Clusters()
 
         # Walking through the linkage array to generate clusters
@@ -236,7 +238,7 @@ class Clusterer:
                 # Update clusters to include previously skipped levels
                 clusters = self._fill_levels(clusters, left, right)
             elif left or right:
-                child, other_id = cast(Tuple[ClusterPosition, int], (left, right_id) if left else (right, left_id))
+                child, other_id = cast(tuple[ClusterPosition, int], (left, right_id) if left else (right, left_id))
                 cc = clusters[child.level][child.cid]
                 samples = np.concatenate([cc.samples, [other_id]])
                 sample_dist = np.concatenate([cc.sample_dist, sample_dist])
@@ -285,7 +287,7 @@ class Clusterer:
 
         return cluster_matrix
 
-    def _calc_merge_indices(self, merge_mean: List[NDArray], intra_max: List[float]) -> NDArray:
+    def _calc_merge_indices(self, merge_mean: list[NDArray], intra_max: list[float]) -> NDArray:
         """
         Determine what clusters should be merged and return their indices
         """
@@ -308,7 +310,7 @@ class Clusterer:
         mask2 = mask2_vals < one_std_check
         return np.logical_or(desired_merge, mask2)
 
-    def _generate_merge_list(self, cluster_matrix: NDArray) -> List[ClusterMergeEntry]:
+    def _generate_merge_list(self, cluster_matrix: NDArray) -> list[ClusterMergeEntry]:
         """
         Runs through the clusters dictionary determining when clusters merge,
         and how close are those clusters when they merge.
@@ -325,7 +327,7 @@ class Clusterer:
         """
         intra_max = []
         merge_mean = []
-        merge_list: List[ClusterMergeEntry] = []
+        merge_list: list[ClusterMergeEntry] = []
 
         for level, cluster_set in self.clusters.items():
             for outer_cluster, cluster in cluster_set.items():
@@ -363,7 +365,7 @@ class Clusterer:
 
         return merge_list
 
-    def _get_last_merge_levels(self) -> Dict[int, int]:
+    def _get_last_merge_levels(self) -> dict[int, int]:
         """
         Creates a dictionary for important cluster ids mapped to their last good merge level
 
@@ -372,7 +374,7 @@ class Clusterer:
         Dict[int, int]
             A mapping of a cluster id to its last good merge level
         """
-        last_merge_levels: Dict[int, int] = {}
+        last_merge_levels: dict[int, int] = {}
 
         if self._max_clusters <= 1:
             last_merge_levels = {0: int(self._num_samples * 0.1)}
@@ -395,7 +397,7 @@ class Clusterer:
 
         return last_merge_levels
 
-    def find_outliers(self, last_merge_levels: Dict[int, int]) -> Tuple[List[int], List[int]]:
+    def find_outliers(self, last_merge_levels: dict[int, int]) -> tuple[list[int], list[int]]:
         """
         Retrieves outliers based on when the sample was added to the cluster
         and how far it was from the cluster when it was added
@@ -439,9 +441,9 @@ class Clusterer:
 
         return sorted(outliers), sorted(possible_outliers)
 
-    def _sorted_union_find(self, index_groups: Iterable[Iterable[int]]) -> List[List[int]]:
+    def _sorted_union_find(self, index_groups: Iterable[Iterable[int]]) -> list[list[int]]:
         """Merges and sorts groups of indices that share any common index"""
-        groups: List[List[int]] = []
+        groups: list[list[int]] = []
         for indices in zip(*index_groups):
             indices = set(indices)
             temp = []
@@ -454,7 +456,7 @@ class Clusterer:
             groups = temp
         return sorted(groups)
 
-    def find_duplicates(self, last_merge_levels: Dict[int, int]) -> Tuple[List[List[int]], List[List[int]]]:
+    def find_duplicates(self, last_merge_levels: dict[int, int]) -> tuple[list[list[int]], list[list[int]]]:
         """
         Finds duplicate and near duplicate data based on the last good merge levels when building the cluster
 

dataeval/_internal/detectors/drift/base.py

@@ -6,10 +6,12 @@ Original code Copyright (c) 2023 Seldon Technologies Ltd
 Licensed under Apache Software License (Apache 2.0)
 """
 
+from __future__ import annotations
+
 from abc import ABC, abstractmethod
 from dataclasses import dataclass
 from functools import wraps
-from typing import Callable, Literal, Optional, Tuple
+from typing import Callable, Literal
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -19,27 +21,40 @@ from dataeval._internal.output import OutputMetadata, set_metadata
 
 
 @dataclass(frozen=True)
-class DriftOutput(OutputMetadata):
+class DriftBaseOutput(OutputMetadata):
+    """
+    Output class for Drift
+
+    Attributes
+    ----------
+    is_drift : bool
+        Drift prediction for the images
+    threshold : float
+        Threshold after multivariate correction if needed
+    """
+
     is_drift: bool
     threshold: float
 
 
 @dataclass(frozen=True)
-class DriftUnivariateOutput(DriftOutput):
+class DriftOutput(DriftBaseOutput):
     """
+    Output class for DriftCVM and DriftKS
+
     Attributes
     ----------
     is_drift : bool
         Drift prediction for the images
     threshold : float
         Threshold after multivariate correction if needed
-    feature_drift : NDArray[np.bool_]
+    feature_drift : NDArray
         Feature-level array of images detected to have drifted
     feature_threshold : float
         Feature-level threshold to determine drift
-    p_vals : NDArray[np.float32]
+    p_vals : NDArray
         Feature-level p-values
-    distances : NDArray[np.float32]
+    distances : NDArray
         Feature-level distances
     """
 
@@ -83,6 +98,15 @@ def preprocess_x(fn):
 
 
 class UpdateStrategy(ABC):
+    """
+    Updates reference dataset for drift detector
+
+    Parameters
+    ----------
+    n : int
+        Update with last n instances seen by the detector.
+    """
+
     def __init__(self, n: int):
         self.n = n
 
@@ -113,7 +137,7 @@ class ReservoirSamplingUpdate(UpdateStrategy):
     Parameters
     ----------
     n : int
-        Update with reservoir sampling of size n.
+        Update with last n instances seen by the detector.
     """
 
     def __call__(self, x_ref: NDArray, x: NDArray, count: int) -> NDArray:
@@ -138,15 +162,64 @@ class ReservoirSamplingUpdate(UpdateStrategy):
 
 
 class BaseDrift:
-    """Generic drift detector component handling preprocessing of data and correction"""
+    """
+    A generic drift detection component for preprocessing data and applying statistical correction.
+
+    This class handles common tasks related to drift detection, such as preprocessing
+    the reference data (`x_ref`), performing statistical correction (e.g., Bonferroni, FDR),
+    and updating the reference data if needed.
+
+    Parameters
+    ----------
+    x_ref : ArrayLike
+        The reference dataset used for drift detection. This is the baseline data against
+        which new data points will be compared.
+    p_val : float, optional
+        The significance level for detecting drift, by default 0.05.
+    x_ref_preprocessed : bool, optional
+        Flag indicating whether the reference data has already been preprocessed, by default False.
+    update_x_ref : UpdateStrategy, optional
+        A strategy object specifying how the reference data should be updated when drift is detected,
+        by default None.
+    preprocess_fn : Callable[[ArrayLike], ArrayLike], optional
+        A function to preprocess the data before drift detection, by default None.
+    correction : {'bonferroni', 'fdr'}, optional
+        Statistical correction method applied to p-values, by default "bonferroni".
+
+    Attributes
+    ----------
+    _x_ref : ArrayLike
+        The reference dataset that is either raw or preprocessed.
+    p_val : float
+        The significance level for drift detection.
+    update_x_ref : UpdateStrategy or None
+        The strategy for updating the reference data if applicable.
+    preprocess_fn : Callable or None
+        Function used for preprocessing input data before drift detection.
+    correction : str
+        Statistical correction method applied to p-values.
+    n : int
+        The number of samples in the reference dataset (`x_ref`).
+    x_ref_preprocessed : bool
+        A flag that indicates whether the reference dataset has been preprocessed.
+    _x_refcount : int
+        Counter for how many times the reference data has been accessed after preprocessing.
+
+    Methods
+    -------
+    x_ref:
+        Property that returns the reference dataset, and applies preprocessing if not already done.
+    _preprocess(x):
+        Preprocesses the given data using the specified `preprocess_fn` if provided.
+    """
 
     def __init__(
         self,
         x_ref: ArrayLike,
         p_val: float = 0.05,
         x_ref_preprocessed: bool = False,
-        update_x_ref: Optional[UpdateStrategy] = None,
-        preprocess_fn: Optional[Callable[[ArrayLike], ArrayLike]] = None,
+        update_x_ref: UpdateStrategy | None = None,
+        preprocess_fn: Callable[[ArrayLike], ArrayLike] | None = None,
         correction: Literal["bonferroni", "fdr"] = "bonferroni",
     ) -> None:
         # Type checking
@@ -172,6 +245,14 @@ class BaseDrift:
 
     @property
     def x_ref(self) -> NDArray:
+        """
+        Retrieve the reference data, applying preprocessing if not already done.
+
+        Returns
+        -------
+        NDArray
+            The reference dataset (`x_ref`), preprocessed if needed.
+        """
         if not self.x_ref_preprocessed:
             self.x_ref_preprocessed = True
             if self.preprocess_fn is not None:
@@ -181,7 +262,19 @@ class BaseDrift:
         return self._x_ref
 
     def _preprocess(self, x: ArrayLike) -> ArrayLike:
-        """Data preprocessing before computing the drift scores."""
+        """
+        Preprocess the given data before computing the drift scores.
+
+        Parameters
+        ----------
+        x : ArrayLike
+            The input data to preprocess.
+
+        Returns
+        -------
+        ArrayLike
+            The preprocessed input data.
+        """
         if self.preprocess_fn is not None:
             x = self.preprocess_fn(x)
         return x
@@ -189,10 +282,55 @@ class BaseDrift:
 
 class BaseDriftUnivariate(BaseDrift):
     """
-    Generic drift detector component which serves as a base class for methods using
-    univariate tests. If n_features > 1, a multivariate correction is applied such
-    that the false positive rate is upper bounded by the specified p-value, with
-    equality in the case of independent features.
+    Base class for drift detection methods using univariate statistical tests.
+
+    This class inherits from `BaseDrift` and serves as a generic component for detecting
+    distribution drift in univariate features. If the number of features `n_features` is greater
+    than 1, a multivariate correction method (e.g., Bonferroni or FDR) is applied to control
+    the false positive rate, ensuring it does not exceed the specified p-value.
+
+    Parameters
+    ----------
+    x_ref : ArrayLike
+        Reference data used as the baseline to compare against when detecting drift.
+    p_val : float, default 0.05
+        Significance level used for detecting drift.
+    x_ref_preprocessed : bool, default False
+        Indicates whether the reference data has been preprocessed.
+    update_x_ref : UpdateStrategy | None, default None
+        Strategy for updating the reference data when drift is detected.
+    preprocess_fn : Callable[ArrayLike] | None, default None
+        Function used to preprocess input data before detecting drift.
+    correction : 'bonferroni' | 'fdr', default 'bonferroni'
+        Multivariate correction method applied to p-values.
+    n_features : int | None, default None
+        Number of features used in the univariate drift tests. If not provided, it will
+        be inferred from the data.
+
+    Attributes
+    ----------
+    _n_features : int | None
+        Number of features in the data. If not provided, it is lazily inferred from the
+        input data and any preprocessing function.
+    p_val : float
+        The significance level for drift detection.
+    correction : str
+        The method for controlling the false discovery rate or applying a Bonferroni correction.
+    update_x_ref : UpdateStrategy | None
+        Strategy for updating the reference data if applicable.
+    preprocess_fn : Callable | None
+        Function used for preprocessing input data before drift detection.
+
+    Methods
+    -------
+    n_features:
+        Property that returns the number of features, inferring it if necessary.
+    score(x):
+        Abstract method to compute univariate feature scores after preprocessing.
+    _apply_correction(p_vals):
+        Apply a statistical correction to p-values to account for multiple testing.
+    predict(x):
+        Predict whether drift has occurred on a batch of data, applying multivariate correction if needed.
     """
 
     def __init__(
@@ -200,10 +338,10 @@ class BaseDriftUnivariate(BaseDrift):
         x_ref: ArrayLike,
         p_val: float = 0.05,
         x_ref_preprocessed: bool = False,
-        update_x_ref: Optional[UpdateStrategy] = None,
-        preprocess_fn: Optional[Callable[[ArrayLike], ArrayLike]] = None,
+        update_x_ref: UpdateStrategy | None = None,
+        preprocess_fn: Callable[[ArrayLike], ArrayLike] | None = None,
         correction: Literal["bonferroni", "fdr"] = "bonferroni",
-        n_features: Optional[int] = None,
+        n_features: int | None = None,
     ) -> None:
         super().__init__(
             x_ref,
@@ -218,6 +356,18 @@ class BaseDriftUnivariate(BaseDrift):
 
     @property
     def n_features(self) -> int:
+        """
+        Get the number of features in the reference data.
+
+        If the number of features is not provided during initialization, it will be inferred
+        from the reference data (``x_ref``). If a preprocessing function is provided, the number
+        of features will be inferred after applying the preprocessing function.
+
+        Returns
+        -------
+        int
+            Number of features in the reference data.
+        """
         # lazy process n_features as needed
         if not isinstance(self._n_features, int):
             # compute number of features for the univariate tests
@@ -233,10 +383,40 @@ class BaseDriftUnivariate(BaseDrift):
 
     @preprocess_x
     @abstractmethod
-    def score(self, x: ArrayLike) -> Tuple[NDArray[np.float32], NDArray[np.float32]]:
-        """Abstract method to calculate feature score after preprocessing"""
+    def score(self, x: ArrayLike) -> tuple[NDArray[np.float32], NDArray[np.float32]]:
+        """
+        Abstract method to calculate feature scores after preprocessing.
+
+        Parameters
+        ----------
+        x : ArrayLike
+            The batch of data to calculate univariate drift scores for each feature.
+
+        Returns
+        -------
+        tuple[NDArray, NDArray]
+            A tuple containing p-values and distance statistics for each feature.
+        """
 
-    def _apply_correction(self, p_vals: NDArray) -> Tuple[bool, float]:
+    def _apply_correction(self, p_vals: NDArray) -> tuple[bool, float]:
+        """
+        Apply the specified correction method (Bonferroni or FDR) to the p-values.
+
+        If the correction method is Bonferroni, the threshold for detecting drift
+        is divided by the number of features. For FDR, the correction is applied
+        using the Benjamini-Hochberg procedure.
+
+        Parameters
+        ----------
+        p_vals : NDArray
+            Array of p-values from the univariate tests for each feature.
+
+        Returns
+        -------
+        tuple[bool, float]
+            A tuple containing a boolean indicating if drift was detected and the
+            threshold after correction.
+        """
         if self.correction == "bonferroni":
             threshold = self.p_val / self.n_features
             drift_pred = bool((p_vals < threshold).any())
@@ -261,7 +441,7 @@ class BaseDriftUnivariate(BaseDrift):
     def predict(
         self,
         x: ArrayLike,
-    ) -> DriftUnivariateOutput:
+    ) -> DriftOutput:
         """
         Predict whether a batch of data has drifted from the reference data and update
         reference data using specified update strategy.
@@ -273,13 +453,13 @@ class BaseDriftUnivariate(BaseDrift):
 
         Returns
         -------
-        Dictionary containing the drift prediction and optionally the feature level
-                p-values, threshold after multivariate correction if needed and test
-                statistics.
+        DriftOutput
+            Dictionary containing the drift prediction and optionally the feature level
+            p-values, threshold after multivariate correction if needed and test statistics.
         """
         # compute drift scores
         p_vals, dist = self.score(x)
 
         feature_drift = (p_vals < self.p_val).astype(np.bool_)
         drift_pred, threshold = self._apply_correction(p_vals)
-        return DriftUnivariateOutput(drift_pred, threshold, feature_drift, self.p_val, p_vals, dist)
+        return DriftOutput(drift_pred, threshold, feature_drift, self.p_val, p_vals, dist)

dataeval/_internal/detectors/drift/cvm.py

@@ -6,7 +6,9 @@ Original code Copyright (c) 2023 Seldon Technologies Ltd
 Licensed under Apache Software License (Apache 2.0)
 """
 
-from typing import Callable, Literal, Optional, Tuple
+from __future__ import annotations
+
+from typing import Callable, Literal
 
 import numpy as np
 from numpy.typing import ArrayLike, NDArray
@@ -19,37 +21,36 @@ from .base import BaseDriftUnivariate, UpdateStrategy, preprocess_x
 
 class DriftCVM(BaseDriftUnivariate):
     """
-    Cramér-von Mises (CVM) data drift detector, which tests for any change in the
-    distribution of continuous univariate data. For multivariate data, a separate
-    CVM test is applied to each feature, and the obtained p-values are aggregated
-    via the Bonferroni or False Discovery Rate (FDR) corrections.
+    Drift detector employing the Cramér-von Mises (CVM) distribution test.
+
+    The CVM test detects changes in the distribution of continuous
+    univariate data. For multivariate data, a separate CVM test is applied to each
+    feature, and the obtained p-values are aggregated via the Bonferroni or
+    False Discovery Rate (FDR) corrections.
 
     Parameters
     ----------
     x_ref : ArrayLike
         Data used as reference distribution.
-    p_val : float, default 0.05
+    p_val : float | None, default 0.05
         p-value used for significance of the statistical test for each feature.
         If the FDR correction method is used, this corresponds to the acceptable
         q-value.
     x_ref_preprocessed : bool, default False
-        Whether the given reference data `x_ref` has been preprocessed yet. If
-        `x_ref_preprocessed=True`, only the test data `x` will be preprocessed at
-        prediction time. If `x_ref_preprocessed=False`, the reference data will also
-        be preprocessed.
-    update_x_ref : Optional[UpdateStrategy], default None
+        Whether the given reference data ``x_ref`` has been preprocessed yet.
+        If ``True``, only the test data ``x`` will be preprocessed at prediction time.
+        If ``False``, the reference data will also be preprocessed.
+    update_x_ref : UpdateStrategy | None, default None
         Reference data can optionally be updated using an UpdateStrategy class. Update
-        using the last n instances seen by the detector with
-        :py:class:`dataeval.detectors.LastSeenUpdateStrategy`
-        or via reservoir sampling with
-        :py:class:`dataeval.detectors.ReservoirSamplingUpdateStrategy`.
-    preprocess_fn : Optional[Callable[[ArrayLike], ArrayLike]], default None
+        using the last n instances seen by the detector with LastSeenUpdateStrategy
+        or via reservoir sampling with ReservoirSamplingUpdateStrategy.
+    preprocess_fn : Callable | None, default None
         Function to preprocess the data before computing the data drift metrics.
         Typically a dimensionality reduction technique.
-    correction : Literal["bonferroni", "fdr"], default "bonferroni"
+    correction : "bonferroni" | "fdr", default "bonferroni"
         Correction type for multivariate data. Either 'bonferroni' or 'fdr' (False
         Discovery Rate).
-    n_features
+    n_features : int | None, default None
         Number of features used in the statistical test. No need to pass it if no
         preprocessing takes place. In case of a preprocessing step, this can also
         be inferred automatically but could be more expensive to compute.
@@ -60,10 +61,10 @@ class DriftCVM(BaseDriftUnivariate):
         x_ref: ArrayLike,
         p_val: float = 0.05,
         x_ref_preprocessed: bool = False,
-        update_x_ref: Optional[UpdateStrategy] = None,
-        preprocess_fn: Optional[Callable[[ArrayLike], ArrayLike]] = None,
+        update_x_ref: UpdateStrategy | None = None,
+        preprocess_fn: Callable[[ArrayLike], ArrayLike] | None = None,
         correction: Literal["bonferroni", "fdr"] = "bonferroni",
-        n_features: Optional[int] = None,
+        n_features: int | None = None,
     ) -> None:
         super().__init__(
             x_ref=x_ref,
@@ -76,7 +77,7 @@ class DriftCVM(BaseDriftUnivariate):
         )
 
     @preprocess_x
-    def score(self, x: ArrayLike) -> Tuple[NDArray[np.float32], NDArray[np.float32]]:
+    def score(self, x: ArrayLike) -> tuple[NDArray[np.float32], NDArray[np.float32]]:
         """
         Performs the two-sample Cramér-von Mises test(s), computing the p-value and
         test statistic per feature.
@@ -88,7 +89,8 @@ class DriftCVM(BaseDriftUnivariate):
 
         Returns
         -------
-        Feature level p-values and CVM statistics.
+        tuple[NDArray, NDArray]
+            Feature level p-values and CVM statistic
         """
         x_np = to_numpy(x)
         x_np = x_np.reshape(x_np.shape[0], -1)