AutoCarver 7.3.0__tar.gz → 7.3.2__tar.gz

{autocarver-7.3.0 → autocarver-7.3.2}/AutoCarver/carvers/multiclass_carver.py

@@ -51,7 +51,7 @@ class MulticlassCarver(BinaryCarver):
 
         # multiclass cannot copy inplace
         if self.config.copy:
-            print("WARNING: can't set copy=True for MulticlassCarver (no inplace DataFrame.assign).")
+            print("WARNING: can't set copy=False for MulticlassCarver (no inplace DataFrame.assign).")
 
     def _prepare_samples(self, samples: Samples) -> Samples:
         """Validates format and content of X and y."""

{autocarver-7.3.0 → autocarver-7.3.2}/AutoCarver/carvers/utils/base_carver.py

@@ -245,12 +245,10 @@ class BaseCarver(BaseDiscretizer, ABC):
         if summaries.empty:
             return summaries
 
-        # binary carving historizes both cramerv and tschuprowt; keep only the metric the carver
-        # is configured to sort by so the same association isn't duplicated across two columns.
-        redundant = {"cramerv", "tschuprowt"} - {self.combination_evaluator.sort_by}
-        summaries = summaries.drop(columns=[col for col in redundant if col in summaries.columns])
-
-        excluded = {"feature", "label", "content", "target_mean", "frequency", "dropped", "dropped_reason"}
+        # per-modality stats (count, target_mean, frequency) stay columns; only per-feature
+        # metrics (sort_by association, n_mod) become index levels so they collapse to one
+        # row per feature instead of repeating across every modality.
+        excluded = {"feature", "label", "content", "target_mean", "frequency", "count", "dropped", "dropped_reason"}
         indices = [col for col in summaries.columns if col not in excluded]
         indices = ["feature"] + indices + ["label"]
         return summaries.set_index(indices)

{autocarver-7.3.0 → autocarver-7.3.2}/AutoCarver/combinations/binary/binary_combination_evaluators.py

@@ -79,10 +79,13 @@ class BinaryCombinationEvaluator(CombinationEvaluator[pd.DataFrame], ABC):
         if pd.notna(cramerv):
             cramerv = round(cramerv / tol) * tol
 
-        # Tschuprow's T
-        tschuprowt = cramerv / np.sqrt(np.sqrt(n_mod_x - 1))
-        if pd.notna(tschuprowt):
-            tschuprowt = round(tschuprowt / tol) * tol
+        # Tschuprow's T (undefined for a single modality: avoids a divide-by-zero)
+        if n_mod_x <= 1:
+            tschuprowt = np.nan
+        else:
+            tschuprowt = cramerv / np.sqrt(np.sqrt(n_mod_x - 1))
+            if pd.notna(tschuprowt):
+                tschuprowt = round(tschuprowt / tol) * tol
 
         return {"cramerv": cramerv, "tschuprowt": tschuprowt}
 

{autocarver-7.3.0 → autocarver-7.3.2}/AutoCarver/combinations/continuous/continuous_combination_evaluators.py

@@ -1,6 +1,7 @@
 """Module for continuous combination evaluators."""
 
 import math
+import warnings
 from abc import ABC
 from collections.abc import Iterable, Iterator
 from typing import Any
