AutoCarver 7.2.1__tar.gz → 7.2.2__tar.gz

{autocarver-7.2.1 → autocarver-7.2.2}/AutoCarver/carvers/binary_carver.py

@@ -65,7 +65,7 @@ class BinaryCarver(BaseCarver):
             config=config,
         )
 
-    def _prepare_data(self, samples: Samples) -> Samples:
+    def _prepare_samples(self, samples: Samples) -> Samples:
         """Validates format and content of X and y."""
         if samples.train.y is None:
             raise ValueError(f"[{self.__name__}] y must be provided")
@@ -73,9 +73,9 @@ class BinaryCarver(BaseCarver):
         if not ((0 in y_values) and (1 in y_values)) or len(y_values) != 2:
             raise ValueError(f"[{self.__name__}] y must be a binary Series of 0 and 1 (int or float, not object)")
 
-        return super()._prepare_data(samples)
+        return super()._prepare_samples(samples)
 
-    def _aggregator(self, X: pd.DataFrame, y: pd.Series) -> dict[str, pd.DataFrame | None]:
+    def _aggregator(self, X: pd.DataFrame, y: pd.Series) -> dict[str, pd.Series | pd.DataFrame | None]:
         """Computes crosstabs for specified features and ensures that the crosstab is ordered
         according to the known labels"""
         # checking for empty datasets (dev)

{autocarver-7.2.1 → autocarver-7.2.2}/AutoCarver/carvers/continuous_carver.py

@@ -63,7 +63,7 @@ class ContinuousCarver(BaseCarver):
             config=config,
         )
 
-    def _prepare_data(self, samples: Samples) -> Samples:
+    def _prepare_samples(self, samples: Samples) -> Samples:
         """Validates format and content of X and y."""
         if samples.train.y is None:
             raise ValueError(f"[{self.__name__}] y must be provided")
@@ -74,9 +74,9 @@ class ContinuousCarver(BaseCarver):
         if len(y_values) <= 2:
             raise ValueError(f"[{self.__name__}] provided y is binary, consider using BinaryCarver instead.")
 
-        return super()._prepare_data(samples)
+        return super()._prepare_samples(samples)
 
-    def _aggregator(self, X: pd.DataFrame, y: pd.Series) -> dict[str, pd.DataFrame | None]:
+    def _aggregator(self, X: pd.DataFrame, y: pd.Series) -> dict[str, pd.Series | pd.DataFrame | None]:
         """Computes y values for modalities of specified features and ensures the ordering
         according to the known labels"""
         # checking for empty datasets
@@ -98,4 +98,4 @@ def get_target_values_by_modality(X: pd.DataFrame, y: pd.Series, feature: BaseFe
 
     # reindexing to ensure the right order (labels may be None pre-fit; pandas
     # treats None as "no reindex" so the original ordering is kept)
-    return yval.reindex(feature.labels, fill_value=[])  # type: ignore[arg-type]
+    return yval.reindex(feature.labels, fill_value=[])  # type: ignore

{autocarver-7.2.1 → autocarver-7.2.2}/AutoCarver/carvers/multiclass_carver.py

@@ -53,7 +53,7 @@ class MulticlassCarver(BinaryCarver):
         if self.config.copy:
             print("WARNING: can't set copy=True for MulticlassCarver (no inplace DataFrame.assign).")
 
-    def _prepare_data(self, samples: Samples) -> Samples:
+    def _prepare_samples(self, samples: Samples) -> Samples:
         """Validates format and content of X and y."""
         # converting target to str (y is required by Carver.fit)
         if samples.train.y is None:
@@ -93,11 +93,11 @@ class MulticlassCarver(BinaryCarver):
         samples = Samples(train=Sample(X, y), dev=Sample(X_dev, y_dev))
 
         # preparing datasets and checking for wrong values
-        samples = self._prepare_data(samples)
+        samples = self._prepare_samples(samples)
 
-        # getting distinct y classes (_prepare_data raises if y is missing)
-        assert samples.train.y is not None
-        y_classes = sorted(samples.train.y.unique().tolist())[1:]  # removing one of the classes
+        # getting distinct y classes (_prepare_samples raises if y is missing)
+        # removing one of the classes
+        y_classes = sorted(samples.train.y.unique().tolist())[1:]  # type: ignore
 
         # adding versionned features
         self.features.add_feature_versions(y_classes)
@@ -125,7 +125,12 @@ class MulticlassCarver(BinaryCarver):
                 config=replace(self.config, copy=True),
             )
 
