churnkit 0.75.0a1__py3-none-any.whl

customer_retention/analysis/recommendations/cleaning/__init__.py

@@ -0,0 +1,11 @@
+from .consistency import ConsistencyNormalizeRecommendation
+from .deduplicate import DeduplicateRecommendation
+from .impute import ImputeRecommendation
+from .outlier import OutlierCapRecommendation
+
+__all__ = [
+    "ImputeRecommendation",
+    "OutlierCapRecommendation",
+    "DeduplicateRecommendation",
+    "ConsistencyNormalizeRecommendation",
+]

customer_retention/analysis/recommendations/cleaning/consistency.py

@@ -0,0 +1,107 @@
+import re
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+from ..base import CleaningRecommendation, RecommendationResult
+
+
+class ConsistencyNormalizeRecommendation(CleaningRecommendation):
+    def __init__(
+        self, columns: List[str], rationale: str = None, normalization: str = "lowercase",
+        evidence: List[str] = None, priority: str = "medium", source_finding: Optional[Any] = None
+    ):
+        rationale = rationale or f"Normalize values using {normalization}"
+        super().__init__(columns, rationale, evidence, priority, source_finding)
+        self.normalization = normalization
+        self._unique_before: Dict[str, int] = {}
+
+    @property
+    def recommendation_type(self) -> str:
+        return f"normalize_{self.normalization}"
+
+    def _fit_impl(self, df: pd.DataFrame) -> None:
+        variants = {}
+        unique_before = {}
+        for col in self.columns:
+            if col not in df.columns:
+                continue
+            unique_before[col] = df[col].nunique()
+            if df[col].dtype == object:
+                variants[col] = df[col].dropna().unique().tolist()[:20]
+        self._fit_params["variants"] = variants
+        self._fit_params["unique_before"] = unique_before
+        self._unique_before = unique_before
+
+    def _normalize_series(self, series: pd.Series) -> pd.Series:
+        if series.dtype != object:
+            return series
+        if self.normalization == "lowercase":
+            return series.str.lower()
+        if self.normalization == "uppercase":
+            return series.str.upper()
+        if self.normalization == "titlecase":
+            return series.str.title()
+        if self.normalization == "strip_whitespace":
+            return series.str.strip()
+        if self.normalization == "collapse_whitespace":
+            return series.apply(lambda x: re.sub(r'\s+', ' ', x) if isinstance(x, str) else x)
+        return series
+
+    def _transform_local(self, df: pd.DataFrame) -> RecommendationResult:
+        df = df.copy()
+        rows_before = len(df)
+        values_changed = {}
+        unique_after = {}
+        for col in self.columns:
+            if col not in df.columns:
+                continue
+            original = df[col].copy()
+            df[col] = self._normalize_series(df[col])
+            changed = (original != df[col]) & original.notna()
+            values_changed[col] = int(changed.sum())
+            unique_after[col] = df[col].nunique()
+        return RecommendationResult(
+            data=df, columns_affected=self.columns, rows_before=rows_before,
+            rows_after=len(df), metadata={
+                "values_changed": values_changed, "unique_after": unique_after,
+                "unique_before": self._unique_before
+            }
+        )
+
+    def _transform_databricks(self, df: pd.DataFrame) -> RecommendationResult:
+        from customer_retention.core.compat import is_spark_available
+        if not is_spark_available():
+            return self._transform_local(df)
+        return self._transform_local(df)
+
+    def _generate_local_code(self) -> str:
+        lines = [f"# Normalize: {self.rationale}"]
+        method_map = {
+            "lowercase": "str.lower()",
+            "uppercase": "str.upper()",
+            "titlecase": "str.title()",
+            "strip_whitespace": "str.strip()",
+            "collapse_whitespace": "apply(lambda x: re.sub(r'\\s+', ' ', x) if isinstance(x, str) else x)",
+        }
+        method = method_map.get(self.normalization, "str.lower()")
+        for col in self.columns:
+            lines.append(f"df['{col}'] = df['{col}'].{method}")
+        return "\n".join(lines)
+
+    def _generate_databricks_code(self) -> str:
+        func_map = {
+            "lowercase": "lower",
+            "uppercase": "upper",
+            "strip_whitespace": "trim",
+            "titlecase": "initcap",
+            "collapse_whitespace": "regexp_replace",
+        }
+        func = func_map.get(self.normalization, "lower")
+        lines = [f"# Normalize: {self.rationale}", f"from pyspark.sql.functions import {func}, col"]
+        for col in self.columns:
+            if self.normalization == "collapse_whitespace":
+                lines.append(f"df = df.withColumn('{col}', regexp_replace(col('{col}'), r'\\s+', ' '))")
+            else:
+                lines.append(f"df = df.withColumn('{col}', {func}(col('{col}')))")
+        return "\n".join(lines)

