edaprep 0.2.1__tar.gz → 0.2.2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edaprep
-Version: 0.2.1
+Version: 0.2.2
 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.2.2}/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.2.2/src/edaprep/_version.py

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

{edaprep-0.2.1 → edaprep-0.2.2}/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
 
@@ -481,7 +497,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.2.2}/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.2.2}/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.
 
@@ -734,13 +828,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 +866,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 +885,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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: edaprep
-Version: 0.2.1
+Version: 0.2.2
 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.2.2}/tests/test_pipeline.py

@@ -794,6 +794,75 @@ def test_column_with_real_nan_still_gets_a_missing_indicator() -> None:
     assert int(out["amount__was_missing"].sum()) == 24
 
 
+def test_missing_fraction_is_consistent_across_the_three_cast_missing_rules() -> None:
+    """#18: drop_high_missing, missing_indicator and impute_by_type must agree.
+
+    Regression: all three rules read cast-introduced placeholders (see #16 / #14), but
+    only stored the pre-cast ``cp.missing_fraction`` in ``params`` while their rationale
+    quoted the post-cast figure -- a decision whose prose says "above the 5.0% flag
+    threshold" reporting ``missing_fraction=0.0`` in the machine-readable half. One frame
+    with three columns, one per rule, and every decision must report the same
+    (post-cast) fraction plus the ``n_rows`` needed to reconstruct it.
+    """
+    gen = np.random.default_rng(41)
+    n = 300
+
+    def blanks(count: int) -> list:
+        values = [f"{v:.2f}" for v in gen.uniform(20, 8000, size=n)]
+        for i in range(count):
+            values[i] = ""
+        return values
+
+    frame = pd.DataFrame(
+        {
+            "col_impute": blanks(6),  # 2%: below the 5% indicator threshold
+            "col_indicator": blanks(24),  # 8%: indicator, then impute
+            "col_drop": blanks(210),  # 70%: above the 60% drop ceiling
+            "y": gen.integers(0, 2, size=n),
+        }
+    )
+
+    pipe = AutoPipeline(target="y", model_family="linear", random_state=0)
+    pipe.fit(frame)
+    plan = pipe.plan_
+
+    expected = {
+        "col_impute": (6, 6 / n),
+        "col_indicator": (24, 24 / n),
+        "col_drop": (210, 210 / n),
+    }
+    tracked_actions = {"drop", "add_missing_indicator"}
+    for column, (cast_missing, fraction) in expected.items():
+        for decision in plan.decisions:
+            if decision.column != column:
+                continue
+            if decision.action not in tracked_actions and not decision.action.startswith(
+                "impute_"
+            ):
+                continue
+            assert decision.params.get("cast_missing") == cast_missing, decision
+            assert decision.params["missing_fraction"] == pytest.approx(fraction), decision
+            assert decision.params["n_rows"] == n, decision
+
+    actions = {d.column: d.action for d in plan.decisions if d.action.startswith("impute_")}
+    assert actions.get("col_impute", "").startswith("impute_")
+    assert actions.get("col_indicator", "").startswith("impute_")
+    assert "col_drop" not in actions, (
+        "a dropped column must not also be scheduled for imputation"
+    )
+    indicator_columns = {
+        d.column for d in plan.decisions if d.action == "add_missing_indicator"
+    }
+    assert indicator_columns == {"col_indicator"}
+    assert "col_drop" in plan.dropped_columns
+
+    # The new key must survive a JSON round-trip like every other param.
+    restored = Plan.from_dict(json.loads(plan.to_json()))
+    before = {(d.column, d.action): d.params for d in plan.decisions}
+    after = {(d.column, d.action): d.params for d in restored.decisions}
+    assert before == after
+
+
 def test_from_dict_tolerates_settings_this_version_removed() -> None:
     """A Config saved before a setting was retired must still load.
 

{edaprep-0.2.1 → edaprep-0.2.2}/tests/test_transformers.py

@@ -15,6 +15,7 @@ from edaprep.exceptions import (
     TransformationError,
 )
 from edaprep.preprocessing import (
+    BinaryEncoder,
     CategoricalEncoder,
     ColumnDropper,
     ConstantFilter,
@@ -396,6 +397,47 @@ def test_onehot_drop_first() -> None:
     assert list(out.columns) == ["c_b", "c_c"]
 
 
+def test_binary_encoder_distinct_categories_get_distinct_codes() -> None:
+    frame = pd.DataFrame({"c": ["a", "b", "c", "d"]})
+    out = BinaryEncoder(["c"]).fit_transform(frame, None, ctx(frame))
+    codes = [tuple(row) for row in out.to_numpy()]
+    assert len(codes) == len(set(codes))
+
+
+def test_binary_encoder_output_width() -> None:
+    for n in (1, 2, 3, 4, 5, 8, 9):
+        categories = [f"v{i}" for i in range(n)]
+        frame = pd.DataFrame({"c": categories})
+        out = BinaryEncoder(["c"]).fit_transform(frame, None, ctx(frame))
+        expected = int(np.ceil(np.log2(max(n, 1))))
+        assert len([c for c in out.columns if c.startswith("c__bin")]) == expected
+
+
+def test_binary_column_order_is_deterministic() -> None:
+    gen = np.random.default_rng(81)
+    frame = pd.DataFrame({"c": gen.choice(list("dcba"), 100)})
+    a = BinaryEncoder(["c"]).fit_transform(frame, None, ctx(frame))
+    b = BinaryEncoder(["c"]).fit_transform(frame.iloc[::-1], None, ctx(frame))
+    assert list(a.columns) == list(b.columns)
+    assert list(a.columns) == ["c__bin0", "c__bin1"]
+
+
+def test_binary_encoder_unseen_category_is_all_zero() -> None:
+    train = pd.DataFrame({"c": ["a", "b", "c", "d"] * 20})
+    context = ctx(train)
+    encoder = BinaryEncoder(["c"]).fit(train, None, context)
+    out = encoder.transform(pd.DataFrame({"c": ["zzz"]}), context)
+    assert out.to_numpy().tolist() == [[0, 0]]
+
+
+def test_binary_encoder_feature_names_match_columns() -> None:
+    frame = pd.DataFrame({"c": ["a", "b", "c", "d", "e"]})
+    context = ctx(frame)
+    encoder = BinaryEncoder(["c"]).fit(frame, None, context)
+    out = encoder.transform(frame, context)
+    assert list(encoder.get_feature_names_out()) == list(out.columns)
+
+
 def test_ordinal_encoder_honours_an_ordered_categorical() -> None:
     dtype = pd.CategoricalDtype(["low", "medium", "high"], ordered=True)
     frame = pd.DataFrame({"c": pd.Series(["high", "low", "medium"], dtype=dtype)})
@@ -798,6 +840,7 @@ ALL_TRANSFORMERS = [
     OutlierHandler,
     CategoricalEncoder,
     OneHotEncoder,
+    BinaryEncoder,
     OrdinalEncoder,
     FrequencyEncoder,
     RareCategoryGrouper,

edaprep-0.2.1/src/edaprep/_version.py

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