-            binary_carver.fit_transform(samples.train.X, train_y_class, X_dev=samples.dev.X, y_dev=dev_y_class)
+            binary_carver.fit_transform(
+                samples.train.X,
+                train_y_class,
+                X_dev=samples.dev.X if samples.dev.has_X else None,
+                y_dev=dev_y_class,
+            )
 
             # filtering out dropped features whilst keeping other version tags
             kept_features = binary_carver.features.versions

{autocarver-7.2.1 → autocarver-7.2.2}/AutoCarver/carvers/utils/base_carver.py

@@ -41,13 +41,13 @@ class Samples:
         dev (Sample): The development sample, containing features (X) and target (y).
     """
 
-    train: Sample = field(default_factory=lambda: Sample(X=None))
-    dev: Sample = field(default_factory=lambda: Sample(X=None))
+    train: Sample = field(default_factory=Sample)
+    dev: Sample = field(default_factory=Sample)
 
     def fillna(self, features: Features) -> None:
         """fills up nans in X and X_dev"""
         self.train.X = features.fillna(self.train.X)
-        if self.dev.X is not None:
+        if self.dev.has_X:
             self.dev.X = features.fillna(self.dev.X)
 
 
@@ -175,14 +175,14 @@ class BaseCarver(BaseDiscretizer, ABC):
         content["combination_evaluator"] = self.combination_evaluator.to_json()
         return content
 
-    def _prepare_data(self, samples: Samples) -> Samples:
+    def _prepare_samples(self, samples: Samples) -> Samples:
         """Validates format and content of X and y."""
         if samples.train.y is None:
             raise ValueError(f"[{self.__name__}] y must be provided, got {samples.train.y}")
 
         # Checking for binary target and copying X
-        samples.train = super()._prepare_data(samples.train)
-        samples.dev = super()._prepare_data(samples.dev)
+        samples.train = super()._prepare_sample(samples.train)
+        samples.dev = super()._prepare_sample(samples.dev)
 
         # discretizing features at half min_freq so the carver has a finer
         # granularity to combine when forming optimal groups
@@ -196,7 +196,7 @@ class BaseCarver(BaseDiscretizer, ABC):
 
         return samples
 
-    def fit(  # pylint: disable=W0222
+    def fit(  # type: ignore
         self,
         X: pd.DataFrame,
         y: pd.Series,
@@ -235,7 +235,7 @@ class BaseCarver(BaseDiscretizer, ABC):
         samples = Samples(Sample(X, y), Sample(X_dev, y_dev))
 
         # preparing datasets and checking for wrong values
-        samples = self._prepare_data(samples)
+        samples = self._prepare_samples(samples)
 
         # logging if requested
         super()._log_if_verbose("---------\n------")
@@ -329,10 +329,11 @@ class BaseCarver(BaseDiscretizer, ABC):
 
         # printing carved distribution, for found, suitable combination
         if best_combination is not None:
+            dev_sample = self.combination_evaluator.samples.dev
             self._print_xagg(
                 feature,
                 xagg=self.combination_evaluator.samples.train.xagg,
-                xagg_dev=self.combination_evaluator.samples.dev.xagg,
+                xagg_dev=dev_sample.xagg if dev_sample.has_xagg else None,
                 message="Carved distribution",
             )
 
@@ -482,7 +483,7 @@ def discretize(
     samples.train.X = discretizer.fit_transform(**samples.train)
 
     # applying discretizer on X_dev if provided
-    if samples.dev.X is not None:
+    if samples.dev.has_X:
         samples.dev.X = discretizer.transform(**samples.dev)
 
     return samples

{autocarver-7.2.1 → autocarver-7.2.2}/AutoCarver/carvers/utils/pretty_print.py

@@ -44,14 +44,14 @@ def prettier_xagg(
 
         # adding custom caption/title
         if caption is not None:
-            nicer_xagg = nicer_xagg.set_caption(caption)
+            nicer_xagg = nicer_xagg.set_caption(caption)  # type: ignore
 
         # hiding index for dev
         if hide_index:
-            nicer_xagg.hide(axis="index")
+            nicer_xagg.hide(axis="index")  # type: ignore
 
         # converting to html
-        nicer_xagg = nicer_xagg._repr_html_()  # pylint: disable=W0212
+        nicer_xagg = nicer_xagg._repr_html_()  # type: ignore
 
     return nicer_xagg
 

{autocarver-7.2.1 → autocarver-7.2.2}/AutoCarver/combinations/binary/binary_combination_evaluators.py

@@ -14,15 +14,19 @@ from AutoCarver.combinations.utils.combination_evaluator import (
     CombinationEvaluator,
 )
 from AutoCarver.combinations.utils.combinations import combination_formatter
+from AutoCarver.combinations.utils.target_rate import TargetRate
 
 
-class BinaryCombinationEvaluator(CombinationEvaluator, ABC):
+class BinaryCombinationEvaluator(CombinationEvaluator[pd.DataFrame], ABC):
     """Binary combination evaluator class."""
 
     is_y_binary = True
     _target_rate_classes: list[type[BinaryTargetRate]] = [TargetMean, OddsRatio, Woe]
+    # narrow inherited attribute: binary evaluators always carry a BinaryTargetRate
+    # (enforced by _init_target_rate).
+    target_rate: BinaryTargetRate
 
-    def _init_target_rate(self, target_rate: BinaryTargetRate | None) -> BinaryTargetRate:
+    def _init_target_rate(self, target_rate: TargetRate[pd.DataFrame] | None) -> BinaryTargetRate:
         """Initializes target rate."""
         if target_rate is None:
             return TargetMean()
@@ -31,8 +35,11 @@ class BinaryCombinationEvaluator(CombinationEvaluator, ABC):
         return target_rate
 
     def _association_measure(
-        self, xagg: AggregatedSample, n_obs: int | None = None, tol: float = 1e-10
-    ) -> dict[str, float]:
+        self,
+        xagg: AggregatedSample | pd.Series | pd.DataFrame,
+        n_obs: int | None = None,
+        tol: float = 1e-10,
+    ) -> dict[str, float | None]:
         """Computes measures of association between feature and target by crosstab.
 
         Used for the raw (one-shot) distribution. The hot per-combination loop