customer_retention/analysis/recommendations/cleaning/deduplicate.py

@@ -0,0 +1,94 @@
+from typing import Any, List, Optional
+
+import pandas as pd
+
+from ..base import CleaningRecommendation, RecommendationResult
+
+
+class DeduplicateRecommendation(CleaningRecommendation):
+    def __init__(
+        self, key_columns: List[str], rationale: str = None, strategy: str = "keep_first",
+        timestamp_column: Optional[str] = None, evidence: List[str] = None,
+        priority: str = "medium", source_finding: Optional[Any] = None
+    ):
+        rationale = rationale or f"Remove duplicate rows using {strategy}"
+        super().__init__(key_columns, rationale, evidence, priority, source_finding)
+        self.key_columns = key_columns
+        self.strategy = strategy
+        self.timestamp_column = timestamp_column
+
+    @property
+    def recommendation_type(self) -> str:
+        return f"deduplicate_{self.strategy}"
+
+    def _fit_impl(self, df: pd.DataFrame) -> None:
+        existing_keys = [k for k in self.key_columns if k in df.columns]
+        if not existing_keys:
+            self._fit_params["duplicate_count"] = 0
+            self._fit_params["duplicate_keys"] = []
+            return
+        duplicated_mask = df.duplicated(subset=existing_keys, keep=False)
+        duplicated_df = df[duplicated_mask]
+        dup_count = len(duplicated_df) - duplicated_df.drop_duplicates(subset=existing_keys).shape[0]
+        self._fit_params["duplicate_count"] = dup_count
+        first_key = existing_keys[0]
+        self._fit_params["duplicate_keys"] = duplicated_df[first_key].unique().tolist()
+
+    def _transform_local(self, df: pd.DataFrame) -> RecommendationResult:
+        df = df.copy()
+        rows_before = len(df)
+        existing_keys = [k for k in self.key_columns if k in df.columns]
+        if not existing_keys:
+            return RecommendationResult(
+                data=df, columns_affected=self.key_columns, rows_before=rows_before,
+                rows_after=rows_before, metadata={"duplicates_removed": 0}
+            )
+        if self.strategy == "keep_first":
+            df = df.drop_duplicates(subset=existing_keys, keep="first")
+        elif self.strategy == "keep_last":
+            df = df.drop_duplicates(subset=existing_keys, keep="last")
+        elif self.strategy == "keep_most_recent" and self.timestamp_column:
+            df = df.sort_values(self.timestamp_column, ascending=False)
+            df = df.drop_duplicates(subset=existing_keys, keep="first")
+            df = df.sort_index()
+        elif self.strategy == "drop_exact":
+            df = df.drop_duplicates(subset=existing_keys, keep="first")
+        rows_after = len(df)
+        return RecommendationResult(
+            data=df, columns_affected=self.key_columns, rows_before=rows_before,
+            rows_after=rows_after, metadata={"duplicates_removed": rows_before - rows_after}
+        )
+
+    def _transform_databricks(self, df: pd.DataFrame) -> RecommendationResult:
+        from customer_retention.core.compat import is_spark_available
+        if not is_spark_available():
+            return self._transform_local(df)
+        return self._transform_local(df)
+
+    def _generate_local_code(self) -> str:
+        key_str = ", ".join(f"'{k}'" for k in self.key_columns)
+        lines = [f"# Deduplicate: {self.rationale}"]
+        if self.strategy == "keep_first":
+            lines.append(f"df = df.drop_duplicates(subset=[{key_str}], keep='first')")
+        elif self.strategy == "keep_last":
+            lines.append(f"df = df.drop_duplicates(subset=[{key_str}], keep='last')")
+        elif self.strategy == "keep_most_recent" and self.timestamp_column:
+            lines.append(f"df = df.sort_values('{self.timestamp_column}', ascending=False)")
+            lines.append(f"df = df.drop_duplicates(subset=[{key_str}], keep='first')")
+            lines.append("df = df.sort_index()")
+        elif self.strategy == "drop_exact":
+            lines.append(f"df = df.drop_duplicates(subset=[{key_str}], keep='first')")
+        return "\n".join(lines)
+
+    def _generate_databricks_code(self) -> str:
+        key_str = ", ".join(f"'{k}'" for k in self.key_columns)
+        lines = [f"# Deduplicate: {self.rationale}"]
+        if self.strategy == "keep_most_recent" and self.timestamp_column:
+            lines.append("from pyspark.sql.window import Window")
+            lines.append("from pyspark.sql.functions import row_number, desc")
+            lines.append(f"window = Window.partitionBy([{key_str}]).orderBy(desc('{self.timestamp_column}'))")
+            lines.append("df = df.withColumn('_row_num', row_number().over(window))")
+            lines.append("df = df.filter(df._row_num == 1).drop('_row_num')")
+        else:
+            lines.append(f"df = df.dropDuplicates([{key_str}])")
+        return "\n".join(lines)

