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

xplainable_preprocessing-0.2.2/.github/workflows/publish-pypi.yml

@@ -0,0 +1,42 @@
+name: Publish to PyPI
+
+on:
+  push:
+    tags:
+      - 'v*'
+
+jobs:
+  publish:
+    runs-on: ubuntu-latest
+    permissions:
+      id-token: write
+      contents: write
+
+    steps:
+    - uses: actions/checkout@v4
+
+    - name: Set up Python
+      uses: actions/setup-python@v5
+      with:
+        python-version: '3.11'
+
+    - name: Install build tools
+      run: pip install build
+
+    - name: Build package
+      run: python -m build
+
+    - name: Publish to PyPI
+      uses: pypa/gh-action-pypi-publish@release/v1
+      with:
+        password: ${{ secrets.PYPI_API_TOKEN }}
+
+    - name: Create GitHub Release
+      env:
+        GH_TOKEN: ${{ github.token }}
+      run: |
+        VERSION=${GITHUB_REF_NAME}
+        gh release create "$VERSION" dist/* \
+          --title "$VERSION" \
+          --generate-notes \
+          --latest

xplainable_preprocessing-0.2.2/.gitignore

@@ -0,0 +1 @@
+.env

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

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

xplainable_preprocessing-0.2.2/README.md

@@ -0,0 +1,164 @@
+# xplainable-preprocessing
+
+Shared preprocessing pipeline library for [xplainable](https://xplainable.io). Define, compile, fit, serialise, and apply data transformation pipelines using a declarative JSON spec.
+
+## Install
+
+```bash
+pip install xplainable-preprocessing
+```
+
+## Quick Start
+
+### Define a pipeline as JSON
+
+```python
+from xplainable_preprocessing.schema import PipelineSpec
+from xplainable_preprocessing.compiler import compile_spec
+
+spec = PipelineSpec(
+    version="2.0",
+    steps=[
+        {"id": "drop_ids", "type": "DropColumnsTransformer", "params": {"columns": ["customer_id", "row_id"]}},
+        {"id": "fill_numeric", "type": "FillMissingTransformer", "columns": ["tenure", "charges"], "params": {"strategies": {"tenure": "median", "charges": "median"}}},
+        {"id": "clip_outliers", "type": "ClipTransformer", "columns": ["charges"], "params": {"min_val": 0, "max_val": 500}},
+        {"id": "missing_flags", "type": "MissingFlagTransformer", "columns": ["tenure", "charges"]},
+        {"id": "condense_plan", "type": "CategoryCondenseTransformer", "columns": ["plan_type"], "params": {"max_categories": 10}},
+        {"id": "extract_dates", "type": "DateTimeExtractTransformer", "columns": ["signup_date"], "params": {"components": ["month", "dayofweek"], "drop_original": true}},
+    ]
+)
+
+pipeline = compile_spec(spec)
+```
+
+### Fit and transform
+
+```python
+import pandas as pd
+
+df = pd.read_csv("data.csv")
+pipeline.fit(df)
+transformed = pipeline.transform(df)
+```
+
+### Serialise and load
+
+```python
+from xplainable_preprocessing.serialization import save_pipeline, load_pipeline
+
+# Save
+binary = save_pipeline(pipeline)
+
+# Load
+loaded = load_pipeline(binary)
+result = loaded.transform(new_data)
+```
+
+## Available Transformers
+
+### Data Cleaning
+| Transformer | Description |
+|-------------|-------------|
+| `DropColumnsTransformer` | Drop specified columns |
+| `RenameColumnsTransformer` | Rename columns |
+| `TypeCastTransformer` | Cast column dtypes (e.g. str to float64, with error coercion) |
+| `ClipTransformer` | Clip numeric values outside (min, max) to NaN |
+
+### Missing Values
+| Transformer | Description |
+|-------------|-------------|
+| `FillMissingTransformer` | Fill nulls with median, mode, constant, or other strategies |
+| `MissingFlagTransformer` | Create binary 0/1 indicator columns for nulls |
+
+### Feature Engineering
+| Transformer | Description |
+|-------------|-------------|
+| `ExpressionTransformer` | Create derived columns via pandas expressions |
+| `DateTimeExtractTransformer` | Extract year, month, dayofweek, etc. from datetime columns |
+| `GroupByAggTransformer` | Aggregate features by group (count, sum, mean) |
+| `GroupedLagTransformer` | Create lagged features within groups |
+| `RollingAggTransformer` | Rolling window aggregations |
+
+### Categorical
+| Transformer | Description |
+|-------------|-------------|
+| `CategoryCondenseTransformer` | Condense high-cardinality categoricals to top N + "Other" |
+| `TextCleanTransformer` | Clean text: lowercase, strip, remove HTML/extra whitespace |
+
+### Scaling (use with caution -- breaks xplainable model explainability)
+| Transformer | Description |
+|-------------|-------------|
+| `StandardScaler` | Standardise to zero mean, unit variance |
+| `MinMaxScaler` | Scale to [0, 1] range |
+| `RobustScaler` | Scale using median and IQR |
+| `PowerTransformer` | Apply power transform for normality |
+| `QuantileTransformer` | Transform to uniform or normal distribution |
+
+> **Note:** Scaling transformers are available but should NOT be used with xplainable models. xplainable models are inherently explainable and require raw feature values. Scaling destroys interpretability.
+
+### Other sklearn
+| Transformer | Description |
+|-------------|-------------|
+| `SimpleImputer` | sklearn's imputer |
+| `OneHotEncoder` | One-hot encode categoricals |
+| `OrdinalEncoder` | Ordinal encode categoricals |
+| `KBinsDiscretizer` | Discretise continuous features into bins |
+| `Binarizer` | Threshold features to binary |
+
+## Pipeline Spec Format
+
+Pipelines are defined as JSON for portability across the xplainable platform, MCP tools, and API:
+
+```json
+{
+    "version": "2.0",
+    "steps": [
+        {
+            "id": "step_name",
+            "type": "TransformerName",
+            "columns": ["col1", "col2"],
+            "params": {"param1": "value1"},
+            "description": "Optional description"
+        }
+    ]
+}
+```
+
+- `id`: unique step identifier
+- `type`: transformer class name (from the registry)
+- `columns`: optional list of columns to apply to (wraps in `DataFrameColumnTransformer`)
+- `params`: constructor arguments for the transformer
+- `description`: optional human-readable description
+
+## Architecture
+
+```
+PipelineSpec (JSON)
+    ↓ compile_spec()
+DataFramePipeline (sklearn Pipeline of transformers)
+    ↓ fit() / transform()
+Transformed DataFrame
+    ↓ save_pipeline()
+Binary (cloudpickle)
+    ↓ load_pipeline()
+DataFramePipeline (restored)
+```
+
+Key modules:
+- `schema.py` -- Pydantic models for `PipelineSpec` and `StepSpec`
+- `compiler.py` -- compiles JSON spec into sklearn pipeline
+- `pipeline.py` -- `DataFramePipeline` wrapper around sklearn `Pipeline`
+- `registry.py` -- maps transformer names to classes, generates LLM-ready catalog
+- `serialization.py` -- cloudpickle save/load
+- `preview.py` -- before/after preview with schema deltas
+
+## Development
+
+```bash
+pip install -e ".[dev]"
+pytest
+```
+
+## License
+
+MIT

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

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

{xplainable_preprocessing-0.2.0 → xplainable_preprocessing-0.2.2}/src/xplainable_preprocessing/registry.py

@@ -20,11 +20,14 @@ from sklearn.preprocessing import (
 
 from xplainable_preprocessing.transformers import (
     CategoryCondenseTransformer,
+    ClipTransformer,
     DateTimeExtractTransformer,
     DropColumnsTransformer,
     ExpressionTransformer,
     FillMissingTransformer,
+    GroupByAggTransformer,
     GroupedLagTransformer,
+    MissingFlagTransformer,
     RenameColumnsTransformer,
     RollingAggTransformer,
     TextCleanTransformer,
@@ -55,6 +58,9 @@ REGISTRY: dict[str, type] = {
     "DateTimeExtractTransformer": DateTimeExtractTransformer,
     "GroupedLagTransformer": GroupedLagTransformer,
     "RollingAggTransformer": RollingAggTransformer,
+    "GroupByAggTransformer": GroupByAggTransformer,
+    "ClipTransformer": ClipTransformer,
+    "MissingFlagTransformer": MissingFlagTransformer,
 }
 
 

{xplainable_preprocessing-0.2.0 → xplainable_preprocessing-0.2.2}/src/xplainable_preprocessing/transformers/__init__.py

@@ -1,23 +1,29 @@
-from xplainable_preprocessing.transformers.expression import ExpressionTransformer
-from xplainable_preprocessing.transformers.drop_columns import DropColumnsTransformer
-from xplainable_preprocessing.transformers.rename_columns import RenameColumnsTransformer
-from xplainable_preprocessing.transformers.type_cast import TypeCastTransformer
-from xplainable_preprocessing.transformers.fill_missing import FillMissingTransformer
 from xplainable_preprocessing.transformers.category_condense import CategoryCondenseTransformer
-from xplainable_preprocessing.transformers.text_clean import TextCleanTransformer
+from xplainable_preprocessing.transformers.clip import ClipTransformer
 from xplainable_preprocessing.transformers.datetime_extract import DateTimeExtractTransformer
+from xplainable_preprocessing.transformers.drop_columns import DropColumnsTransformer
+from xplainable_preprocessing.transformers.expression import ExpressionTransformer
+from xplainable_preprocessing.transformers.fill_missing import FillMissingTransformer
+from xplainable_preprocessing.transformers.groupby_agg import GroupByAggTransformer
 from xplainable_preprocessing.transformers.grouped_lag import GroupedLagTransformer
+from xplainable_preprocessing.transformers.missing_flag import MissingFlagTransformer
+from xplainable_preprocessing.transformers.rename_columns import RenameColumnsTransformer
 from xplainable_preprocessing.transformers.rolling_agg import RollingAggTransformer
+from xplainable_preprocessing.transformers.text_clean import TextCleanTransformer
+from xplainable_preprocessing.transformers.type_cast import TypeCastTransformer
 
 __all__ = [
-    "ExpressionTransformer",
-    "DropColumnsTransformer",
-    "RenameColumnsTransformer",
-    "TypeCastTransformer",
-    "FillMissingTransformer",
     "CategoryCondenseTransformer",
-    "TextCleanTransformer",
+    "ClipTransformer",
     "DateTimeExtractTransformer",
+    "DropColumnsTransformer",
+    "ExpressionTransformer",
+    "FillMissingTransformer",
+    "GroupByAggTransformer",
     "GroupedLagTransformer",
+    "MissingFlagTransformer",
+    "RenameColumnsTransformer",
     "RollingAggTransformer",
+    "TextCleanTransformer",
+    "TypeCastTransformer",
 ]

xplainable_preprocessing-0.2.2/src/xplainable_preprocessing/transformers/clip.py

@@ -0,0 +1,45 @@
+"""Clip transformer -- clips numeric values outside a range to NaN."""
+
+from __future__ import annotations
+
+import numpy as np
+import pandas as pd
+from sklearn.base import BaseEstimator, TransformerMixin
+
+
+class ClipTransformer(BaseEstimator, TransformerMixin):
+    """Clip numeric values outside (min_val, max_val) to NaN.
+
+    Useful for nulling out physically impossible values
+    (e.g. BMI of 0, 2090 push-ups) so they don't create
+    junk bins in the model.
+
+    Parameters
+    ----------
+    min_val : float | None
+        Values strictly below this are set to NaN. None means no lower bound.
+    max_val : float | None
+        Values strictly above this are set to NaN. None means no upper bound.
+    """
+
+    def __init__(
+        self,
+        min_val: float | None = None,
+        max_val: float | None = None,
+    ):
+        self.min_val = min_val
+        self.max_val = max_val
+
+    def fit(self, X: pd.DataFrame, y=None):
+        return self
+
+    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        X = X.copy()
+        for col in X.columns:
+            if not pd.api.types.is_numeric_dtype(X[col]):
+                continue
+            if self.min_val is not None:
+                X.loc[X[col] < self.min_val, col] = np.nan
+            if self.max_val is not None:
+                X.loc[X[col] > self.max_val, col] = np.nan
+        return X

xplainable_preprocessing-0.2.2/src/xplainable_preprocessing/transformers/groupby_agg.py

@@ -0,0 +1,143 @@
+"""GroupBy aggregation transformer for collapsing rows."""
+
+from __future__ import annotations
+
+import pandas as pd
+from sklearn.base import BaseEstimator, TransformerMixin
+
+
+class GroupByAggTransformer(BaseEstimator, TransformerMixin):
+    """Aggregate rows by grouping columns, collapsing many rows into one per group.
+
+    Supports standard pandas aggregation functions plus ``mode`` and ``nunique``.
+    Each aggregation entry maps a source column to one or more operations, with
+    optional output column renaming.
+
+    Parameters
+    ----------
+    group_by : list[str]
+        Columns to group by. These become the index of the result and are
+        always retained in the output.
+    aggregations : dict
+        Mapping of ``source_column`` to aggregation specification(s).
+
+        Each value can be:
+
+        - A string: a single function name (e.g. ``"sum"``, ``"mean"``).
+          The output column keeps the source name.
+        - A dict with ``func`` and optional ``output``:
+          ``{"func": "sum", "output": "total_revenue"}``.
+        - A list of the above, producing multiple output columns from one
+          source.
+
+        Supported functions: ``sum``, ``mean``, ``median``, ``min``, ``max``,
+        ``std``, ``count``, ``first``, ``last``, ``nunique``, ``mode``.
+
+    Examples
+    --------
+    >>> spec_params = {
+    ...     "group_by": ["customer_id"],
+    ...     "aggregations": {
+    ...         "country": "first",
+    ...         "order_id": {"func": "count", "output": "orders_count"},
+    ...         "revenue": [
+    ...             {"func": "sum", "output": "total_spent"},
+    ...             {"func": "mean", "output": "avg_order_value"},
+    ...         ],
+    ...         "product_id": {"func": "nunique", "output": "unique_products"},
+    ...         "category": {"func": "mode", "output": "primary_category"},
+    ...     },
+    ... }
+    """
+
+    FUNCTIONS = {
+        "sum", "mean", "median", "min", "max", "std",
+        "count", "first", "last", "nunique", "mode",
+    }
+
+    def __init__(
+        self,
+        group_by: list[str] | None = None,
+        aggregations: dict | None = None,
+    ):
+        self.group_by = group_by or []
+        self.aggregations = aggregations or {}
+
+    def fit(self, X: pd.DataFrame, y=None):
+        # Validate all requested functions
+        for col, specs in self._iter_specs():
+            for func, _ in specs:
+                if func not in self.FUNCTIONS:
+                    raise ValueError(
+                        f"Column '{col}': unknown function '{func}'. "
+                        f"Available: {sorted(self.FUNCTIONS)}"
+                    )
+        return self
+
+    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        if not self.group_by:
+            raise ValueError("group_by must be specified")
+        if not self.aggregations:
+            raise ValueError("aggregations must be specified")
+
+        grouped = X.groupby(self.group_by, sort=False)
+
+        result_parts: dict[str, pd.Series] = {}
+
+        for col, specs in self._iter_specs():
+            if col not in X.columns:
+                continue
+            for func, output_name in specs:
+                result_parts[output_name] = self._apply_func(grouped, col, func)
+
+        result = pd.DataFrame(result_parts)
+
+        # Restore group_by columns from the index
+        for i, col in enumerate(self.group_by):
+            if len(self.group_by) == 1:
+                result.insert(i, col, result.index)
+            else:
+                result.insert(i, col, result.index.get_level_values(i))
+
+        return result.reset_index(drop=True)
+
+    def _iter_specs(self):
+        """Yield (source_column, [(func, output_name), ...]) tuples."""
+        for col, spec in self.aggregations.items():
+            yield col, self._normalise(col, spec)
+
+    @staticmethod
+    def _normalise(col: str, spec) -> list[tuple[str, str]]:
+        """Normalise the various spec formats into [(func, output), ...]."""
+        if isinstance(spec, str):
+            return [(spec, col)]
+
+        if isinstance(spec, dict):
+            func = spec["func"]
+            output = spec.get("output", col)
+            return [(func, output)]
+
+        if isinstance(spec, list):
+            result = []
+            for entry in spec:
+                if isinstance(entry, str):
+                    result.append((entry, col))
+                elif isinstance(entry, dict):
+                    func = entry["func"]
+                    output = entry.get("output", col)
+                    result.append((func, output))
+            return result
+
+        raise ValueError(
+            f"Column '{col}': spec must be a string, dict, or list, "
+            f"got {type(spec).__name__}"
+        )
+
+    @staticmethod
+    def _apply_func(grouped, col: str, func: str) -> pd.Series:
+        """Apply a single aggregation function to a grouped column."""
+        if func == "mode":
+            return grouped[col].agg(lambda x: x.mode().iloc[0] if len(x.mode()) > 0 else None)
+        if func == "nunique":
+            return grouped[col].nunique()
+        return grouped[col].agg(func)

xplainable_preprocessing-0.2.2/src/xplainable_preprocessing/transformers/missing_flag.py

@@ -0,0 +1,48 @@
+"""Missing flag transformer -- creates binary indicators for null values."""
+
+from __future__ import annotations
+
+import pandas as pd
+from sklearn.base import BaseEstimator, TransformerMixin
+
+
+class MissingFlagTransformer(BaseEstimator, TransformerMixin):
+    """Create binary 0/1 indicator columns for null values.
+
+    For each specified column, adds a new column ``{col}_missing``
+    that is 1 where the original value is null and 0 otherwise.
+    Useful when missingness itself is informative (e.g. "physical
+    testing not completed" predicts injury risk).
+
+    Parameters
+    ----------
+    suffix : str
+        Suffix appended to column names for the flag columns.
+        Default ``"_missing"``.
+    drop_original : bool
+        If True, drop the original columns after creating flags.
+        Default False.
+    """
+
+    def __init__(
+        self,
+        suffix: str = "_missing",
+        drop_original: bool = False,
+    ):
+        self.suffix = suffix
+        self.drop_original = drop_original
+
+    def fit(self, X: pd.DataFrame, y=None):
+        return self
+
+    def transform(self, X: pd.DataFrame) -> pd.DataFrame:
+        X = X.copy()
+        flag_cols = {}
+        for col in X.columns:
+            flag_cols[f"{col}{self.suffix}"] = X[col].isna().astype(int)
+        flags = pd.DataFrame(flag_cols, index=X.index)
+        if self.drop_original:
+            X = pd.concat([flags], axis=1)
+        else:
+            X = pd.concat([X, flags], axis=1)
+        return X

{xplainable_preprocessing-0.2.0 → xplainable_preprocessing-0.2.2}/tests/test_transformers/test_all_transformers.py

@@ -9,6 +9,7 @@ from xplainable_preprocessing.transformers.datetime_extract import DateTimeExtra
 from xplainable_preprocessing.transformers.drop_columns import DropColumnsTransformer
 from xplainable_preprocessing.transformers.fill_missing import FillMissingTransformer
 from xplainable_preprocessing.transformers.grouped_lag import GroupedLagTransformer
+from xplainable_preprocessing.transformers.groupby_agg import GroupByAggTransformer
 from xplainable_preprocessing.transformers.rename_columns import RenameColumnsTransformer
 from xplainable_preprocessing.transformers.rolling_agg import RollingAggTransformer
 from xplainable_preprocessing.transformers.text_clean import TextCleanTransformer
@@ -226,3 +227,128 @@ class TestRollingAggTransformer:
         t = RollingAggTransformer(columns=["v"], operation="invalid")
         with pytest.raises(ValueError, match="Unknown operation"):
             t.fit(pd.DataFrame({"v": [1]}))
+
+
+class TestGroupByAggTransformer:
+    @pytest.fixture
+    def orders_df(self):
+        return pd.DataFrame({
+            "customer_id": [1, 1, 1, 2, 2, 3],
+            "country": ["US", "US", "US", "UK", "UK", "CA"],
+            "revenue": [100.0, 200.0, 150.0, 300.0, 250.0, 50.0],
+            "quantity": [2, 3, 1, 4, 2, 1],
+            "product_id": [10, 20, 10, 30, 30, 40],
+            "category": ["A", "B", "A", "C", "C", "A"],
+            "returned": [0, 1, 0, 0, 0, 1],
+        })
+
+    def test_basic_string_agg(self, orders_df):
+        t = GroupByAggTransformer(
+            group_by=["customer_id"],
+            aggregations={"country": "first"},
+        )
+        result = t.fit_transform(orders_df)
+        assert len(result) == 3
+        assert "customer_id" in result.columns
+        assert "country" in result.columns
+        assert result.loc[result["customer_id"] == 1, "country"].iloc[0] == "US"
+
+    def test_dict_with_rename(self, orders_df):
+        t = GroupByAggTransformer(
+            group_by=["customer_id"],
+            aggregations={
+                "revenue": {"func": "sum", "output": "total_spent"},
+            },
+        )
+        result = t.fit_transform(orders_df)
+        assert "total_spent" in result.columns
+        assert "revenue" not in result.columns
+        assert result.loc[result["customer_id"] == 1, "total_spent"].iloc[0] == 450.0
+
+    def test_list_multiple_aggs(self, orders_df):
+        t = GroupByAggTransformer(
+            group_by=["customer_id"],
+            aggregations={
+                "revenue": [
+                    {"func": "sum", "output": "total_revenue"},
+                    {"func": "mean", "output": "avg_revenue"},
+                ],
+            },
+        )
+        result = t.fit_transform(orders_df)
+        assert "total_revenue" in result.columns
+        assert "avg_revenue" in result.columns
+        assert result.loc[result["customer_id"] == 1, "total_revenue"].iloc[0] == 450.0
+        assert result.loc[result["customer_id"] == 1, "avg_revenue"].iloc[0] == 150.0
+
+    def test_nunique(self, orders_df):
+        t = GroupByAggTransformer(
+            group_by=["customer_id"],
+            aggregations={
+                "product_id": {"func": "nunique", "output": "unique_products"},
+            },
+        )
+        result = t.fit_transform(orders_df)
+        assert result.loc[result["customer_id"] == 1, "unique_products"].iloc[0] == 2
+        assert result.loc[result["customer_id"] == 2, "unique_products"].iloc[0] == 1
+
+    def test_mode(self, orders_df):
+        t = GroupByAggTransformer(
+            group_by=["customer_id"],
+            aggregations={
+                "category": {"func": "mode", "output": "primary_category"},
+            },
+        )
+        result = t.fit_transform(orders_df)
+        assert result.loc[result["customer_id"] == 1, "primary_category"].iloc[0] == "A"
+        assert result.loc[result["customer_id"] == 2, "primary_category"].iloc[0] == "C"
+
+    def test_count(self, orders_df):
+        t = GroupByAggTransformer(
+            group_by=["customer_id"],
+            aggregations={
+                "revenue": {"func": "count", "output": "orders_count"},
+            },
+        )
+        result = t.fit_transform(orders_df)
+        assert result.loc[result["customer_id"] == 1, "orders_count"].iloc[0] == 3
+        assert result.loc[result["customer_id"] == 3, "orders_count"].iloc[0] == 1
+
+    def test_invalid_function(self, orders_df):
+        t = GroupByAggTransformer(
+            group_by=["customer_id"],
+            aggregations={"revenue": "bogus"},
+        )
+        with pytest.raises(ValueError, match="unknown function"):
+            t.fit(orders_df)
+
+    def test_empty_group_by_raises(self, orders_df):
+        t = GroupByAggTransformer(
+            group_by=[],
+            aggregations={"revenue": "sum"},
+        )
+        t.fit(orders_df)
+        with pytest.raises(ValueError, match="group_by must be specified"):
+            t.transform(orders_df)
+
+    def test_combined_spec(self, orders_df):
+        """Full integration: multiple agg types in one spec."""
+        t = GroupByAggTransformer(
+            group_by=["customer_id"],
+            aggregations={
+                "country": "first",
+                "revenue": [
+                    {"func": "sum", "output": "total_spent"},
+                    {"func": "mean", "output": "avg_order_value"},
+                ],
+                "product_id": {"func": "nunique", "output": "unique_products"},
+                "category": {"func": "mode", "output": "top_category"},
+                "returned": {"func": "sum", "output": "return_count"},
+            },
+        )
+        result = t.fit_transform(orders_df)
+        assert len(result) == 3
+        assert set(result.columns) == {
+            "customer_id", "country", "total_spent", "avg_order_value",
+            "unique_products", "top_category", "return_count",
+        }

xplainable_preprocessing-0.2.0/scripts/release.sh

@@ -1,292 +0,0 @@
-#!/bin/bash
-# Simple release script for xplainable-preprocessing
-
-set -e
-
-# Colors for output
-RED='\033[0;31m'
-GREEN='\033[0;32m'
-YELLOW='\033[1;33m'
-BLUE='\033[0;34m'
-NC='\033[0m' # No Color
-
-# Functions
-print_header() {
-    echo -e "${BLUE}$1${NC}"
-    echo "=================================="
-}
-
-print_success() {
-    echo -e "${GREEN}✅ $1${NC}"
-}
-
-print_warning() {
-    echo -e "${YELLOW}⚠️  $1${NC}"
-}
-
-print_error() {
-    echo -e "${RED}❌ $1${NC}"
-}
-
-# Parse arguments
-VERSION=""
-INCREMENT=""
-DRY_RUN=false
-PUBLISH_PYPI=false
-
-while [[ $# -gt 0 ]]; do
-    case $1 in
-        -v|--version)
-            VERSION="$2"
-            shift 2
-            ;;
-        -i|--increment)
-            INCREMENT="$2"
-            shift 2
-            ;;
-        --dry-run)
-            DRY_RUN=true
-            shift
-            ;;
-        --publish)
-            PUBLISH_PYPI=true
-            shift
-            ;;
-        -h|--help)
-            echo "Usage: $0 [OPTIONS]"
-            echo ""
-            echo "Options:"
-            echo "  -v, --version VERSION    Specific version (e.g., 1.2.3)"
-            echo "  -i, --increment TYPE     Auto-increment: major, minor, or patch"
-            echo "      --dry-run           Show what would be done"
-            echo "      --publish           Publish to PyPI after building"
-            echo "  -h, --help              Show this help"
-            echo ""
-            echo "Examples:"
-            echo "  $0 --version 0.2.0"
-            echo "  $0 --increment patch"
-            echo "  $0 --increment minor --publish"
-            echo "  $0 --increment minor --dry-run"
-            exit 0
-            ;;
-        *)
-            print_error "Unknown option: $1"
-            exit 1
-            ;;
-    esac
-done
-
-# Validate arguments
-if [[ -z "$VERSION" && -z "$INCREMENT" ]]; then
-    print_error "Must specify either --version or --increment"
-    echo "Run $0 --help for usage"
-    exit 1
-fi
-
-if [[ -n "$VERSION" && -n "$INCREMENT" ]]; then
-    print_error "Cannot specify both --version and --increment"
-    exit 1
-fi
-
-print_header "🚀 xplainable-preprocessing Release"
-
-# Check if we're in the right directory
-if [[ ! -f "pyproject.toml" ]]; then
-    print_error "Not in project root (no pyproject.toml found)"
-    exit 1
-fi
-
-# Check git status
-print_header "📋 Pre-release Checks"
-
-if ! git rev-parse --git-dir > /dev/null 2>&1; then
-    print_error "Not in a git repository"
-    exit 1
-fi
-
-if [[ -n $(git status --porcelain) ]]; then
-    print_error "Uncommitted changes detected"
-    git status --short
-    exit 1
-fi
-
-CURRENT_BRANCH=$(git branch --show-current)
-if [[ "$CURRENT_BRANCH" != "main" && "$CURRENT_BRANCH" != "master" ]]; then
-    print_warning "Currently on branch '$CURRENT_BRANCH'"
-    read -p "Continue anyway? (y/N): " -n 1 -r
-    echo
-    if [[ ! $REPLY =~ ^[Yy]$ ]]; then
-        exit 1
-    fi
-fi
-
-print_success "Git repository is clean"
-
-# Run tests before release
-print_header "🧪 Running Tests"
-if python -m pytest tests/ -q; then
-    print_success "All tests passed"
-else
-    print_error "Tests failed — aborting release"
-    exit 1
-fi
-
-# Get current version from pyproject.toml
-CURRENT_VERSION=$(grep '^version =' pyproject.toml | sed 's/version = "\(.*\)"/\1/')
-
-if [[ -z "$CURRENT_VERSION" ]]; then
-    print_error "Could not determine current version"
-    exit 1
-fi
-
-print_success "Current version: $CURRENT_VERSION"
-
-# Determine new version
-if [[ -n "$VERSION" ]]; then
-    NEW_VERSION="${VERSION#v}"  # Remove 'v' prefix if present
-else
-    # Auto-increment
-    IFS='.' read -ra VERSION_PARTS <<< "$CURRENT_VERSION"
-    MAJOR=${VERSION_PARTS[0]}
-    MINOR=${VERSION_PARTS[1]}
-    PATCH=${VERSION_PARTS[2]}
-
-    case $INCREMENT in
-        major)
-            MAJOR=$((MAJOR + 1))
-            MINOR=0
-            PATCH=0
-            ;;
-        minor)
-            MINOR=$((MINOR + 1))
-            PATCH=0
-            ;;
-        patch)
-            PATCH=$((PATCH + 1))
-            ;;
-        *)
-            print_error "Invalid increment type: $INCREMENT"
-            exit 1
-            ;;
-    esac
-
-    NEW_VERSION="$MAJOR.$MINOR.$PATCH"
-fi
-
-TAG="v$NEW_VERSION"
-
-print_header "📦 Release Plan"
-echo "Current:  $CURRENT_VERSION"
-echo "New:      $NEW_VERSION"
-echo "Tag:      $TAG"
-
-if [[ "$DRY_RUN" == true ]]; then
-    print_header "🔍 DRY RUN - Would perform:"
-    echo "1. Clean build artifacts"
-    echo "2. Update version in pyproject.toml"
-    echo "3. Commit version changes"
-    echo "4. Create git tag $TAG"
-    echo "5. Build package (wheel and sdist)"
-    echo "6. Push changes and tag"
-    if [[ "$PUBLISH_PYPI" == true ]]; then
-        echo "7. Publish package to PyPI"
-        echo "8. Create GitHub release (if gh CLI available)"
-    else
-        echo "7. Create GitHub release (if gh CLI available)"
-    fi
-    exit 0
-fi
-
-# Confirm
-read -p "Create release v$NEW_VERSION? (y/N): " -n 1 -r
-echo
-if [[ ! $REPLY =~ ^[Yy]$ ]]; then
-    print_error "Release cancelled"
-    exit 1
-fi
-
-print_header "🔨 Creating Release"
-
-# Clean up build artifacts
-print_success "Cleaning up build artifacts..."
-rm -rf build/ dist/ *.egg-info/ src/*.egg-info/ || true
-
-# Update version in pyproject.toml
-print_success "Updating version..."
-sed -i.bak "s/^version = .*/version = \"$NEW_VERSION\"/" pyproject.toml && rm pyproject.toml.bak
-print_success "Updated pyproject.toml"
-
-# Commit changes
-print_success "Committing version changes..."
-git add .
-git commit -m "chore: bump version to $NEW_VERSION"
-
-# Create tag
-print_success "Creating tag $TAG..."
-RELEASE_DATE=$(date +%Y-%m-%d)
-git tag -a "$TAG" -m "Release $TAG — $RELEASE_DATE"
-
-# Build package
-print_success "Building package..."
-python -m build
-
-# Push changes
-print_success "Pushing changes..."
-git push
-git push --tags
-
-# Publish to PyPI if requested
-if [[ "$PUBLISH_PYPI" == true ]]; then
-    print_success "Publishing to PyPI..."
-
-    if ! command -v twine &> /dev/null; then
-        print_error "twine not found"
-        echo "Install with: pip install twine"
-        exit 1
-    fi
-
-    if [[ -z "$TWINE_PASSWORD" && ! -f ~/.pypirc ]]; then
-        print_error "PyPI credentials not configured"
-        echo "Set up credentials with one of:"
-        echo "  1. Environment: export TWINE_USERNAME=__token__ TWINE_PASSWORD=pypi-..."
-        echo "  2. Config file: ~/.pypirc"
-        exit 1
-    fi
-
-    if twine upload dist/*; then
-        print_success "Package published to PyPI!"
-        echo "🔗 View at: https://pypi.org/project/xplainable-preprocessing/$NEW_VERSION/"
-    else
-        print_error "PyPI upload failed"
-        exit 1
-    fi
-fi
-
-# Create GitHub release if gh CLI is available
-if command -v gh &> /dev/null; then
-    if gh auth status &> /dev/null; then
-        print_success "Creating GitHub release..."
-
-        gh release create "$TAG" \
-            --title "v$NEW_VERSION" \
-            --notes "## xplainable-preprocessing v$NEW_VERSION — $RELEASE_DATE
-
-### Installation
-
-\`\`\`bash
-pip install xplainable-preprocessing==$NEW_VERSION
-\`\`\`" \
-            --latest
-
-        print_success "GitHub release created!"
-    else
-        print_warning "GitHub CLI not authenticated, skipping release creation"
-    fi
-else
-    print_warning "GitHub CLI not found, skipping release creation"
-fi
-
-print_header "🎉 RELEASE COMPLETE!"
-echo "Version:     $NEW_VERSION"
-echo "Tag:         $TAG"
-echo "PyPI:        https://pypi.org/project/xplainable-preprocessing/$NEW_VERSION/"