{autocarver-7.2.1 → autocarver-7.2.2}/AutoCarver/combinations/binary/binary_target_rates.py

@@ -1,6 +1,7 @@
 """set of target rates for binary classification"""
 
 from abc import ABC
+from typing import overload
 
 import numpy as np
 import pandas as pd
@@ -8,12 +9,16 @@ import pandas as pd
 from AutoCarver.combinations.utils import TargetRate
 
 
-class BinaryTargetRate(TargetRate, ABC):
+class BinaryTargetRate(TargetRate[pd.DataFrame], ABC):
     """Binary target rate class."""
 
     __name__ = "binary_target_rate"
 
-    def compute(self, xagg: pd.DataFrame) -> pd.DataFrame:
+    @overload
+    def compute(self, xagg: pd.Series | pd.DataFrame) -> pd.DataFrame: ...
+    @overload
+    def compute(self, xagg: None) -> None: ...
+    def compute(self, xagg: pd.Series | pd.DataFrame | None) -> pd.DataFrame | None:
         """Computes the target rate.
 
         Parameters
@@ -31,8 +36,12 @@ class BinaryTargetRate(TargetRate, ABC):
             # frequency per modality
             frequency = xagg.sum(axis=1) / xagg.sum().sum()
 
-            # computing target rate
-            return pd.DataFrame({self.__name__: self._compute(xagg), "frequency": frequency})
+            # computing target rate. `_compute` expects pd.DataFrame (Generic
+            # XAgg=DataFrame); compute()'s wide signature is for LSP matching,
+            # callers always pass a crosstab here.
+            return pd.DataFrame(
+                {self.__name__: self._compute(xagg), "frequency": frequency}  # type: ignore
+            )
         return None
 
 

{autocarver-7.2.1 → autocarver-7.2.2}/AutoCarver/combinations/continuous/continuous_combination_evaluators.py

@@ -2,6 +2,7 @@
 
 from abc import ABC
 from collections.abc import Iterable, Iterator
+from typing import Any
 
 import numpy as np
 import pandas as pd
@@ -11,10 +12,11 @@ from tqdm import tqdm
 from AutoCarver.combinations.continuous.continuous_target_rates import ContinuousTargetRate, TargetMean, TargetMedian
 from AutoCarver.combinations.utils.combination_evaluator import AggregatedSample, CombinationEvaluator
 from AutoCarver.combinations.utils.combinations import combination_formatter
+from AutoCarver.combinations.utils.target_rate import TargetRate
 from AutoCarver.combinations.utils.testing import Keys, is_viable, test_viability
 
 
-class ContinuousCombinationEvaluator(CombinationEvaluator, ABC):
+class ContinuousCombinationEvaluator(CombinationEvaluator[pd.Series], ABC):
     """Continuous combination evaluator class."""
 
     is_y_continuous = True
@@ -23,7 +25,7 @@ class ContinuousCombinationEvaluator(CombinationEvaluator, ABC):
     # carvers always carry a ContinuousTargetRate (enforced by _init_target_rate).
     target_rate: ContinuousTargetRate
 
-    def _init_target_rate(self, target_rate: ContinuousTargetRate | None) -> ContinuousTargetRate:
+    def _init_target_rate(self, target_rate: TargetRate[pd.Series] | None) -> ContinuousTargetRate:
         """Initializes target rate."""
         if target_rate is None:
             return TargetMean()
@@ -32,7 +34,10 @@ class ContinuousCombinationEvaluator(CombinationEvaluator, ABC):
         return target_rate
 
     def _association_measure(
-        self, xagg: AggregatedSample, n_obs: int | None = None, tol: float = 1e-10
+        self,
+        xagg: AggregatedSample | pd.Series | pd.DataFrame,
+        n_obs: int | None = None,
+        tol: float = 1e-10,
     ) -> dict[str, float | None]:
         """Computes measures of association between feature and quantitative target.
 