@@ -64,9 +65,13 @@ class ContinuousCombinationEvaluator(CombinationEvaluator[pd.Series], ABC):
         """
         _, _ = n_obs, tol  # unused attribute
 
-        # Kruskal-Wallis' H
+        # Kruskal-Wallis' H (degenerate groups legitimately yield NaN: scipy's
+        # SmallSampleWarning / tie-correction RuntimeWarning are silenced here so
+        # end users don't see them)
         try:
-            return {"kruskal": kruskal(*tuple(xagg.values))[0]}
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")
+                return {"kruskal": kruskal(*tuple(xagg.values))[0]}
         except (ValueError, IndexError):
             return {"kruskal": None}
 

{autocarver-7.3.0 → autocarver-7.3.2}/AutoCarver/combinations/continuous/continuous_target_rates.py

@@ -1,5 +1,6 @@
 """set of target rates for binary classification"""
 
+import warnings
 from abc import ABC
 from typing import overload
 
@@ -72,7 +73,10 @@ class TargetMean(ContinuousTargetRate):
         # 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
+        # empty modalities legitimately yield NaN: silence numpy's mean-of-empty warnings
+        with np.errstate(invalid="ignore", divide="ignore"), warnings.catch_warnings():
+            warnings.simplefilter("ignore", RuntimeWarning)
+            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.
@@ -146,7 +150,10 @@ class TargetMedian(ContinuousTargetRate):
     def _compute(self, xagg: pd.Series | pd.DataFrame) -> pd.Series:
         """Computes the mean target rate."""
         # see TargetMean._compute: same pandas-stub widening on apply().
-        return xagg.apply(np.median)  # type: ignore
+        # empty modalities legitimately yield NaN: silence numpy's median-of-empty warnings
+        with np.errstate(invalid="ignore", divide="ignore"), warnings.catch_warnings():
+            warnings.simplefilter("ignore", RuntimeWarning)
+            return xagg.apply(np.median)  # type: ignore
 
 
 # class TargetVariance(ContinuousTargetRate):

{autocarver-7.3.0 → autocarver-7.3.2}/AutoCarver/discretizers/utils/frequency_ci.py

@@ -50,7 +50,10 @@ def wilson_upper_bound(
     denom = 1.0 + (z * z) / n
     center = (phat + (z * z) / (2.0 * n)) / denom
     half_width = (z / denom) * np.sqrt(phat * (1.0 - phat) / n + (z * z) / (4.0 * n * n))
-    upper = center + half_width
+    # A proportion CI bound is by definition in [0, 1]; clamp to absorb float
+    # rounding (e.g. count == nobs cancels to exactly 1.0 in exact arithmetic but
+    # lands at 1.0000000000000002 in floating point).
+    upper = np.clip(center + half_width, 0.0, 1.0)
 
     if np.isscalar(count):
         return float(upper)

{autocarver-7.3.0 → autocarver-7.3.2}/AutoCarver/features/features.py

@@ -604,7 +604,7 @@ class Features:
         # defining indices to set
         indices = []
         for col in summaries.columns:
-            if col not in ["feature", "label", "content", "target_mean", "frequency"]:
+            if col not in ["feature", "label", "content", "target_mean", "frequency", "count"]:
                 indices += [col]
         indices = ["feature"] + indices + ["label"]
 

{autocarver-7.3.0 → autocarver-7.3.2}/AutoCarver/features/qualitatives/qualitative_feature.py

@@ -33,8 +33,6 @@ class QualitativeFeature(BaseFeature):
         super()._restore_from_json(feature_json)
 
     def fit(self, X: pd.DataFrame, y: pd.Series | None = None) -> None:
-        """TODO fit stats"""
-
         # checking for feature's unique non-nan values
         sorted_unique_values = nan_unique(X[self.version], sort=True)
 
@@ -119,64 +117,28 @@ class QualitativeFeature(BaseFeature):
         # adding statistics and history
         return self._add_statistics_to_summary(summary)
 
-    def _specific_update(self, values: GroupedList, convert_labels: bool = False) -> None:
-        """update content of values specifically per feature type"""
+    def _resolve_grouping(
+        self, kept_label: str | float, grouped_values: list, r_value_per_label: dict
+    ) -> tuple[list, str | float]:
+        """selects the kept value and finalizes grouped values"""
 
-        # no values have been set
-        if not convert_labels and self.values.is_empty():
-            self.values = values
+        # choosing which value to keep: getting group of kept_value
+        kept_value = self.values.get_group(self.value_per_label.get(kept_label))
+        # TODO force kept_value to != self.nan like in quantitative feature?
 
-        # values are not labels
-        elif not convert_labels:
-            # updating: iterating over each grouped values
-            for kept_value, grouped_values in values.content.items():
-                self.values.group(grouped_values, kept_value)
+        # keeping only values not already grouped with kept_value
+        grouped_values = [
+            self.values.get_group(value) for value in grouped_values if self.values.get_group(value) != kept_value
+        ]
 
-        # values are labels -> converting them back to values
-        else:
-            # iterating over each grouped values
-            for kept_label, grouped_labels in values.content.items():
-                # converting labels to values
-                kept_value = self.value_per_label.get(kept_label)
-                grouped_values = [self.value_per_label.get(label) for label in grouped_labels]
-
-                # checking that kept values exists
-                if kept_label not in self.value_per_label:
-                    raise AttributeError(f"{self} no {kept_label}, in value_per_label: {self.value_per_label}")
-
-                # checking that grouped values exists
-                for grouped_value, grouped_label in zip(grouped_values, grouped_labels):
-                    if grouped_value is None:
-                        print(f"{self} no {grouped_label}, in value_per_label: {self.value_per_label}")
-
-                # choosing which value to keep: getting group of kept_value
-                kept_value = self.values.get_group(kept_value)
-                # TODO force kept_value to != self.nan like in quantitative feature?
-
-                # keeping only values not already grouped with kept_value
-                grouped_values = [
-                    self.values.get_group(value)
-                    for value in grouped_values
-                    if self.values.get_group(value) != kept_value
-                ]
-
-                # deduplicating
-                grouped_values = [
-                    value for num, value in enumerate(grouped_values) if value not in grouped_values[num + 1 :]
-                ]
-
-                # updating values if any to group
-                if len(grouped_values) > 0:
-                    # if ordinal_encoding, converting values to unique values
-                    if self.ordinal_encoding:
-                        r_value_per_label = {v: self.values[k] for k, v in self.value_per_label.items()}
-                        grouped_values = [r_value_per_label[value] for value in grouped_values]
-
-                    # grouping values
-                    self.values.group(grouped_values, kept_value)
-
-                # updating statistics
-                self._update_statistics_value(kept_label, kept_value)
+        # deduplicating
+        grouped_values = [value for num, value in enumerate(grouped_values) if value not in grouped_values[num + 1 :]]
+
+        # if ordinal_encoding, converting values to unique values
+        if len(grouped_values) > 0 and self.ordinal_encoding:
+            grouped_values = [r_value_per_label[value] for value in grouped_values]
+
+        return grouped_values, kept_value
 
     @abstractmethod
     def _specific_formatting(self, ordered_content: list[str]) -> str:

{autocarver-7.3.0 → autocarver-7.3.2}/AutoCarver/features/quantitatives/quantitative_feature.py

@@ -18,57 +18,30 @@ class QuantitativeFeature(BaseFeature):
         """No-op: quantitative features cannot have a default value."""
         _ = value
 
-    def _specific_update(self, values: GroupedList, convert_labels: bool = False) -> None:  # noqa: C901
-        """update content of values specifically per feature type"""
-
-        # no values have been set
-        if not convert_labels and self.values.is_empty():
-            # checking that inf is amongst values
-            if values[-1] != np.inf:
-                raise ValueError(f"[{self}] Must provide values with values[-1] == numpy.inf")
-            self.values = values
-
-        # values are not labels
-        elif not convert_labels:
-            # updating: iterating over each grouped values
-            for kept_value, grouped_values in values.content.items():
-                self.values.group(grouped_values, kept_value)
-
-        # values are labels -> converting them back to values
-        else:
-            # iterating over each grouped values
-            for kept_label, grouped_labels in values.content.items():
-                # checking that kept values exists
-                if kept_label not in self.value_per_label:
-                    raise AttributeError(f"{self} no {kept_label}, in value_per_label: {self.value_per_label}")
-
-                # converting labels to values
-                kept_value = self.value_per_label[kept_label]
-                grouped_values = [self.value_per_label.get(label) for label in grouped_labels]
-
-                # checking that grouped values exists
-                for grouped_value, grouped_label in zip(grouped_values, grouped_labels):
-                    if grouped_value is None:
-                        print(f"{self} no {grouped_label}, in value_per_label: {self.value_per_label}")
-
-                # choosing which value to keep
-                which_to_keep = [value for value in grouped_values if value != self.nan]
-
-                # keeping the largest value amongst the discarded
-                if len(which_to_keep) > 0:
-                    kept_value = max(which_to_keep)
-
-                # updating values if any to group
-                if len(grouped_values) > 0:
-                    # if ordinal_encoding, converting values to unique values
-                    if self.ordinal_encoding:
-                        r_value_per_label = {v: self.values[k] for k, v in self.value_per_label.items()}
-                        grouped_values = [r_value_per_label[value] for value in grouped_values]
-                        kept_value = r_value_per_label[kept_value]
-                    self.values.group(grouped_values, kept_value)
-
-                # updating statistics
-                self._update_statistics_value(kept_label, kept_value)
+    def _check_empty_values(self, values: GroupedList) -> None:
+        """checks that inf is amongst values"""
+        if values[-1] != np.inf:
+            raise ValueError(f"[{self}] Must provide values with values[-1] == numpy.inf")
+
+    def _resolve_grouping(
+        self, kept_label: str | float, grouped_values: list, r_value_per_label: dict
+    ) -> tuple[list, str | float]:
+        """selects the kept value and finalizes grouped values"""
+
+        # choosing which value to keep
+        kept_value = self.value_per_label[kept_label]
+
+        # keeping the largest value amongst the discarded
+        which_to_keep = [value for value in grouped_values if value != self.nan]
+        if len(which_to_keep) > 0:
+            kept_value = max(which_to_keep)
+
+        # if ordinal_encoding, converting values to unique values
+        if len(grouped_values) > 0 and self.ordinal_encoding:
+            grouped_values = [r_value_per_label[value] for value in grouped_values]
+            kept_value = r_value_per_label[kept_value]
+
+        return grouped_values, kept_value
 
     def make_labels(self) -> GroupedList:
         """gives labels per quantile (values for continuous features)
