edaprep 0.2.1__tar.gz → 0.3.0__tar.gz

{edaprep-0.2.1/src/edaprep.egg-info → edaprep-0.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edaprep
-Version: 0.2.1
+Version: 0.3.0
 Summary: Transparent, leakage-safe EDA and ML preprocessing with an explainable planner.
 Author-email: bijay <bijaybeezoe@gmail.com>
 License: MIT
@@ -321,7 +321,7 @@ changed what shipped are listed here alongside the commits.
 | [@qiaobochi040726-source](https://github.com/qiaobochi040726-source) | Removed `Config.n_jobs`, a setting the library accepted and never read ([#11](https://github.com/bijay-odyssey/edaprep/pull/11)) |
 | [@zbs-ops](https://github.com/zbs-ops) | Benchmarked parallelising the per-column profiling loop, which is what decided [#9](https://github.com/bijay-odyssey/edaprep/issues/9) — no commit, and the reason the parameter went |
 | [@Jeferson681](https://github.com/Jeferson681) | Made the missing-indicator and high-missing rules see gaps introduced at the cast step ([#16](https://github.com/bijay-odyssey/edaprep/pull/16)) |
-| [@luziyi123448-gif](https://github.com/luziyi123448-gif) | Independent fix for the same issue whose design was the better one; it survives as [#18](https://github.com/bijay-odyssey/edaprep/issues/18) ([#17](https://github.com/bijay-odyssey/edaprep/pull/17)) |
+| [@luziyi123448-gif](https://github.com/luziyi123448-gif) | Independent fix for the same issue whose design was the better one; that design shipped in [#18](https://github.com/bijay-odyssey/edaprep/issues/18) ([#17](https://github.com/bijay-odyssey/edaprep/pull/17)) |
 | [@LeonxLJX](https://github.com/LeonxLJX) | Formatted the tree and made `ruff format` a real CI gate rather than an advisory one ([#25](https://github.com/bijay-odyssey/edaprep/pull/25)) |
 | [@TrueFurina](https://github.com/TrueFurina) | First to run the Codecov upload path, which is how we learned it fails silently from a fork with no token — CI green, nothing reported; coverage moved to the job summary instead ([#21](https://github.com/bijay-odyssey/edaprep/pull/21)) |
 

{edaprep-0.2.1 → edaprep-0.3.0}/README.md

@@ -275,7 +275,7 @@ changed what shipped are listed here alongside the commits.
 | [@qiaobochi040726-source](https://github.com/qiaobochi040726-source) | Removed `Config.n_jobs`, a setting the library accepted and never read ([#11](https://github.com/bijay-odyssey/edaprep/pull/11)) |
 | [@zbs-ops](https://github.com/zbs-ops) | Benchmarked parallelising the per-column profiling loop, which is what decided [#9](https://github.com/bijay-odyssey/edaprep/issues/9) — no commit, and the reason the parameter went |
 | [@Jeferson681](https://github.com/Jeferson681) | Made the missing-indicator and high-missing rules see gaps introduced at the cast step ([#16](https://github.com/bijay-odyssey/edaprep/pull/16)) |
-| [@luziyi123448-gif](https://github.com/luziyi123448-gif) | Independent fix for the same issue whose design was the better one; it survives as [#18](https://github.com/bijay-odyssey/edaprep/issues/18) ([#17](https://github.com/bijay-odyssey/edaprep/pull/17)) |
+| [@luziyi123448-gif](https://github.com/luziyi123448-gif) | Independent fix for the same issue whose design was the better one; that design shipped in [#18](https://github.com/bijay-odyssey/edaprep/issues/18) ([#17](https://github.com/bijay-odyssey/edaprep/pull/17)) |
 | [@LeonxLJX](https://github.com/LeonxLJX) | Formatted the tree and made `ruff format` a real CI gate rather than an advisory one ([#25](https://github.com/bijay-odyssey/edaprep/pull/25)) |
 | [@TrueFurina](https://github.com/TrueFurina) | First to run the Codecov upload path, which is how we learned it fails silently from a fork with no token — CI green, nothing reported; coverage moved to the job summary instead ([#21](https://github.com/bijay-odyssey/edaprep/pull/21)) |
 

edaprep-0.3.0/src/edaprep/_version.py

@@ -0,0 +1 @@
+__version__ = "0.3.0"

{edaprep-0.2.1 → edaprep-0.3.0}/src/edaprep/config.py

@@ -36,7 +36,19 @@ __all__ = ["Config", "ColumnConfig", "Thresholds", "AUTO"]
 AUTO = "auto"
 
 _MISSING_STRATEGIES = frozenset(
-    {AUTO, "mean", "median", "mode", "constant", "ffill", "bfill", "drop_rows", "none"}
+    {
+        AUTO,
+        "mean",
+        "median",
+        "mode",
+        "constant",
+        "ffill",
+        "bfill",
+        "drop_rows",
+        "none",
+        "knn",
+        "iterative",
+    }
 )
 _OUTLIER_METHODS = frozenset({AUTO, "iqr", "zscore", "modified_zscore", "percentile", "none"})
 _OUTLIER_STRATEGIES = frozenset(
@@ -383,7 +395,12 @@ class Config:
         """Return the override record for ``name`` without creating one."""
         return self.columns.get(name)
 
-    def set_columns(self, overrides: Mapping[str, Mapping[str, Any]]) -> "Config":
+    def set_columns(
+        self,
+        overrides: Mapping[str, Mapping[str, Any]],
+        *,
+        warn_on_unknown: bool = False,
+    ) -> "Config":
         """Bulk-apply overrides: ``{"age": {"imputation": "median"}, ...}``."""
         for name, kwargs in overrides.items():
             col = self.column(name)
@@ -392,6 +409,15 @@ class Config:
                     valid = [
                         f.name for f in dataclasses.fields(ColumnConfig) if f.name != "name"
                     ]
+                    if warn_on_unknown:
+                        warnings.warn(
+                            f"Config.from_dict ignoring unrecognised column({name!r}) "
+                            f"setting: {key!r}. It was either retired in a later "
+                            f"version of edaprep or is misspelt.",
+                            UserWarning,
+                            stacklevel=2,
+                        )
+                        continue
                     raise ConfigurationError.unknown_option(
                         f"column({name!r}) setting", key, valid
                     )
@@ -484,7 +510,21 @@ class Config:
         equally likely to be a typo, and this is the only signal you would get.
         """
         data = dict(data)
-        thresholds = Thresholds(**data.pop("thresholds", {}))
+        thresholds_raw = dict(data.pop("thresholds", {}))
+        known_thresholds = {f.name for f in dataclasses.fields(Thresholds)}
+        unknown_thresholds = sorted(set(thresholds_raw) - known_thresholds)
+        if unknown_thresholds:
+            warnings.warn(
+                f"Config.from_dict ignoring {len(unknown_thresholds)} unrecognised "
+                f"threshold setting(s): "
+                f"{', '.join(repr(k) for k in unknown_thresholds)}. They were either "
+                f"retired in a later version of edaprep or are misspelt; the rest of "
+                f"the threshold configuration was applied unchanged.",
+                UserWarning,
+                stacklevel=2,
+            )
+            thresholds_raw = {k: v for k, v in thresholds_raw.items() if k in known_thresholds}
+        thresholds = Thresholds(**thresholds_raw)
         columns_raw = data.pop("columns", {})
 
         known = {f.name for f in dataclasses.fields(cls)}
@@ -504,7 +544,7 @@ class Config:
         for name, kwargs in columns_raw.items():
             kwargs = dict(kwargs)
             kwargs.pop("name", None)
-            cfg.set_columns({name: kwargs})
+            cfg.set_columns({name: kwargs}, warn_on_unknown=True)
         return cfg
 
     def __repr__(self) -> str:

{edaprep-0.2.1 → edaprep-0.3.0}/src/edaprep/eda/categorical.py

@@ -9,6 +9,7 @@ from __future__ import annotations
 
 from typing import List, Optional
 
+import numpy as np
 import pandas as pd
 
 from ..config import Config
@@ -26,7 +27,7 @@ def categorical_summary(
     rare_threshold = config.effective_rare_threshold
     high_cardinality = config.effective_high_cardinality
     n_rows = profile.n_rows
-    floor = max(1, int(rare_threshold * n_rows))
+    floor = max(1, int(np.ceil(rare_threshold * n_rows)))
 
     rows: List[dict] = []
     for name in profile.column_order:

{edaprep-0.2.1 → edaprep-0.3.0}/src/edaprep/planning/rules.py

@@ -19,7 +19,7 @@ named, the reasoning is printed, and a user can override any of it per column.
 from __future__ import annotations
 
 from dataclasses import dataclass
-from typing import Callable, Dict, List, Optional, Sequence
+from typing import Callable, Dict, List, Optional, Sequence, Tuple
 
 import numpy as np
 
@@ -193,9 +193,8 @@ def _rule_drop_high_missing(cp: ColumnProfile, ctx: RuleContext) -> Optional[Dec
     if not ctx.config.drop_high_missing or cp.is_target:
         return None
     threshold = ctx.thresholds.missing_drop_threshold
-    cast_missing = _cast_missing(cp, ctx)
-    effective = (cp.n_missing + cast_missing) / cp.n_rows if cp.n_rows else 0.0
-    if effective < threshold:
+    cast_missing, missing_fraction = _post_cast_missing(cp, ctx)
+    if missing_fraction < threshold:
         return None
     # Quoting cp.missing_fraction alone would report "0.0% missing" on a column that is
     # about to be full of placeholders-turned-NaN, so the phrase names whichever
@@ -208,7 +207,7 @@ def _rule_drop_high_missing(cp: ColumnProfile, ctx: RuleContext) -> Optional[Dec
     elif cast_missing:
         found = (
             f"{cast_missing} placeholder value(s) become NaN when the column is cast, "
-            f"leaving {_pct(effective)} missing"
+            f"leaving {_pct(missing_fraction)} missing"
         )
     else:
         found = f"{_pct(cp.missing_fraction)} missing"
@@ -224,7 +223,8 @@ def _rule_drop_high_missing(cp: ColumnProfile, ctx: RuleContext) -> Optional[Dec
         Stage.DROP_COLUMNS,
         "drop",
         params={
-            "missing_fraction": round(cp.missing_fraction, 4),
+            "missing_fraction": round(missing_fraction, 4),
+            "n_rows": cp.n_rows,
             **({"cast_missing": cast_missing} if cast_missing else {}),
         },
         rationale=(
@@ -261,9 +261,8 @@ def _rule_missing_indicator(cp: ColumnProfile, ctx: RuleContext) -> Optional[Dec
     if cp.is_target or not ctx.config.add_missing_indicators:
         return None
     threshold = ctx.thresholds.missing_indicator_threshold
-    cast_missing = _cast_missing(cp, ctx)
-    effective = (cp.n_missing + cast_missing) / cp.n_rows if cp.n_rows else 0.0
-    if effective < threshold or effective >= 1.0:
+    cast_missing, missing_fraction = _post_cast_missing(cp, ctx)
+    if missing_fraction < threshold or missing_fraction >= 1.0:
         return None
     # Quoting cp.missing_fraction alone would report "0.0% missing" on a column that is
     # about to be full of placeholders-turned-NaN, so the phrase names whichever
@@ -285,7 +284,8 @@ def _rule_missing_indicator(cp: ColumnProfile, ctx: RuleContext) -> Optional[Dec
         Stage.MISSING_FLAG,
         "add_missing_indicator",
         params={
-            "missing_fraction": round(cp.missing_fraction, 4),
+            "missing_fraction": round(missing_fraction, 4),
+            "n_rows": cp.n_rows,
             **({"cast_missing": cast_missing} if cast_missing else {}),
         },
         rationale=(
@@ -387,6 +387,22 @@ def _cast_missing(cp: ColumnProfile, ctx: RuleContext) -> int:
     return sum(ctx.profile.sentinels.get(cp.name, {}).values())
 
 
+def _post_cast_missing(cp: ColumnProfile, ctx: RuleContext) -> Tuple[int, float]:
+    """Count and fraction of missing cells once cast-introduced NaN are counted too.
+
+    ``cp.missing_fraction`` is measured on the raw frame; this is the number the
+    decision that consumes it is actually taken on.  Centralising the arithmetic here
+    means the three rules keyed on it (``drop_high_missing``, ``missing_indicator``,
+    ``impute_by_type``) record the same fraction in ``params`` rather than each
+    reporting the pre-cast figure while its rationale describes the post-cast one --
+    see #18.  ``cp.missing_fraction`` itself is untouched and still what the rationale
+    text quotes when it deliberately contrasts "reported" against "effective".
+    """
+    cast_missing = _cast_missing(cp, ctx)
+    missing_fraction = (cp.n_missing + cast_missing) / cp.n_rows if cp.n_rows else 0.0
+    return cast_missing, missing_fraction
+
+
 def _rule_impute(cp: ColumnProfile, ctx: RuleContext) -> Optional[Decision]:
     if cp.is_target:
         return None
@@ -397,7 +413,7 @@ def _rule_impute(cp: ColumnProfile, ctx: RuleContext) -> Optional[Decision]:
     outlier_may_impute = (
         cp.semantic is SemanticType.NUMERIC and ctx.config.outlier_strategy == "impute"
     )
-    cast_missing = _cast_missing(cp, ctx)
+    cast_missing, missing_fraction = _post_cast_missing(cp, ctx)
     if cp.n_missing == 0 and not cast_missing and user is None and not outlier_may_impute:
         return None
 
@@ -436,6 +452,11 @@ def _rule_impute(cp: ColumnProfile, ctx: RuleContext) -> Optional[Decision]:
             f"{cast_missing} placeholder value(s) become NaN when the column is cast, "
             f"so it needs imputation despite reporting 0.0% missing"
         )
+    elif outlier_may_impute:
+        found = (
+            "0.0% missing today, but outlier_strategy='impute' may introduce NaN at the "
+            "OUTLIERS stage that runs before this one"
+        )
     else:
         found = f"{_pct(cp.missing_fraction)} missing"
 
@@ -481,7 +502,8 @@ def _rule_impute(cp: ColumnProfile, ctx: RuleContext) -> Optional[Decision]:
         f"impute_{strategy}",
         params={
             "strategy": strategy,
-            "missing_fraction": round(cp.missing_fraction, 4),
+            "missing_fraction": round(missing_fraction, 4),
+            "n_rows": cp.n_rows,
             **({"cast_missing": cast_missing} if cast_missing else {}),
         },
         rationale=reason,

{edaprep-0.2.1 → edaprep-0.3.0}/src/edaprep/preprocessing/__init__.py

@@ -8,6 +8,7 @@ from .casting import DataTypeInference
 from .datetime_features import DateTimeExpander
 from .duplicates import DuplicateRowHandler, duplicate_report
 from .encoding import (
+    BinaryEncoder,
     CategoricalEncoder,
     FrequencyEncoder,
     OneHotEncoder,
@@ -51,6 +52,7 @@ __all__ = [
     "detect_outliers",
     "CategoricalEncoder",
     "OneHotEncoder",
+    "BinaryEncoder",
     "OrdinalEncoder",
     "FrequencyEncoder",
     "TargetEncoder",

{edaprep-0.2.1 → edaprep-0.3.0}/src/edaprep/preprocessing/casting.py

@@ -146,7 +146,7 @@ class DataTypeInference(Transformer, ColumnTransformerMixin):
                     stripped = series.astype(object).map(
                         lambda v: v.strip() if isinstance(v, str) else v
                     )
-                    counts["stripped"] = int((stripped != series).sum())
+                    counts["stripped"] = int(((stripped != series) & series.notna()).sum())
                     series = stripped
 
                 if "sentinels_to_nan" in actions:

{edaprep-0.2.1 → edaprep-0.3.0}/src/edaprep/preprocessing/datetime_features.py

@@ -43,13 +43,13 @@ _EXTRACTORS: Dict[str, Callable[[pd.Series], pd.Series]] = {
     "hour": lambda s: s.dt.hour,
     "minute": lambda s: s.dt.minute,
     "second": lambda s: s.dt.second,
-    "is_weekend": lambda s: (s.dt.dayofweek >= 5).astype("float64"),
-    "is_month_start": lambda s: s.dt.is_month_start.astype("float64"),
-    "is_month_end": lambda s: s.dt.is_month_end.astype("float64"),
-    "is_quarter_start": lambda s: s.dt.is_quarter_start.astype("float64"),
-    "is_quarter_end": lambda s: s.dt.is_quarter_end.astype("float64"),
-    "is_year_start": lambda s: s.dt.is_year_start.astype("float64"),
-    "is_year_end": lambda s: s.dt.is_year_end.astype("float64"),
+    "is_weekend": lambda s: (s.dt.dayofweek >= 5).astype("float64").where(s.notna()),
+    "is_month_start": lambda s: s.dt.is_month_start.astype("float64").where(s.notna()),
+    "is_month_end": lambda s: s.dt.is_month_end.astype("float64").where(s.notna()),
+    "is_quarter_start": lambda s: s.dt.is_quarter_start.astype("float64").where(s.notna()),
+    "is_quarter_end": lambda s: s.dt.is_quarter_end.astype("float64").where(s.notna()),
+    "is_year_start": lambda s: s.dt.is_year_start.astype("float64").where(s.notna()),
+    "is_year_end": lambda s: s.dt.is_year_end.astype("float64").where(s.notna()),
     "month_sin": lambda s: np.sin(2 * np.pi * s.dt.month / 12.0),
     "month_cos": lambda s: np.cos(2 * np.pi * s.dt.month / 12.0),
     "dayofweek_sin": lambda s: np.sin(2 * np.pi * s.dt.dayofweek / 7.0),

{edaprep-0.2.1 → edaprep-0.3.0}/src/edaprep/preprocessing/encoding.py

@@ -33,6 +33,7 @@ from ..types import CATEGORICAL_LIKE, ModelFamily, SemanticType, Severity, Stage
 __all__ = [
     "RareCategoryGrouper",
     "OneHotEncoder",
+    "BinaryEncoder",
     "OrdinalEncoder",
     "FrequencyEncoder",
     "TargetEncoder",
@@ -336,6 +337,99 @@ class OneHotEncoder(_CategoricalBase):
         return out
 
 
+class BinaryEncoder(_CategoricalBase):
+    """Expand each category into ``ceil(log2(n))`` binary indicator columns.
+
+    A middle ground between one-hot (``n`` columns) and ordinal (one column with a
+    false ordering).  Unseen categories at transform time are encoded as all-zero,
+    consistent with :class:`OneHotEncoder`.
+    """
+
+    stage = Stage.ENCODE
+
+    def __init__(
+        self,
+        columns: Optional[Sequence[str]] = None,
+        dtype: str = "int8",
+    ) -> None:
+        super().__init__(columns)
+        self.dtype = dtype
+
+    def _fit(self, X: pd.DataFrame, y: Optional[pd.Series], context: FitContext) -> None:
+        self.categories_: Dict[str, List[Any]] = {}
+        self.mappings_: Dict[str, Dict[Any, int]] = {}
+        self.n_bits_: Dict[str, int] = {}
+        self.output_names_: Dict[str, List[str]] = {}
+
+        with context.journal.timer(self.stage, type(self).__name__, "fit", "fit") as timer:
+            total = 0
+            for column in self.columns_:
+                series = self._as_object(X[column])
+                categories = sorted(series.dropna().unique(), key=_sort_key)
+                self.categories_[column] = categories
+                self.mappings_[column] = {c: i for i, c in enumerate(categories)}
+                n_bits = int(np.ceil(np.log2(max(len(categories), 1))))
+                self.n_bits_[column] = n_bits
+                self.output_names_[column] = [f"{column}__bin{i}" for i in range(n_bits)]
+                total += n_bits
+
+            timer.columns = list(self.columns_)
+            timer.effect = {"n_output_columns": total}
+
+    def _transform(self, X: pd.DataFrame, context: FitContext) -> pd.DataFrame:
+        added: Dict[str, pd.Series] = {}
+        unknown_counts: Dict[str, int] = {}
+
+        with context.journal.timer(
+            self.stage, type(self).__name__, "binary", "transform"
+        ) as timer:
+            for column in self.columns_:
+                if column not in X.columns:
+                    continue
+                series = self._as_object(X[column])
+                mapping = self.mappings_[column]
+                integer_codes = series.map(mapping)
+                unknown = series.notna() & integer_codes.isna()
+                n_unknown = int(unknown.sum())
+                if n_unknown:
+                    unknown_counts[column] = n_unknown
+
+                known = integer_codes.notna()
+                codes_int = integer_codes[known].to_numpy(dtype=np.int64)
+                for bit, name in enumerate(self.output_names_[column]):
+                    values = np.zeros(len(X), dtype=self.dtype)
+                    if known.any():
+                        values[known.to_numpy()] = ((codes_int >> bit) & 1).astype(self.dtype)
+                    added[name] = pd.Series(values, index=X.index, name=name)
+
+            if unknown_counts:
+                context.journal.warn(
+                    "unseen_categories",
+                    f"{sum(unknown_counts.values())} value(s) across "
+                    f"{len(unknown_counts)} column(s) were not present at fit time and "
+                    f"were encoded as all-zero indicators: "
+                    f"{', '.join(sorted(unknown_counts))}.",
+                    Severity.INFO,
+                    tuple(unknown_counts),
+                    unknown_counts,
+                )
+
+            timer.columns = list(self.categories_)
+            timer.effect = {
+                "n_output_columns": len(added),
+                "n_unknown_values": unknown_counts,
+            }
+
+        remaining = {str(c): X[c] for c in X.columns if str(c) not in self.categories_}
+        return pd.DataFrame({**remaining, **added}, index=X.index, copy=False)
+
+    def _compute_feature_names_out(self) -> List[str]:
+        out = [c for c in self.feature_names_in_ if c not in self.categories_]
+        for column in self.categories_:
+            out.extend(self.output_names_[column])
+        return out
+
+
 class OrdinalEncoder(_CategoricalBase):
     """Map categories to integer codes.
 
@@ -343,6 +437,12 @@ class OrdinalEncoder(_CategoricalBase):
     subset of codes, and for genuinely ordered columns.  It imposes a false ordering on
     a nominal column fed to a linear or distance-based model, which is why the planner
     only selects it for ``model_family="tree"`` or ``SemanticType.ORDINAL``.
+
+    The ``dtype`` parameter (default ``"int32"``) is applied to encoded columns. When
+    missing values are present and ``dtype`` cannot represent NA (such as standard numpy
+    integer types), the column safely falls back to ``"float64"`` so downstream imputers
+    can process it. Nullable integer dtypes (e.g. ``"Int32"``) are preserved with missing
+    values.
     """
 
     stage = Stage.ENCODE
@@ -403,7 +503,13 @@ class OrdinalEncoder(_CategoricalBase):
                 # NaN in the input stays NaN so a later imputer can see it; only
                 # genuinely unseen categories get the sentinel code.
                 codes = codes.mask(unknown, self.unknown_value)
-                replacements[column] = codes.astype("float64")
+                if codes.isna().any():
+                    try:
+                        replacements[column] = codes.astype(self.dtype)
+                    except (ValueError, TypeError):
+                        replacements[column] = codes.astype("float64")
+                else:
+                    replacements[column] = codes.astype(self.dtype)
 
             if unknown_counts:
                 context.journal.warn(
@@ -734,13 +840,11 @@ class CategoricalEncoder(_CategoricalBase):
         if strategy == "target":
             return TargetEncoder(cols)
         if strategy == "binary":
-            raise ConfigurationError(
-                "encoding='binary' is not implemented in this version. Use 'frequency' "
-                "or 'target' for high-cardinality columns; both produce a single "
-                "column and are better understood."
-            )
+            return BinaryEncoder(cols)
         raise ConfigurationError.unknown_option(
-            "encoding", strategy, ["onehot", "ordinal", "frequency", "count", "target"]
+            "encoding",
+            strategy,
+            ["onehot", "ordinal", "frequency", "count", "target", "binary"],
         )
 
     def _fit_transform(
@@ -774,12 +878,17 @@ class CategoricalEncoder(_CategoricalBase):
         return X[keep]
 
     def _compute_feature_names_out(self) -> List[str]:
-        # Must match _transform exactly.  One-hot appends its indicator columns at the
-        # end rather than expanding in place (expanding in place would mean rebuilding
+        # Must match _transform exactly.  One-hot and binary append indicator columns at
+        # the end rather than expanding in place (expanding in place would mean rebuilding
         # the frame around each encoded column), so the names have to be appended too.
         # Ordinal, frequency and target encoding all replace their column in position.
         onehot = self.encoders_.get("onehot")
-        encoded_away = set(getattr(onehot, "categories_", {})) if onehot else set()
+        binary = self.encoders_.get("binary")
+        encoded_away = set()
+        if onehot is not None:
+            encoded_away.update(onehot.categories_)  # type: ignore[attr-defined]
+        if binary is not None:
+            encoded_away.update(binary.categories_)  # type: ignore[attr-defined]
         names = [
             c
             for c in self.feature_names_in_
@@ -788,4 +897,7 @@ class CategoricalEncoder(_CategoricalBase):
         if onehot is not None:
             for column in onehot.categories_:  # type: ignore[attr-defined]
                 names.extend(onehot.output_names_[column])  # type: ignore[attr-defined]
+        if binary is not None:
+            for column in binary.categories_:  # type: ignore[attr-defined]
+                names.extend(binary.output_names_[column])  # type: ignore[attr-defined]
         return names