@@ -138,8 +143,8 @@ class ContinuousCombinationEvaluator(CombinationEvaluator, ABC):
           :meth:`_association_measure`).
         """
         raw_xagg = self.samples.train.xagg
-        # Pre-rank y once for the whole feature
-        R_per_mod, n_per_mod, N, tie_corr = _modality_rank_stats(raw_xagg)
+        # Pre-rank y once for the whole feature.
+        R_per_mod, n_per_mod, N, tie_corr = _modality_rank_stats(raw_xagg)  # type: ignore
 
         # Map modality label -> position in R_per_mod / n_per_mod
         mod_to_pos: dict = {m: i for i, m in enumerate(raw_xagg.index)}
@@ -148,14 +153,17 @@ class ContinuousCombinationEvaluator(CombinationEvaluator, ABC):
         # Cache per-modality (n, sum_y) for the viability fast path.
         # Resets each time _compute_associations runs so the nan-pass refreshes
         # the cache after _apply_best_combination changes samples.train.xagg.
-        sum_y_per_mod = _modality_sum_y(raw_xagg)
-        self._train_modality_stats = {
+        sum_y_per_mod = _modality_sum_y(raw_xagg)  # type: ignore
+        # Why: heterogeneous-value dict; annotate `Any` so downstream readers (line 203-204
+        # and _get_dev_modality_stats) can narrow to the per-key concrete type without ty
+        # unioning across all value types.
+        self._train_modality_stats: dict[str, Any] = {
             "n_per_mod": n_per_mod.astype(float),
             "sum_y_per_mod": sum_y_per_mod,
             "mod_to_pos": mod_to_pos,
             "n_mod": n_mod,
         }
-        self._dev_modality_stats: dict | None = None  # lazy; aligned to train's mod_to_pos
+        self._dev_modality_stats: dict[str, Any] | None = None  # lazy; aligned to train's mod_to_pos
         self._dev_modality_stats_id: int | None = None
 
         batch: list[dict] = []
@@ -193,9 +201,9 @@ class ContinuousCombinationEvaluator(CombinationEvaluator, ABC):
         computation (the unit tests rely on this; production flows reassign
         dev only via ``samples.set`` at the start of ``get_best_combination``).
         """
