xplainable-preprocessing 0.2.2__tar.gz → 0.2.3__tar.gz

{xplainable_preprocessing-0.2.2 → xplainable_preprocessing-0.2.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: xplainable-preprocessing
-Version: 0.2.2
+Version: 0.2.3
 Summary: Shared preprocessing pipeline package for xplainable
 Requires-Python: >=3.9
 Requires-Dist: cloudpickle>=3.0

{xplainable_preprocessing-0.2.2 → xplainable_preprocessing-0.2.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "xplainable-preprocessing"
-version = "0.2.2"
+version = "0.2.3"
 description = "Shared preprocessing pipeline package for xplainable"
 requires-python = ">=3.9"
 dependencies = [

{xplainable_preprocessing-0.2.2 → xplainable_preprocessing-0.2.3}/src/xplainable_preprocessing/compiler.py

@@ -3,6 +3,9 @@
 from __future__ import annotations
 
 import inspect
+import logging
+
+logger = logging.getLogger(__name__)
 
 from xplainable_preprocessing.pipeline import DataFrameColumnTransformer, DataFramePipeline
 from xplainable_preprocessing.registry import REGISTRY
@@ -11,14 +14,29 @@ from xplainable_preprocessing.schema import PipelineSpec
 
 
 def _coerce_params(cls, params: dict) -> dict:
-    """Convert list params to tuples where the constructor expects them.
+    """Adapt spec params to the constructor's signature.
 
-    JSON has no tuple type, so specs always contain lists. sklearn transformers
-    like MinMaxScaler expect tuples for params like feature_range.
+    - Converts list params to tuples where the constructor expects them
+      (JSON has no tuple type, so specs always contain lists; sklearn
+      transformers like MinMaxScaler expect tuples for feature_range).
+    - Drops params the constructor does not accept, with a warning. Specs
+      may be generated in an env with a newer sklearn than the one
+      compiling them (2026-07: sklearn 1.7 emitted
+      KBinsDiscretizer(quantile_method=...), which 1.6 rejects).
     """
     sig = inspect.signature(cls.__init__)
+    accepts_kwargs = any(
+        p.kind is inspect.Parameter.VAR_KEYWORD for p in sig.parameters.values()
+    )
     coerced = {}
     for key, value in params.items():
+        if key not in sig.parameters and not accepts_kwargs:
+            logger.warning(
+                "%s does not accept param '%s' in this environment "
+                "(likely a library-version mismatch with the spec's "
+                "generator); dropping it", cls.__name__, key
+            )
+            continue
         if isinstance(value, list) and key in sig.parameters:
             param = sig.parameters[key]
             if param.default is not inspect.Parameter.empty and isinstance(param.default, tuple):
@@ -48,6 +66,8 @@ def compile_spec(spec: PipelineSpec) -> DataFramePipeline:
     steps = []
 
     for step in spec.steps:
+        wrap = bool(step.columns)
+
         if step.type == "custom":
             transformer = compile_custom(step.params)
         else:
@@ -58,9 +78,18 @@ def compile_spec(spec: PipelineSpec) -> DataFramePipeline:
                 )
             cls = REGISTRY[step.type]
             params = _coerce_params(cls, step.params)
+
+            # Column-aware transformers (constructor takes `columns`) must
+            # receive the step-level columns directly and must NOT be wrapped:
+            # DataFrameColumnTransformer feeds them only their declared columns
+            # and re-attaches the result, which turns e.g. a drop into a no-op.
+            if step.columns and "columns" in inspect.signature(cls.__init__).parameters:
+                params.setdefault("columns", step.columns)
+                wrap = False
+
             transformer = cls(**params)
 
-        if step.columns:
+        if wrap:
             transformer = DataFrameColumnTransformer(transformer, step.columns)
 
         steps.append((step.id, transformer))

{xplainable_preprocessing-0.2.2 → xplainable_preprocessing-0.2.3}/tests/test_compiler.py

@@ -34,6 +34,40 @@ class TestCompileSpec:
         name, transformer = pipeline.steps[0]
         assert not isinstance(transformer, DataFrameColumnTransformer)
 
+    def test_step_level_columns_on_drop_actually_drops(self):
+        # Specs commonly declare columns at the step level with empty params.
+        # DropColumnsTransformer is column-aware: wrapping it in
+        # DataFrameColumnTransformer turns the drop into a no-op (the wrapper
+        # re-attaches the "transformed" — i.e. untouched — columns).
+        spec = PipelineSpec(steps=[
+            StepSpec(id="drop", type="DropColumnsTransformer",
+                     columns=["id", "count"], params={}),
+        ])
+        pipeline = compile_spec(spec)
+        df = pd.DataFrame({"id": [1, 2], "count": [3, 4], "value": [5.0, 6.0]})
+        result = pipeline.fit_transform(df)
+        assert list(result.columns) == ["value"]
+
+    def test_step_level_columns_injected_into_column_aware_transformer(self):
+        spec = PipelineSpec(steps=[
+            StepSpec(id="drop", type="DropColumnsTransformer",
+                     columns=["id"], params={}),
+        ])
+        pipeline = compile_spec(spec)
+        _, transformer = pipeline.steps[0]
+        assert not isinstance(transformer, DataFrameColumnTransformer)
+        assert transformer.columns == ["id"]
+
+    def test_params_columns_take_precedence_over_step_columns(self):
+        spec = PipelineSpec(steps=[
+            StepSpec(id="drop", type="DropColumnsTransformer",
+                     columns=["id"], params={"columns": ["count"]}),
+        ])
+        pipeline = compile_spec(spec)
+        _, transformer = pipeline.steps[0]
+        assert not isinstance(transformer, DataFrameColumnTransformer)
+        assert transformer.columns == ["count"]
+
     def test_unknown_type_raises(self):
         spec = PipelineSpec(steps=[
             StepSpec(id="bad", type="FakeTransformer"),
@@ -118,3 +152,51 @@ class TestCompileSpec:
         assert "id" not in result.columns
         assert "value" in result.columns
         assert not result["value"].isna().any()
+
+
+class TestUnsupportedParamFiltering:
+    """Specs may be generated in an env with a newer sklearn than the one
+    compiling them (2026-07: autotrain on sklearn 1.7 emitted
+    KBinsDiscretizer(quantile_method=...), which the API's sklearn 1.6
+    constructor rejects). Unknown constructor params must be dropped with a
+    warning instead of crashing compilation."""
+
+    def test_unknown_param_is_dropped_with_warning(self, caplog):
+        import logging
+
+        spec = PipelineSpec(steps=[
+            StepSpec(
+                id="bin",
+                type="KBinsDiscretizer",
+                columns=["age"],
+                params={
+                    "n_bins": 4,
+                    "encode": "ordinal",
+                    "strategy": "quantile",
+                    "definitely_not_a_real_sklearn_param": "x",
+                },
+            ),
+        ])
+        with caplog.at_level(logging.WARNING):
+            pipeline = compile_spec(spec)
+
+        _, transformer = pipeline.steps[0]
+        inner = transformer.transformer
+        assert inner.n_bins == 4
+        assert not hasattr(inner, "definitely_not_a_real_sklearn_param")
+        assert any("definitely_not_a_real_sklearn_param" in r.message
+                   for r in caplog.records)
+
+    def test_supported_params_pass_through_unchanged(self):
+        spec = PipelineSpec(steps=[
+            StepSpec(
+                id="bin",
+                type="KBinsDiscretizer",
+                columns=["age"],
+                params={"n_bins": 3, "encode": "ordinal"},
+            ),
+        ])
+        pipeline = compile_spec(spec)
+        _, transformer = pipeline.steps[0]
+        assert transformer.transformer.n_bins == 3
+        assert transformer.transformer.encode == "ordinal"