customer_retention/analysis/recommendations/cleaning/impute.py

@@ -0,0 +1,67 @@
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+from ..base import CleaningRecommendation, RecommendationResult
+
+
+class ImputeRecommendation(CleaningRecommendation):
+    def __init__(
+        self, columns: List[str], rationale: str = None, strategy: str = "median",
+        fill_value: Any = None, evidence: List[str] = None,
+        priority: str = "medium", source_finding: Optional[Any] = None
+    ):
+        rationale = rationale or f"Impute missing values using {strategy}"
+        super().__init__(columns, rationale, evidence, priority, source_finding)
+        self.strategy = strategy
+        self.fill_value = fill_value
+        self._impute_values: Dict[str, Any] = {}
+
+    @property
+    def recommendation_type(self) -> str:
+        return f"impute_{self.strategy}"
+
+    def _fit_impl(self, df: pd.DataFrame) -> None:
+        for col in self.columns:
+            if col not in df.columns:
+                continue
+            series = df[col]
+            if self.strategy == "median":
+                self._impute_values[col] = series.median()
+            elif self.strategy == "mean":
+                self._impute_values[col] = series.mean()
+            elif self.strategy == "mode":
+                modes = series.mode()
+                self._impute_values[col] = modes.iloc[0] if len(modes) > 0 else None
+            elif self.strategy == "constant":
+                self._impute_values[col] = self.fill_value
+        self._fit_params["impute_values"] = self._impute_values
+
+    def _transform_local(self, df: pd.DataFrame) -> RecommendationResult:
+        df = df.copy()
+        rows_before = len(df)
+        nulls_imputed = {}
+        for col in self.columns:
+            if col in df.columns and col in self._impute_values:
+                nulls = int(df[col].isna().sum())
+                df[col] = df[col].fillna(self._impute_values[col])
+                nulls_imputed[col] = nulls
+        return RecommendationResult(
+            data=df, columns_affected=self.columns, rows_before=rows_before,
+            rows_after=len(df), metadata={"nulls_imputed": nulls_imputed}
+        )
+
+    def _transform_databricks(self, df: pd.DataFrame) -> RecommendationResult:
+        from customer_retention.core.compat import is_spark_available
+        if not is_spark_available():
+            return self._transform_local(df)
+        return self._transform_local(df)
+
+    def _generate_local_code(self) -> str:
+        lines = [f"# Impute: {self.rationale}"]
+        for col, val in self._impute_values.items():
+            lines.append(f"df['{col}'] = df['{col}'].fillna({repr(val)})")
+        return "\n".join(lines)
+
+    def _generate_databricks_code(self) -> str:
+        return f"# Impute: {self.rationale}\ndf = df.fillna({self._impute_values})"