-        dev_xagg = self.samples.dev.xagg
-        if dev_xagg is None:
+        if not self.samples.dev.has_xagg:
             return None
+        dev_xagg = self.samples.dev.xagg
         if self._dev_modality_stats is not None and self._dev_modality_stats_id == id(dev_xagg):
             return self._dev_modality_stats
         train_stats = self._train_modality_stats
@@ -261,7 +269,7 @@ class ContinuousCombinationEvaluator(CombinationEvaluator, ABC):
         """Fast-path viability on dev; falls back to legacy when the active
         target rate's ``compute_from_stats`` returns ``None``.
         """
-        if not test_results[Keys.VIABLE.value] or self.samples.dev.xagg is None:
+        if not test_results[Keys.VIABLE.value] or not self.samples.dev.has_xagg:
             return {**test_results, "dev": {Keys.VIABLE.value: None}}
 
         dev_stats = self._get_dev_modality_stats()

{autocarver-7.2.1 → autocarver-7.2.2}/AutoCarver/combinations/continuous/continuous_target_rates.py

@@ -1,6 +1,7 @@
 """set of target rates for binary classification"""
 
 from abc import ABC
+from typing import overload
 
 import numpy as np
 import pandas as pd
@@ -8,12 +9,16 @@ import pandas as pd
 from AutoCarver.combinations.utils import TargetRate
 
 
-class ContinuousTargetRate(TargetRate, ABC):
+class ContinuousTargetRate(TargetRate[pd.Series], ABC):
     """Continuous target rate class."""
 
     __name__ = "continuous_target_rate"
 
-    def compute(self, xagg: pd.Series) -> pd.DataFrame:
+    @overload
+    def compute(self, xagg: pd.Series | pd.DataFrame) -> pd.DataFrame: ...
+    @overload
+    def compute(self, xagg: None) -> None: ...
+    def compute(self, xagg: pd.Series | pd.DataFrame | None) -> pd.DataFrame | None:
         """Computes the target rate.
 
         Parameters
@@ -31,8 +36,12 @@ class ContinuousTargetRate(TargetRate, ABC):
             # frequency per modality
             frequency = xagg.apply(len) / xagg.apply(len).sum()
 
-            # computing target rate
-            return pd.DataFrame({self.__name__: self._compute(xagg), "frequency": frequency})
+            # computing target rate. `_compute` expects pd.Series (Generic
+            # XAgg=Series); compute()'s wide signature is for LSP matching,
+            # callers always pass a Series-of-y-lists here.
+            return pd.DataFrame(
+                {self.__name__: self._compute(xagg), "frequency": frequency}  # type: ignore
+            )
         return None
 
     def compute_from_stats(self, *, stats: dict, index_to_groupby: dict) -> pd.DataFrame | None:
@@ -59,7 +68,10 @@ class TargetMean(ContinuousTargetRate):
 
     def _compute(self, xagg: pd.Series | pd.DataFrame) -> pd.Series:
         """Computes the mean target rate."""
-        return xagg.apply(np.mean)
+        # pandas stubs widen `Series.apply(func)` to `Series | DataFrame`
+        # because they can't tell np.mean returns a scalar; the runtime
+        # result is always a Series.
+        return xagg.apply(np.mean)  # type: ignore
 
     def compute_from_stats(self, *, stats: dict, index_to_groupby: dict) -> pd.DataFrame | None:
         """Closed-form ``(target_mean, frequency)`` per group from per-modality stats.