@@ -91,6 +64,16 @@ class QuantitativeFeature(BaseFeature):
         # converting quantiles in string
         labels = format_quantiles(quantiles)
 
+        # add NaNs if there are any (grouped into an existing quantile bucket):
+        # mark the absorbing bucket's label (mirrors QualitativeFeature._format_modalities).
+        # Only relevant when nan isn't its own leader; labels is positionally aligned with
+        # the non-nan leaders of self.values (finite quantiles followed by inf).
+        if self.nan not in self.values and self.values.contains(self.nan):
+            labels = [
+                f"{label}, {self.nan}" if self.nan in self.values.get(leader) else label
+                for label, leader in zip(labels, self.values)
+            ]
+
         # converting to grouped list
         labels = GroupedList(labels)
 
@@ -98,9 +81,6 @@ class QuantitativeFeature(BaseFeature):
         if self.nan in self.values:
             labels.append(self.nan)
 
-        # TODO add NaNs if there are any (grouped)
-        # elif self.nan in self.values.values:
-
         return labels
 
     def _make_summary(self):
@@ -145,6 +125,11 @@ def format_quantiles(a_list: list[float]) -> list[str]:
 
     # several quantiles
     else:
+        # collapse signed zero: an identical boundary can surface as -0.0 or 0.0
+        # depending on the quantile computation path (they compare equal but
+        # format to different strings), which would make labels run-dependent
+        a_list = [number + 0.0 for number in a_list]
+
         # getting minimal number of decimals to differentiate labels
         decimals_needed = min_decimals_to_differentiate(a_list, min_decimals=1)
 