customer_retention/analysis/recommendations/cleaning/outlier.py

@@ -0,0 +1,71 @@
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+from ..base import CleaningRecommendation, RecommendationResult
+
+
+class OutlierCapRecommendation(CleaningRecommendation):
+    def __init__(
+        self, columns: List[str], rationale: str = None, percentile: int = 99,
+        evidence: List[str] = None, priority: str = "medium", source_finding: Optional[Any] = None
+    ):
+        rationale = rationale or f"Cap outliers at {percentile}th percentile"
+        super().__init__(columns, rationale, evidence, priority, source_finding)
+        self.percentile = percentile
+        self._bounds: Dict[str, Dict[str, float]] = {}
+
+    @property
+    def recommendation_type(self) -> str:
+        return f"cap_outliers_{self.percentile}"
+
+    def _fit_impl(self, df: pd.DataFrame) -> None:
+        lower_pct = (100 - self.percentile) / 100
+        upper_pct = self.percentile / 100
+        for col in self.columns:
+            if col not in df.columns:
+                continue
+            series = df[col].dropna()
+            self._bounds[col] = {
+                "lower": float(series.quantile(lower_pct)),
+                "upper": float(series.quantile(upper_pct)),
+            }
+        self._fit_params["bounds"] = self._bounds
+
+    def _transform_local(self, df: pd.DataFrame) -> RecommendationResult:
+        df = df.copy()
+        rows_before = len(df)
+        outliers_capped = {}
+        for col in self.columns:
+            if col in df.columns and col in self._bounds:
+                bounds = self._bounds[col]
+                outlier_mask = (df[col] < bounds["lower"]) | (df[col] > bounds["upper"])
+                outliers_capped[col] = int(outlier_mask.sum())
+                df[col] = df[col].clip(lower=bounds["lower"], upper=bounds["upper"])
+        return RecommendationResult(
+            data=df, columns_affected=self.columns, rows_before=rows_before,
+            rows_after=len(df), metadata={"outliers_capped": outliers_capped, "bounds": self._bounds}
+        )
+
+    def _transform_databricks(self, df: pd.DataFrame) -> RecommendationResult:
+        from customer_retention.core.compat import is_spark_available
+        if not is_spark_available():
+            return self._transform_local(df)
+        return self._transform_local(df)
+
+    def _generate_local_code(self) -> str:
+        lines = [f"# Cap outliers: {self.rationale}"]
+        for col, bounds in self._bounds.items():
+            lines.append(f"df['{col}'] = df['{col}'].clip(lower={bounds['lower']}, upper={bounds['upper']})")
+        return "\n".join(lines)
+
+    def _generate_databricks_code(self) -> str:
+        lines = [f"# Cap outliers: {self.rationale}", "from pyspark.sql.functions import when, col"]
+        for col, bounds in self._bounds.items():
+            lines.append(
+                f"df = df.withColumn('{col}', "
+                f"when(col('{col}') < {bounds['lower']}, {bounds['lower']})"
+                f".when(col('{col}') > {bounds['upper']}, {bounds['upper']})"
+                f".otherwise(col('{col}')))"
+            )
+        return "\n".join(lines)

customer_retention/analysis/recommendations/datetime/__init__.py

@@ -0,0 +1,3 @@
+from .extract import DaysSinceRecommendation, ExtractDayOfWeekRecommendation, ExtractMonthRecommendation
+
+__all__ = ["ExtractMonthRecommendation", "ExtractDayOfWeekRecommendation", "DaysSinceRecommendation"]

customer_retention/analysis/recommendations/datetime/extract.py