@@ -130,7 +142,8 @@ class TargetMedian(ContinuousTargetRate):
 
     def _compute(self, xagg: pd.Series | pd.DataFrame) -> pd.Series:
         """Computes the mean target rate."""
-        return xagg.apply(np.median)
+        # see TargetMean._compute: same pandas-stub widening on apply().
+        return xagg.apply(np.median)  # type: ignore
 
 
 # class TargetVariance(ContinuousTargetRate):

{autocarver-7.2.1 → autocarver-7.2.2}/AutoCarver/combinations/utils/combination_evaluator.py

@@ -6,6 +6,7 @@ import math
 from abc import ABC, abstractmethod
 from collections.abc import Iterable, Iterator
 from dataclasses import dataclass, field
+from typing import Generic
 
 import pandas as pd
 from tqdm import tqdm
@@ -17,31 +18,46 @@ from AutoCarver.combinations.utils.combinations import (
     order_apply_combination,
     xagg_apply_combination,
 )
-from AutoCarver.combinations.utils.target_rate import TargetRate
+from AutoCarver.combinations.utils.target_rate import TargetRate, XAgg
 from AutoCarver.combinations.utils.testing import Keys, is_viable, test_viability
 from AutoCarver.features import BaseFeature, GroupedList
 
 
-@dataclass
 class AggregatedSample:
-    """Sample class to store aggregated samples
-
-    Attributes
-    ----------
-    xagg : pd.DataFrame
-        Aggregated sample
-    raw : pd.DataFrame
-        Raw aggregated sample
-    """
+    """Sample class to store aggregated samples.
 
-    xagg: pd.Series | pd.DataFrame
-    _raw: pd.Series | pd.DataFrame | None = None
+    The public ``xagg`` is typed as mandatory ``pd.Series | pd.DataFrame``. The
+    constructor accepts ``None`` so that placeholders (default factories, optional
+    dev samples) are expressible, but reading ``.xagg`` on an unset sample raises.
+    Use :attr:`has_xagg` to check presence without triggering.
+    """
 
-    def __post_init__(self):
-        """Post initialization"""
+    def __init__(
+        self,
+        xagg: pd.Series | pd.DataFrame | None = None,
+        _raw: pd.Series | pd.DataFrame | None = None,
+    ) -> None:
+        self._xagg: pd.Series | pd.DataFrame | None = xagg
+        self._raw: pd.Series | pd.DataFrame | None = _raw
         # setting xtab_dev to xtab if not provided
-        if self._raw is None and self.xagg is not None:
-            self._raw = self.xagg.copy()
+        if self._raw is None and self._xagg is not None:
+            self._raw = self._xagg.copy()
+
+    @property
+    def xagg(self) -> pd.Series | pd.DataFrame:
+        """Returns the aggregated sample, or raises if not set."""
+        if self._xagg is None:
+            raise RuntimeError("[AggregatedSample] xagg is not set")
+        return self._xagg
+
+    @xagg.setter
+    def xagg(self, value: pd.Series | pd.DataFrame) -> None:
+        self._xagg = value
+
+    @property
+    def has_xagg(self) -> bool:
+        """Whether xagg is set."""
+        return self._xagg is not None
 
     @property
     def raw(self) -> pd.Series | pd.DataFrame | None:
@@ -88,8 +104,8 @@ class AggregatedSample:
 class AggregatedSamples:
     """stores train and dev samples"""
 
-    train: AggregatedSample = field(default_factory=lambda: AggregatedSample(None))
-    dev: AggregatedSample = field(default_factory=lambda: AggregatedSample(None))
+    train: AggregatedSample = field(default_factory=AggregatedSample)
+    dev: AggregatedSample = field(default_factory=AggregatedSample)
 
     def set(self, train: pd.Series | pd.DataFrame | None, dev: pd.Series | pd.DataFrame | None = None) -> None:
         """Sets the train and dev samples"""