{autocarver-7.3.0 → autocarver-7.3.2}/AutoCarver/features/utils/base_feature.py

@@ -267,9 +267,73 @@ class BaseFeature(ABC):
     def _make_summary(self) -> list[dict]:
         """Returns a summary of the feature."""
 
-    @abstractmethod
     def _specific_update(self, values: GroupedList, convert_labels: bool = False) -> None:
-        """Update content of values specifically per feature type."""
+        """Update content of values, converting labels back to values if needed."""
+
+        # no values have been set
+        if not convert_labels and self.values.is_empty():
+            self._check_empty_values(values)
+            self.values = values
+            return
+
+        # values are not labels
+        if not convert_labels:
+            # updating: iterating over each grouped values
+            for kept_value, grouped_values in values.content.items():
+                self.values.group(grouped_values, kept_value)
+            return
+
+        # values are labels -> converting them back to values
+        # Snapshot the encoded-label -> leader-value map once. self.values.group()
+        # below mutates leader positions, so rebuilding this inside the loop would
+        # desync self.values[k] (IndexError on the 2nd+ grouped label).
+        r_value_per_label = self._reverse_value_per_label()
+
+        # iterating over each grouped values
+        for kept_label, grouped_labels in values.content.items():
+            self._update_grouped_label(kept_label, grouped_labels, r_value_per_label)
+
+    def _reverse_value_per_label(self) -> dict:
+        """Maps each encoded label back to its current leader value (ordinal only)."""
+        if self.ordinal_encoding:
+            leaders = list(self.values)
+            return {v: leaders[k] for k, v in self.value_per_label.items()}
+        return {}
+
+    def _update_grouped_label(self, kept_label: str | float, grouped_labels: list, r_value_per_label: dict) -> None:
+        """Converts one labelled group back to values and groups them."""
+
+        # checking that kept value exists
+        if kept_label not in self.value_per_label:
+            raise AttributeError(f"{self} no {kept_label}, in value_per_label: {self.value_per_label}")
+
+        # converting labels to values
+        grouped_values = [self.value_per_label.get(label) for label in grouped_labels]
+
+        # checking that grouped values exists
+        for grouped_value, grouped_label in zip(grouped_values, grouped_labels):
+            if grouped_value is None:
+                print(f"{self} no {grouped_label}, in value_per_label: {self.value_per_label}")
+
+        # feature-specific: choosing kept value and finalizing grouped values
+        grouped_values, kept_value = self._resolve_grouping(kept_label, grouped_values, r_value_per_label)
+
+        # updating values if any to group
+        if len(grouped_values) > 0:
+            self.values.group(grouped_values, kept_value)
+
+        # updating statistics
+        self._update_statistics_value(kept_label, kept_value)
+
+    def _check_empty_values(self, values: GroupedList) -> None:
+        """Optional hook: validates values before the first assignment (no-op by default)."""
+        return
+
+    @abstractmethod
+    def _resolve_grouping(
+        self, kept_label: str | float, grouped_values: list, r_value_per_label: dict
+    ) -> tuple[list, str | float]:
+        """Selects the kept value and finalizes grouped values specifically per feature type."""
 
     # ------------------------------------------------------------------
     # summary