@@ -0,0 +1,149 @@
+from datetime import datetime
+from typing import Any, List, Optional
+
+import pandas as pd
+
+from ..base import DatetimeRecommendation, RecommendationResult
+
+
+class ExtractMonthRecommendation(DatetimeRecommendation):
+    def __init__(
+        self, columns: List[str], rationale: str = None, evidence: List[str] = None,
+        priority: str = "medium", source_finding: Optional[Any] = None
+    ):
+        rationale = rationale or "Extract month from datetime for seasonality analysis"
+        super().__init__(columns, rationale, evidence, priority, source_finding)
+
+    @property
+    def recommendation_type(self) -> str:
+        return "extract_month"
+
+    def _fit_impl(self, df: pd.DataFrame) -> None:
+        self._fit_params["columns"] = self.columns
+
+    def _transform_local(self, df: pd.DataFrame) -> RecommendationResult:
+        df = df.copy()
+        new_cols = []
+        for col in self.columns:
+            if col in df.columns:
+                new_col = f"{col}_month"
+                df[new_col] = pd.to_datetime(df[col]).dt.month
+                new_cols.append(new_col)
+        return RecommendationResult(
+            data=df, columns_affected=self.columns + new_cols,
+            rows_before=len(df), rows_after=len(df), metadata={"new_columns": new_cols}
+        )
+
+    def _transform_databricks(self, df: pd.DataFrame) -> RecommendationResult:
+        from customer_retention.core.compat import is_spark_available
+        if not is_spark_available():
+            return self._transform_local(df)
+        return self._transform_local(df)
+
+    def _generate_local_code(self) -> str:
+        lines = [f"# Extract: {self.rationale}"]
+        for col in self.columns:
+            lines.append(f"df['{col}_month'] = pd.to_datetime(df['{col}']).dt.month")
+        return "\n".join(lines)
+
+    def _generate_databricks_code(self) -> str:
+        lines = [f"# Extract: {self.rationale}", "from pyspark.sql.functions import month, col"]
+        for col in self.columns:
+            lines.append(f"df = df.withColumn('{col}_month', month(col('{col}')))")
+        return "\n".join(lines)
+
+
+class ExtractDayOfWeekRecommendation(DatetimeRecommendation):
+    def __init__(
+        self, columns: List[str], rationale: str = None, evidence: List[str] = None,
+        priority: str = "medium", source_finding: Optional[Any] = None
+    ):
+        rationale = rationale or "Extract day of week from datetime for weekly patterns"
+        super().__init__(columns, rationale, evidence, priority, source_finding)
+
+    @property
+    def recommendation_type(self) -> str:
+        return "extract_dayofweek"
+
+    def _fit_impl(self, df: pd.DataFrame) -> None:
+        self._fit_params["columns"] = self.columns
+
+    def _transform_local(self, df: pd.DataFrame) -> RecommendationResult:
+        df = df.copy()
+        new_cols = []
+        for col in self.columns:
+            if col in df.columns:
+                new_col = f"{col}_dayofweek"
+                df[new_col] = pd.to_datetime(df[col]).dt.dayofweek
+                new_cols.append(new_col)
+        return RecommendationResult(
+            data=df, columns_affected=self.columns + new_cols,
+            rows_before=len(df), rows_after=len(df), metadata={"new_columns": new_cols}
+        )
+
+    def _transform_databricks(self, df: pd.DataFrame) -> RecommendationResult:
+        from customer_retention.core.compat import is_spark_available
+        if not is_spark_available():
+            return self._transform_local(df)
+        return self._transform_local(df)
+
+    def _generate_local_code(self) -> str:
+        lines = [f"# Extract: {self.rationale}"]
+        for col in self.columns:
+            lines.append(f"df['{col}_dayofweek'] = pd.to_datetime(df['{col}']).dt.dayofweek")
+        return "\n".join(lines)
+
+    def _generate_databricks_code(self) -> str:
+        lines = [f"# Extract: {self.rationale}", "from pyspark.sql.functions import dayofweek, col"]
+        for col in self.columns:
+            lines.append(f"df = df.withColumn('{col}_dayofweek', dayofweek(col('{col}')) - 1)")
+        return "\n".join(lines)
+
+
+class DaysSinceRecommendation(DatetimeRecommendation):
+    def __init__(
+        self, columns: List[str], rationale: str = None, reference_date: datetime = None,
+        evidence: List[str] = None, priority: str = "medium", source_finding: Optional[Any] = None
+    ):
+        rationale = rationale or "Calculate days since datetime for recency features"
+        super().__init__(columns, rationale, evidence, priority, source_finding)
+        self.reference_date = reference_date or datetime.now()
+
+    @property
+    def recommendation_type(self) -> str:
+        return "days_since"
+
+    def _fit_impl(self, df: pd.DataFrame) -> None:
+        self._fit_params["reference_date"] = str(self.reference_date)
+
+    def _transform_local(self, df: pd.DataFrame) -> RecommendationResult:
+        df = df.copy()
+        new_cols = []
+        for col in self.columns:
+            if col in df.columns:
+                new_col = f"{col}_days_since"
+                df[new_col] = (pd.Timestamp(self.reference_date) - pd.to_datetime(df[col])).dt.days
+                new_cols.append(new_col)
+        return RecommendationResult(
+            data=df, columns_affected=self.columns + new_cols,
+            rows_before=len(df), rows_after=len(df), metadata={"reference_date": str(self.reference_date), "new_columns": new_cols}
+        )
+
+    def _transform_databricks(self, df: pd.DataFrame) -> RecommendationResult:
+        from customer_retention.core.compat import is_spark_available
+        if not is_spark_available():
+            return self._transform_local(df)
+        return self._transform_local(df)
+
+    def _generate_local_code(self) -> str:
+        lines = [f"# Extract: {self.rationale}", f"reference_date = pd.Timestamp('{self.reference_date}')"]
+        for col in self.columns:
+            lines.append(f"df['{col}_days_since'] = (reference_date - pd.to_datetime(df['{col}'])).dt.days")
+        return "\n".join(lines)
+
+    def _generate_databricks_code(self) -> str:
+        lines = [f"# Extract: {self.rationale}", "from pyspark.sql.functions import datediff, lit, col, to_date"]
+        lines.append(f"reference_date = '{self.reference_date.strftime('%Y-%m-%d')}'")
+        for col in self.columns:
+            lines.append(f"df = df.withColumn('{col}_days_since', datediff(lit(reference_date), to_date(col('{col}'))))")
+        return "\n".join(lines)