@@ -130,7 +146,7 @@ class AggregatedSamples:
         self.dev.raw = xagg_apply_combination(self.dev.raw, feature)
 
 
-class CombinationEvaluator(ABC):
+class CombinationEvaluator(ABC, Generic[XAgg]):
     """CombinationEvaluator class to evaluate
     the best combination of modalities for a feature."""
 
@@ -144,7 +160,7 @@ class CombinationEvaluator(ABC):
         self,
         *,
         verbose: bool = False,
-        target_rate: TargetRate | None = None,
+        target_rate: TargetRate[XAgg] | None = None,
     ) -> None:
         """
         Parameters
@@ -162,10 +178,10 @@ class CombinationEvaluator(ABC):
         self._feature: BaseFeature | None = None
         self.samples: AggregatedSamples = AggregatedSamples()
         self._statistics_cache = None
-        self.target_rate: TargetRate = self._init_target_rate(target_rate)
+        self.target_rate: TargetRate[XAgg] = self._init_target_rate(target_rate)
 
     @abstractmethod
-    def _init_target_rate(self, target_rate: TargetRate | None) -> TargetRate:
+    def _init_target_rate(self, target_rate: TargetRate[XAgg] | None) -> TargetRate[XAgg]:
         """Initializes target rate."""
         if target_rate is None:
             raise NotImplementedError("Subclasses must implement _init_target_rate to provide a default target rate")
@@ -209,7 +225,7 @@ class CombinationEvaluator(ABC):
         combinations. Output is in arrival order; the caller is expected to
         sort by the configured metric.
         """
-        n_obs = self.samples.train.xagg.apply(sum).sum()
+        n_obs: int = self.samples.train.xagg.apply(sum).sum()  # type: ignore
         for grouped_xagg in tqdm(grouped_xaggs, desc="Computing associations", disable=not self.verbose):
             measure = self._association_measure(grouped_xagg["xagg"], n_obs=n_obs)
             yield {
@@ -218,7 +234,7 @@ class CombinationEvaluator(ABC):
                 **measure,
             }
 
-    def _get_best_association(self, combinations: Iterable[list[str]]) -> dict | None:
+    def _get_best_association(self, combinations: Iterable[list[list[str]]]) -> dict | None:
         """Streams grouping → scoring → viability in one pass.
 
         - ``combinations`` is consumed lazily (generator-friendly).
@@ -275,8 +291,13 @@ class CombinationEvaluator(ABC):
             # applying best_combination to raw xagg and xagg_dev
             self.samples.apply_combination(self.feature)
 
-            # udpating statistics
-            self.feature.statistics = self.target_rate.compute(self.samples.train.raw)
+            # udpating statistics — `apply_combination` always populates
+            # `samples.train.raw`; narrow Optional so the overloaded
+            # compute() returns DataFrame (not DataFrame | None).
+            raw = self.samples.train.raw
+            if raw is None:
+                raise RuntimeError(f"[{self.__name__}] samples.train.raw is not populated after apply_combination")
+            self.feature.statistics = self.target_rate.compute(raw)
 
     def _get_best_combination_non_nan(self) -> dict | None:
         """Computes associations of the tab for each combination of non-nans
@@ -384,7 +405,7 @@ class CombinationEvaluator(ABC):
         """testing the viability of the combination on xagg_dev"""
 
         # case 0: not viable on train or no test sample -> not testing for robustness
-        if not test_results[Keys.VIABLE.value] or self.samples.dev.xagg is None:
+        if not test_results[Keys.VIABLE.value] or not self.samples.dev.has_xagg:
             return {**test_results, "dev": {Keys.VIABLE.value: None}}
 
         # case 1: test sample provided and viable on train -> testing robustness
@@ -440,14 +461,22 @@ class CombinationEvaluator(ABC):
         return viable_combination
 
     @abstractmethod