@@ -293,8 +357,7 @@ class BaseFeature(ABC):
         if len(history) > 0:
             selected: dict = {}
 
-            with pd.option_context("future.no_silent_downcasting", True):
-                viable = history["viable"].fillna(False).astype(bool)
+            viable = history["viable"].fillna(False).astype(bool)
 
             if viable.any():
                 dropna = history["dropna"].fillna(False)

{autocarver-7.3.0 → autocarver-7.3.2}/AutoCarver/selectors/measures/_vectorized.py

@@ -69,13 +69,16 @@ def kruskal_h(block: pd.DataFrame, groups: pd.Series) -> tuple[np.ndarray, np.nd
     n_obs = mask.sum(0).astype(float)  # (P,)
     n_groups = (n > 0).sum(0)  # (P,)
 
+    tie_factors = _tie_factors(block)
     with np.errstate(divide="ignore", invalid="ignore"):
         term = np.nansum(np.where(n > 0, rank_sums**2 / n, np.nan), axis=0)  # (P,)
         h = 12.0 / (n_obs * (n_obs + 1)) * term - 3.0 * (n_obs + 1)
-        h = h / _tie_factors(block)
+        h = h / tie_factors
 
-    # undefined where scipy.kruskal would raise / has_values would bail
-    h = np.where((n_obs > 1) & (n_groups > 1), h, np.nan)
+    # undefined where scipy.kruskal would raise / has_values would bail; a
+    # constant column has tie_factor 0 (division above -> inf), which scipy
+    # rejects ("All numbers are identical") -> treat as undefined too
+    h = np.where((n_obs > 1) & (n_groups > 1) & (tie_factors > 0), h, np.nan)
     return h, n_obs, n_groups.astype(float)
 
 
@@ -115,12 +118,15 @@ def kruskal_h_reversed(block: pd.DataFrame, y: pd.Series) -> tuple[np.ndarray, n
             continue
         term = (rank_sums[populated] ** 2 / counts[populated]).sum()
         h_j = 12.0 / (n * (n + 1)) * term - 3.0 * (n + 1)
-        # tie correction over the pooled y ranks
+        # tie correction over the pooled y ranks; an all-tied y gives tie_factor
+        # 0 (scipy.stats.kruskal rejects it: "All numbers are identical") -> leave
+        # h[j] undefined instead of dividing to +inf
         _, tcounts = np.unique(ranks, return_counts=True)
         ties = float((tcounts**3 - tcounts).sum())
-        if n**3 - n > 0:
-            h_j /= 1.0 - ties / (n**3 - n)
-        h[j] = h_j
+        tie_factor = 1.0 - ties / (n**3 - n)
+        if tie_factor == 0:
+            continue
+        h[j] = h_j / tie_factor
     return h, n_obs, n_groups
 
 
@@ -152,7 +158,16 @@ def chi2_all(block: pd.DataFrame, y: pd.Series) -> tuple[np.ndarray, np.ndarray,
         row = table.sum(1, keepdims=True)
         col_sum = table.sum(0, keepdims=True)
         expected = row @ col_sum / n
+
+        # Yates' continuity correction on 2x2 tables (dof == 1), matching the
+        # scalar reference (scipy.stats.chi2_contingency, correction=True by
+        # default) and the closed-form in binary_combination_evaluators.
+        obs = table
+        if m == 2 and n_y == 2:
+            diff = expected - obs
+            obs = obs + np.minimum(0.5, np.abs(diff)) * np.sign(diff)
+
         with np.errstate(divide="ignore", invalid="ignore"):
-            contrib = np.where(expected > 0, (table - expected) ** 2 / expected, 0.0)
+            contrib = np.where(expected > 0, (obs - expected) ** 2 / expected, 0.0)
         chi2[j] = contrib.sum()
     return chi2, n_obs, n_mod_x, np.full(p, float(n_y))

{autocarver-7.3.0 → autocarver-7.3.2}/AutoCarver/selectors/measures/base_measures.py

@@ -2,6 +2,7 @@
 
 from abc import ABC, abstractmethod
 
+import numpy as np
 import pandas as pd
 
 from AutoCarver.features import BaseFeature
@@ -279,6 +280,10 @@ class ModeMeasure(OutlierMeasure):
             Measure of ``x``'s mode
         """
         _ = y
-        mode = x.mode(dropna=True).values[0]  # computing mode
+        modes = x.mode(dropna=True)  # computing mode
+        if len(modes) == 0:  # all-NaN feature: no defined non-NaN mode
+            self.value = np.nan
+            return self.value
+        mode = modes.values[0]
         self.value = (x == mode).mean()  # Computing percentage of the mode
         return self.value

{autocarver-7.3.0 → autocarver-7.3.2}/AutoCarver/selectors/measures/qualitative_measures.py

@@ -2,6 +2,7 @@
 
 from math import sqrt
 
+import numpy as np
 import pandas as pd
 from scipy.stats import chi2_contingency
 
@@ -40,7 +41,10 @@ class Chi2Measure(BaseMeasure):
         xtab = pd.crosstab(x, y)
 
         # computing Chi2 statistic
-        self.value = chi2_contingency(xtab)[0]
+        try:
+            self.value = chi2_contingency(xtab)[0]
+        except ValueError:
+            self.value = np.nan
         return self.value
 
     def compute_all(self, X, y, features) -> dict[str, dict]:
@@ -109,14 +113,21 @@ class TschuprowtMeasure(Chi2Measure):
         n_mod_x, n_mod_y = x.nunique(), y.nunique()
 
         # computing Tschuprow's T
-        dof_mods = sqrt((n_mod_x - 1) * (n_mod_y - 1))
+        dof_prod = (n_mod_x - 1) * (n_mod_y - 1)
+        if dof_prod < 0:  # no data for x or y: Tschuprow's T is undefined
+            self.value = np.nan
+            return self.value
+        dof_mods = sqrt(dof_prod)
         self.value = 0
         if dof_mods > 0:
             self.value = sqrt(chi2_value / n_obs / dof_mods)
         return self.value
 
     def _stat(self, chi2: float, n_obs: float, n_mod_x: float, n_mod_y: float) -> float:
-        dof_mods = sqrt((n_mod_x - 1) * (n_mod_y - 1))
+        dof_prod = (n_mod_x - 1) * (n_mod_y - 1)
+        if dof_prod < 0:  # no data for x or y: Tschuprow's T is undefined
+            return np.nan
+        dof_mods = sqrt(dof_prod)
         if dof_mods > 0:
             return sqrt(chi2 / n_obs / dof_mods)
         return 0.0

{autocarver-7.3.0 → autocarver-7.3.2}/AutoCarver/selectors/measures/quantitative_measures.py

@@ -1,5 +1,6 @@
 """Measures of association between a Quantitative feature and binary target."""
 
+import warnings
 from math import sqrt
 
 import numpy as np
@@ -181,6 +182,12 @@ class RMeasure(BaseMeasure):
         if y[~nans].nunique() != 2:
             raise ValueError(f"[{self}] Provided y is not binary")
 
+        # a constant feature has no explained variance (centered_tss == 0): R is
+        # undefined, return NaN before fitting to avoid a divide-by-zero in statsmodels
+        if x[~nans].nunique() <= 1:
+            self.value = np.nan
+            return self.value
+
         # grouping feature and target
         ols_df = pd.DataFrame({"feature": x[~nans], "target": y[~nans]})
 
@@ -212,7 +219,12 @@ class CorrelationMeasure(AbsoluteMeasure):
     def compute_all(self, X, y, features) -> dict[str, dict]:
         """Vectorized correlation of every feature with ``y`` in one ``corrwith`` call."""
         block = X[[feature.version for feature in features]]
-        corr = block.corrwith(y, method=self._corr_method)
+        # degenerate columns (constant, or <=1 non-NaN overlap) legitimately yield
+        # NaN; silence the numpy/scipy RuntimeWarnings (divide, df<=0, ConstantInput)
+        # rather than surface them to end users
+        with np.errstate(divide="ignore", invalid="ignore"), warnings.catch_warnings():
+            warnings.simplefilter("ignore", RuntimeWarning)
+            corr = block.corrwith(y, method=self._corr_method)
         return {feature.version: self._result(corr[feature.version]) for feature in features}
 
 

{autocarver-7.3.0 → autocarver-7.3.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: AutoCarver
-Version: 7.3.0
+Version: 7.3.2
 Summary: Automatic Discretization of Features with Optimal Target Association
 Keywords: binning,discretization,feature-engineering,credit-scoring,woe,scorecards,tschuprow,tschuprow-t,cramer-v,information-value,iv,monotonic-binning,supervised-discretization,bucketization,risk-modeling,credit-risk,fraud-detection,categorical-encoding
 Author: Mario DEFRANCE

{autocarver-7.3.0 → autocarver-7.3.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "AutoCarver"
-version = "7.3.0"
+version = "7.3.2"
 description = "Automatic Discretization of Features with Optimal Target Association"
 authors = [{ name = "Mario DEFRANCE", email = "defrancemario@gmail.com" }]
 requires-python = ">=3.11, <3.15"
@@ -75,6 +75,7 @@ dev = [
     "ruff>=0.15.12",
     "pytest-xdist>=3.8.0",
     "ty>=0.0.38",
+    "hypothesis>=6.0,<7",
 ]
 
 [project.urls]