customer_retention/analysis/recommendations/encoding/__init__.py

@@ -0,0 +1,3 @@
+from .categorical import LabelEncodeRecommendation, OneHotEncodeRecommendation
+
+__all__ = ["OneHotEncodeRecommendation", "LabelEncodeRecommendation"]

customer_retention/analysis/recommendations/encoding/categorical.py

@@ -0,0 +1,114 @@
+from typing import Any, Dict, List, Optional
+
+import pandas as pd
+
+from ..base import EncodingRecommendation, RecommendationResult
+
+
+class OneHotEncodeRecommendation(EncodingRecommendation):
+    def __init__(
+        self, columns: List[str], rationale: str = None, drop_first: bool = False,
+        evidence: List[str] = None, priority: str = "medium", source_finding: Optional[Any] = None
+    ):
+        rationale = rationale or "One-hot encode categorical features"
+        super().__init__(columns, rationale, evidence, priority, source_finding)
+        self.drop_first = drop_first
+        self._categories: Dict[str, List[str]] = {}
+
+    @property
+    def recommendation_type(self) -> str:
+        return "onehot_encode"
+
+    def _fit_impl(self, df: pd.DataFrame) -> None:
+        for col in self.columns:
+            if col in df.columns:
+                self._categories[col] = list(df[col].dropna().unique())
+        self._fit_params["categories"] = self._categories
+
+    def _transform_local(self, df: pd.DataFrame) -> RecommendationResult:
+        df = df.copy()
+        rows_before = len(df)
+        new_cols = []
+        for col in self.columns:
+            if col in df.columns:
+                dummies = pd.get_dummies(df[col], prefix=col, drop_first=self.drop_first)
+                new_cols.extend(dummies.columns.tolist())
+                df = pd.concat([df, dummies], axis=1)
+                df = df.drop(columns=[col])
+        return RecommendationResult(
+            data=df, columns_affected=self.columns + new_cols, rows_before=rows_before,
+            rows_after=len(df), metadata={"categories": self._categories, "new_columns": new_cols}
+        )
+
+    def _transform_databricks(self, df: pd.DataFrame) -> RecommendationResult:
+        from customer_retention.core.compat import is_spark_available
+        if not is_spark_available():
+            return self._transform_local(df)
+        return self._transform_local(df)
+
+    def _generate_local_code(self) -> str:
+        lines = [f"# Encode: {self.rationale}"]
+        for col in self.columns:
+            lines.append(f"df = pd.concat([df, pd.get_dummies(df['{col}'], prefix='{col}')], axis=1).drop(columns=['{col}'])")
+        return "\n".join(lines)
+
+    def _generate_databricks_code(self) -> str:
+        lines = [f"# Encode: {self.rationale}", "from pyspark.ml.feature import StringIndexer, OneHotEncoder"]
+        for col in self.columns:
+            lines.append(f"indexer = StringIndexer(inputCol='{col}', outputCol='{col}_idx')")
+            lines.append(f"encoder = OneHotEncoder(inputCol='{col}_idx', outputCol='{col}_vec')")
+            lines.append("df = encoder.fit(indexer.fit(df).transform(df)).transform(indexer.fit(df).transform(df))")
+        return "\n".join(lines)
+
+
+class LabelEncodeRecommendation(EncodingRecommendation):
+    def __init__(
+        self, columns: List[str], rationale: str = None, evidence: List[str] = None,
+        priority: str = "medium", source_finding: Optional[Any] = None
+    ):
+        rationale = rationale or "Label encode categorical features to integers"
+        super().__init__(columns, rationale, evidence, priority, source_finding)
+        self._mappings: Dict[str, Dict[str, int]] = {}
+
+    @property
+    def recommendation_type(self) -> str:
+        return "label_encode"
+
+    def _fit_impl(self, df: pd.DataFrame) -> None:
+        for col in self.columns:
+            if col in df.columns:
+                categories = sorted(df[col].dropna().unique())
+                self._mappings[col] = {cat: idx for idx, cat in enumerate(categories)}
+        self._fit_params["mappings"] = self._mappings
+
+    def _transform_local(self, df: pd.DataFrame) -> RecommendationResult:
+        df = df.copy()
+        rows_before = len(df)
+        for col in self.columns:
+            if col in df.columns and col in self._mappings:
+                df[col] = df[col].map(self._mappings[col])
+        return RecommendationResult(
+            data=df, columns_affected=self.columns, rows_before=rows_before,
+            rows_after=len(df), metadata={"mappings": self._mappings}
+        )
+
+    def _transform_databricks(self, df: pd.DataFrame) -> RecommendationResult:
+        from customer_retention.core.compat import is_spark_available
+        if not is_spark_available():
+            return self._transform_local(df)
+        return self._transform_local(df)
+
+    def _generate_local_code(self) -> str:
+        lines = [f"# Encode: {self.rationale}", "from sklearn.preprocessing import LabelEncoder"]
+        for col in self.columns:
+            lines.append(f"le_{col} = LabelEncoder()")
+            lines.append(f"df['{col}'] = le_{col}.fit_transform(df['{col}'].astype(str))")
+        return "\n".join(lines)
+
+    def _generate_databricks_code(self) -> str:
+        lines = [f"# Encode: {self.rationale}", "from pyspark.ml.feature import StringIndexer"]
+        for col in self.columns:
+            lines.append(f"indexer = StringIndexer(inputCol='{col}', outputCol='{col}_idx')")
+            lines.append("df = indexer.fit(df).transform(df)")
+            lines.append(f"df = df.drop('{col}').withColumnRenamed('{col}_idx', '{col}')")
+        return "\n".join(lines)