-    def _grouper(self, xagg: AggregatedSample, groupby: dict[str, str]) -> pd.Series | pd.DataFrame:
+    def _grouper(self, xagg: AggregatedSample, groupby: dict[str, str]) -> XAgg:
         """Helper to group XAGG's values by groupby (carver specific)"""
 
     @abstractmethod
     def _association_measure(
-        self, xagg: AggregatedSample, n_obs: int | None = None, tol: float = 1e-10
-    ) -> dict[str, float]:
-        """Helper to measure association between X and y (carver specific)"""
+        self,
+        xagg: AggregatedSample | pd.Series | pd.DataFrame,
+        n_obs: int | None = None,
+        tol: float = 1e-10,
+    ) -> dict[str, float | None]:
+        """Helper to measure association between X and y (carver specific).
+
+        Return value type is widened to ``float | None`` so the continuous
+        Kruskal–Wallis path (which returns ``None`` when scipy raises) can
+        share the base signature with the binary chi² path.
+        """
 
     def _historize_remaining_combinations(self, associations: list[dict], n_combination: int) -> None:
         """historizes the remaining combinations that have not been tested"""

autocarver-7.2.2/AutoCarver/combinations/utils/target_rate.py

@@ -0,0 +1,52 @@
+"""defines a target rate"""
+
+from abc import ABC, abstractmethod
+from typing import Generic, TypeVar, overload
+
+import pandas as pd
+
+# parametric type: target rates and evaluators are split by the *kind* of
+# aggregated input — DataFrame crosstabs for binary, Series-of-lists for
+# continuous. A value-constrained TypeVar prevents accidental third instantiations.
+XAgg = TypeVar("XAgg", pd.Series, pd.DataFrame)
+
+
+class TargetRate(ABC, Generic[XAgg]):
+    """Target rate class.
+
+    Generic over ``XAgg`` for the inner :meth:`_compute` worker so that
+    binary (``DataFrame`` crosstabs) and continuous (``Series`` of y-lists)
+    subclasses don't violate LSP by narrowing the worker's parameter type.
+    The outer :meth:`compute` keeps a wide ``Series | DataFrame | None``
+    signature because call sites in :class:`CombinationEvaluator` and
+    :class:`BaseCarver` carry that union directly from
+    :class:`AggregatedSample.raw` / pretty-printer plumbing.
+    """
+
+    __name__ = "target_rate"
+
+    @abstractmethod
+    def _compute(self, xagg: XAgg) -> pd.Series:
+        """Computes the target rate."""
+
+    # `compute` is overloaded so that callers passing a non-None ``xagg`` get a
+    # non-Optional ``pd.DataFrame`` back — required by `_test_viability_*` and
+    # the `BaseFeature.statistics` setter, which don't accept ``None``.
+    @overload
+    def compute(self, xagg: pd.Series | pd.DataFrame) -> pd.DataFrame: ...
+    @overload
+    def compute(self, xagg: None) -> None: ...
+    @abstractmethod
+    def compute(self, xagg: pd.Series | pd.DataFrame | None) -> pd.DataFrame | None:
+        """Computes the target rate.
+
+        Parameters
+        ----------
+        xagg : pd.Series | pd.DataFrame | None
+            A crosstab (binary) or Series-of-y-lists (continuous).
+
+        Returns
+        -------
+        pd.DataFrame | None
+            Target rate frame, or ``None`` if ``xagg`` was ``None``.
+        """

{autocarver-7.2.1 → autocarver-7.2.2}/AutoCarver/discretizers/discretizer.py

@@ -39,9 +39,9 @@ class Discretizer(BaseDiscretizer):
         super().__init__(features, min_freq=min_freq, config=config)
 
     @extend_docstring(BaseDiscretizer.fit)
-    def fit(self, X: pd.DataFrame, y: pd.Series) -> Self:  # pylint: disable=W0222
+    def fit(self, X: pd.DataFrame, y: pd.Series) -> Self:
         # Checking for binary target and copying X
-        sample = self._prepare_data(Sample(X, y))
+        sample = self._prepare_sample(Sample(X, y))
 
         # fitting quantitative features if any
         self._fit_quantitatives(**sample)