churnkit 0.75.0a3__py3-none-any.whl → 0.75.1a2__py3-none-any.whl

customer_retention/stages/profiling/temporal_feature_analyzer.py

@@ -5,7 +5,7 @@ from typing import Any, Dict, List, Optional, Tuple
 import numpy as np
 from scipy import stats
 
-from customer_retention.core.compat import DataFrame, pd
+from customer_retention.core.compat import DataFrame, pd, qcut, to_datetime
 from customer_retention.core.utils import compute_effect_size
 
 
@@ -627,7 +627,7 @@ class TemporalFeatureAnalyzer:
 
     def _prepare_dataframe(self, df: DataFrame) -> DataFrame:
         df = df.copy()
-        df[self.time_column] = pd.to_datetime(df[self.time_column])
+        df[self.time_column] = to_datetime(df[self.time_column])
         return df
 
     def _validate_event_level_target_usage(self, df: DataFrame, target_column: Optional[str]) -> None:
@@ -646,7 +646,7 @@ class TemporalFeatureAnalyzer:
         if len(df_iv) < bins * 2:
             return 0.0
         try:
-            df_iv["bin"] = pd.qcut(df_iv["feature"], q=bins, duplicates="drop")
+            df_iv["bin"] = qcut(df_iv["feature"], q=bins, duplicates="drop")
         except ValueError:
             return 0.0
 

customer_retention/stages/profiling/temporal_feature_engineer.py

@@ -25,7 +25,7 @@ from typing import Any, Dict, List, Optional
 
 import numpy as np
 
-from customer_retention.core.compat import pd
+from customer_retention.core.compat import Timedelta, pd, to_datetime, to_pandas
 
 
 class ReferenceMode(Enum):
@@ -179,8 +179,8 @@ class TemporalFeatureEngineer:
         Returns:
             TemporalFeatureResult with features DataFrame and metadata
         """
-        events_df = events_df.copy()
-        events_df[time_col] = pd.to_datetime(events_df[time_col])
+        events_df = to_pandas(events_df).copy()
+        events_df[time_col] = to_datetime(events_df[time_col])
 
         # Determine reference dates per entity
         ref_dates = self._get_reference_dates(
@@ -313,9 +313,9 @@ class TemporalFeatureEngineer:
             })
 
         if reference_dates is not None and reference_col is not None:
-            ref_df = reference_dates[[entity_col, reference_col]].copy()
+            ref_df = to_pandas(reference_dates)[[entity_col, reference_col]].copy()
             ref_df.columns = [entity_col, "reference_date"]
-            ref_df["reference_date"] = pd.to_datetime(ref_df["reference_date"])
+            ref_df["reference_date"] = to_datetime(ref_df["reference_date"])
             return ref_df
 
         # Default: Use last event date per entity
@@ -511,8 +511,8 @@ class TemporalFeatureEngineer:
             entity_df["last_event"].iloc[0]
 
             # Calculate split boundaries
-            split1 = first_event + pd.Timedelta(days=history_days * splits[0])
-            split2 = first_event + pd.Timedelta(days=history_days * (splits[0] + splits[1]))
+            split1 = first_event + Timedelta(days=history_days * splits[0])
+            split2 = first_event + Timedelta(days=history_days * (splits[0] + splits[1]))
 
             for col in value_cols:
                 beginning_val = entity_df[entity_df[time_col] < split1][col].sum()

customer_retention/stages/profiling/temporal_pattern_analyzer.py

@@ -5,7 +5,7 @@ from typing import Dict, List, Optional, Tuple
 import numpy as np
 from scipy import stats
 
-from customer_retention.core.compat import DataFrame, pd
+from customer_retention.core.compat import DataFrame, Timestamp, cut, pd, to_datetime, to_pandas
 from customer_retention.core.utils import compute_effect_size
 
 
@@ -229,15 +229,16 @@ MONOTONIC_TOLERANCE = 0.05
 
 def compute_recency_buckets(
     df: DataFrame, entity_column: str, time_column: str, target_column: str,
-    reference_date: pd.Timestamp, bucket_edges: Optional[List[float]] = None
+    reference_date: Timestamp, bucket_edges: Optional[List[float]] = None
 ) -> List[RecencyBucketStats]:
+    df = to_pandas(df)
     edges = bucket_edges or DEFAULT_BUCKET_EDGES
     labels = _generate_bucket_labels(edges)
     entity_last = df.groupby(entity_column)[time_column].max().reset_index()
     entity_last["recency_days"] = (reference_date - entity_last[time_column]).dt.days
     entity_target = df.groupby(entity_column)[target_column].first().reset_index()
     entity_data = entity_last.merge(entity_target, on=entity_column)
-    entity_data["bucket"] = pd.cut(entity_data["recency_days"], bins=edges, labels=labels, include_lowest=True)
+    entity_data["bucket"] = cut(entity_data["recency_days"], bins=edges, labels=labels, include_lowest=True)
     bucket_stats = []
     for i, label in enumerate(labels):
         bucket_data = entity_data[entity_data["bucket"] == label]
@@ -296,6 +297,7 @@ def classify_distribution_pattern(buckets: List[RecencyBucketStats]) -> str:
 def _diagnose_anomaly_pattern(
     df: DataFrame, entity_column: str, time_column: str, target_column: str
 ) -> AnomalyDiagnostics:
+    df = to_pandas(df)
     entity_target = df.groupby(entity_column)[target_column].first()
     target_1_pct = float(entity_target.mean() * 100)
     target_1_is_minority = target_1_pct < 50
@@ -429,8 +431,9 @@ def _extract_threshold_from_bucket(bucket_label: str) -> int:
 
 def compare_recency_by_target(
     df: DataFrame, entity_column: str, time_column: str, target_column: str,
-    reference_date: Optional[pd.Timestamp] = None, cap_percentile: float = 0.99
+    reference_date: Optional[Timestamp] = None, cap_percentile: float = 0.99
 ) -> Optional[RecencyComparisonResult]:
+    df = to_pandas(df)
     if target_column not in df.columns:
         return None
     ref_date = reference_date or df[time_column].max()
@@ -495,11 +498,11 @@ class TemporalPatternAnalyzer:
         if len(df) < 3:
             return self._unknown_trend()
 
-        df_clean = df[[self.time_column, value_column]].dropna()
+        df_clean = to_pandas(df)[[self.time_column, value_column]].dropna()
         if len(df_clean) < 3:
             return self._unknown_trend()
 
-        time_col = pd.to_datetime(df_clean[self.time_column])
+        time_col = to_datetime(df_clean[self.time_column])
         x = (time_col - time_col.min()).dt.total_seconds() / 86400
         y = df_clean[value_column].values
 
@@ -583,10 +586,10 @@ class TemporalPatternAnalyzer:
         if len(df) == 0:
             return pd.DataFrame()
 
-        df_copy = df.copy()
+        df_copy = to_pandas(df).copy()
         entity_first_event = df_copy.groupby(entity_column)[cohort_column].min()
         df_copy["_cohort"] = df_copy[entity_column].map(entity_first_event)
-        df_copy["_cohort"] = pd.to_datetime(df_copy["_cohort"]).dt.to_period(period)
+        df_copy["_cohort"] = to_datetime(df_copy["_cohort"]).dt.to_period(period)
 
         entity_cohorts = df_copy.groupby(entity_column)["_cohort"].first().reset_index()
         entity_cohorts.columns = [entity_column, "_cohort"]
@@ -607,15 +610,16 @@ class TemporalPatternAnalyzer:
 
         return cohort_stats.sort_values("cohort")
 
-    def analyze_recency(self, df: DataFrame, entity_column: str, target_column: Optional[str] = None, reference_date: Optional[pd.Timestamp] = None) -> RecencyResult:
+    def analyze_recency(self, df: DataFrame, entity_column: str, target_column: Optional[str] = None, reference_date: Optional[Timestamp] = None) -> RecencyResult:
         if len(df) == 0:
             return RecencyResult(avg_recency_days=0, median_recency_days=0, min_recency_days=0, max_recency_days=0)
 
-        ref_date = reference_date or pd.Timestamp.now()
-        pd.to_datetime(df[self.time_column])
+        df = to_pandas(df)
+        ref_date = reference_date or Timestamp.now()
+        to_datetime(df[self.time_column])
 
         entity_last = df.groupby(entity_column)[self.time_column].max()
-        entity_last = pd.to_datetime(entity_last)
+        entity_last = to_datetime(entity_last)
         recency_days = (ref_date - entity_last).dt.days
 
         target_correlation = None

customer_retention/stages/profiling/temporal_quality_checks.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass, field
 from typing import Optional
 
-from customer_retention.core.compat import DataFrame, pd
+from customer_retention.core.compat import DataFrame, Timestamp, to_datetime, to_pandas
 from customer_retention.core.components.enums import Severity
 
 
@@ -73,7 +73,8 @@ class TemporalGapCheck(TemporalQualityCheck):
         if len(df) < 2:
             return self._pass_result("Insufficient data to check gaps")
 
-        time_col = pd.to_datetime(df.sort_values(self.time_column)[self.time_column])
+        df = to_pandas(df)
+        time_col = to_datetime(df.sort_values(self.time_column)[self.time_column])
         diffs_days = time_col.diff().dropna().dt.total_seconds() / 86400
         expected_days = self.FREQ_TO_DAYS.get(self.expected_frequency, 1)
         threshold_days = expected_days * self.max_gap_multiple
@@ -101,16 +102,16 @@ class TemporalGapCheck(TemporalQualityCheck):
 
 
 class FutureDateCheck(TemporalQualityCheck):
-    def __init__(self, time_column: str, reference_date: Optional[pd.Timestamp] = None):
+    def __init__(self, time_column: str, reference_date: Optional[Timestamp] = None):
         super().__init__("TQ003", "Future Dates", Severity.HIGH)
         self.time_column = time_column
-        self.reference_date = reference_date or pd.Timestamp.now()
+        self.reference_date = reference_date or Timestamp.now()
 
     def run(self, df: DataFrame) -> TemporalQualityResult:
         if len(df) == 0:
             return self._pass_result("No data to check")
 
-        time_col = pd.to_datetime(df[self.time_column])
+        time_col = to_datetime(df[self.time_column])
         future_mask = time_col > self.reference_date
         future_count = future_mask.sum()
 
@@ -140,7 +141,7 @@ class EventOrderCheck(TemporalQualityCheck):
         if len(df) < 2:
             return self._pass_result("Insufficient data to check ordering")
 
-        df_check = df.assign(_parsed_time=pd.to_datetime(df[self.time_column]))
+        df_check = df.assign(_parsed_time=to_datetime(df[self.time_column]))
         collision_counts = df_check.groupby([self.entity_column, "_parsed_time"]).size()
         ambiguous = collision_counts[collision_counts > 1]
         ambiguous_count = ambiguous.sum() - len(ambiguous)

customer_retention/stages/profiling/time_series_profiler.py

@@ -3,7 +3,14 @@ from typing import Optional
 
 import numpy as np
 
-from customer_retention.core.compat import DataFrame, pd
+from customer_retention.core.compat import (
+    DataFrame,
+    Timestamp,
+    is_datetime64_any_dtype,
+    pd,
+    to_datetime,
+    to_pandas,
+)
 
 
 @dataclass
@@ -161,8 +168,8 @@ def classify_activity_segments(entity_lifecycles: DataFrame) -> ActivitySegmentR
 @dataclass
 class EntityLifecycle:
     entity: str
-    first_event: pd.Timestamp
-    last_event: pd.Timestamp
+    first_event: Timestamp
+    last_event: Timestamp
     duration_days: int
     event_count: int
 
@@ -177,8 +184,8 @@ class TimeSeriesProfile:
     events_per_entity: DistributionStats
     entity_lifecycles: DataFrame
     avg_inter_event_days: Optional[float] = None
-    first_event_date: Optional[pd.Timestamp] = None
-    last_event_date: Optional[pd.Timestamp] = None
+    first_event_date: Optional[Timestamp] = None
+    last_event_date: Optional[Timestamp] = None
 
 
 class TimeSeriesProfiler:
@@ -223,9 +230,9 @@ class TimeSeriesProfiler:
             raise KeyError(f"Time column '{self.time_column}' not found")
 
     def _prepare_dataframe(self, df: DataFrame) -> DataFrame:
-        df = df.copy()
-        if not pd.api.types.is_datetime64_any_dtype(df[self.time_column]):
-            df[self.time_column] = pd.to_datetime(df[self.time_column])
+        df = to_pandas(df).copy()
+        if not is_datetime64_any_dtype(df[self.time_column]):
+            df[self.time_column] = to_datetime(df[self.time_column])
         return df
 
     def _compute_entity_lifecycles(self, df: DataFrame) -> DataFrame:

customer_retention/stages/profiling/time_window_aggregator.py

@@ -6,7 +6,14 @@ from typing import Dict, List, Optional, Union
 
 import numpy as np
 
-from customer_retention.core.compat import DataFrame, pd
+from customer_retention.core.compat import (
+    DataFrame,
+    Timedelta,
+    Timestamp,
+    is_numeric_dtype,
+    pd,
+    to_datetime,
+)
 
 
 class AggregationType(str, Enum):
@@ -71,7 +78,7 @@ class TimeWindowAggregator:
     def aggregate(
         self, df: DataFrame, windows: Optional[List[str]] = None,
         value_columns: Optional[List[str]] = None, agg_funcs: Optional[List[str]] = None,
-        reference_date: Optional[pd.Timestamp] = None, include_event_count: bool = False,
+        reference_date: Optional[Timestamp] = None, include_event_count: bool = False,
         include_recency: bool = False, include_tenure: bool = False,
         exclude_columns: Optional[List[str]] = None,
     ) -> DataFrame:
@@ -79,7 +86,7 @@ class TimeWindowAggregator:
             return pd.DataFrame()
 
         df = df.copy()
-        df[self.time_column] = pd.to_datetime(df[self.time_column])
+        df[self.time_column] = to_datetime(df[self.time_column])
         reference_date = self._validate_reference_date(df, reference_date)
         parsed_windows = [TimeWindow.from_string(w) for w in (windows or ["30d"])]
 
@@ -107,13 +114,13 @@ class TimeWindowAggregator:
         result = pd.DataFrame(result_data)
         result.attrs["aggregation_reference_date"] = (
             reference_date.isoformat() if hasattr(reference_date, "isoformat") else str(reference_date))
-        result.attrs["aggregation_timestamp"] = pd.Timestamp.now().isoformat()
+        result.attrs["aggregation_timestamp"] = Timestamp.now().isoformat()
         return result
 
     def _add_value_aggregations(
         self, result_data: Dict, df: DataFrame, entities: np.ndarray,
         windows: List[TimeWindow], value_columns: List[str], agg_funcs: List[str],
-        reference_date: pd.Timestamp,
+        reference_date: Timestamp,
     ) -> None:
         for window in windows:
             for col in value_columns:
@@ -169,9 +176,9 @@ class TimeWindowAggregator:
 
         return feature_columns, value_counts_categories
 
-    def _validate_reference_date(self, df: DataFrame, reference_date: Optional[pd.Timestamp]) -> pd.Timestamp:
+    def _validate_reference_date(self, df: DataFrame, reference_date: Optional[Timestamp]) -> Timestamp:
         data_min, data_max = df[self.time_column].min(), df[self.time_column].max()
-        current_date = pd.Timestamp.now()
+        current_date = Timestamp.now()
 
         if reference_date is None:
             warnings.warn(
@@ -196,16 +203,16 @@ class TimeWindowAggregator:
         return reference_date
 
     def _compute_event_counts(
-        self, df: DataFrame, entities: np.ndarray, window: TimeWindow, reference_date: pd.Timestamp,
+        self, df: DataFrame, entities: np.ndarray, window: TimeWindow, reference_date: Timestamp,
     ) -> np.ndarray:
         filtered_df = self._filter_by_window(df, window, reference_date)
         counts = filtered_df.groupby(self.entity_column).size()
         return np.array([counts.get(e, 0) for e in entities])
 
-    def _filter_by_window(self, df: DataFrame, window: TimeWindow, reference_date: pd.Timestamp) -> DataFrame:
+    def _filter_by_window(self, df: DataFrame, window: TimeWindow, reference_date: Timestamp) -> DataFrame:
         if window.days is None:
             return df
-        cutoff = reference_date - pd.Timedelta(days=window.days)
+        cutoff = reference_date - Timedelta(days=window.days)
         return df[df[self.time_column] >= cutoff]
 
     def _compute_aggregation(
@@ -215,14 +222,14 @@ class TimeWindowAggregator:
         value_column: str,
         agg_func: str,
         window: TimeWindow,
-        reference_date: pd.Timestamp,
+        reference_date: Timestamp,
     ) -> np.ndarray:
         filtered_df = self._filter_by_window(df, window, reference_date)
         if len(filtered_df) == 0:
             default = 0 if agg_func in ["sum", "count", "nunique"] else np.nan
             return np.full(len(entities), default)
 
-        is_numeric = pd.api.types.is_numeric_dtype(df[value_column])
+        is_numeric = is_numeric_dtype(df[value_column])
         if agg_func in CATEGORICAL_AGG_FUNCS:
             return self._compute_categorical_agg(filtered_df, entities, value_column, agg_func)
         elif agg_func in NUMERIC_AGG_FUNCS and not is_numeric:
@@ -288,7 +295,7 @@ class TimeWindowAggregator:
         return np.array([entropy_result.get(e, np.nan) for e in entities])
 
     def _compute_value_counts(
-        self, df: DataFrame, entities: np.ndarray, col: str, window: TimeWindow, reference_date: pd.Timestamp
+        self, df: DataFrame, entities: np.ndarray, col: str, window: TimeWindow, reference_date: Timestamp
     ) -> Dict[str, np.ndarray]:
         filtered_df = self._filter_by_window(df, window, reference_date)
         unique_values = df[col].dropna().unique()
@@ -302,12 +309,12 @@ class TimeWindowAggregator:
                 result[col_name] = np.array([counts.get(e, 0) for e in entities])
         return result
 
-    def _compute_recency(self, df: DataFrame, entities: np.ndarray, reference_date: pd.Timestamp) -> np.ndarray:
+    def _compute_recency(self, df: DataFrame, entities: np.ndarray, reference_date: Timestamp) -> np.ndarray:
         last_dates = df.groupby(self.entity_column)[self.time_column].max()
         days_since_last = (reference_date - last_dates).dt.days
         return np.array([days_since_last.get(e, np.nan) for e in entities])
 
-    def _compute_tenure(self, df: DataFrame, entities: np.ndarray, reference_date: pd.Timestamp) -> np.ndarray:
+    def _compute_tenure(self, df: DataFrame, entities: np.ndarray, reference_date: Timestamp) -> np.ndarray:
         first_dates = df.groupby(self.entity_column)[self.time_column].min()
         days_since_first = (reference_date - first_dates).dt.days
         return np.array([days_since_first.get(e, np.nan) for e in entities])

customer_retention/stages/transformation/categorical_encoder.py

@@ -4,7 +4,7 @@ from typing import Optional
 
 import numpy as np
 
-from customer_retention.core.compat import DataFrame, Series, pd
+from customer_retention.core.compat import DataFrame, Series, to_numeric
 
 
 class EncodingStrategy(str, Enum):
@@ -212,7 +212,7 @@ class CategoricalEncoder:
         if hasattr(self, '_cyclical_mapping') and self._cyclical_mapping is not None:
             numeric = series.map(self._cyclical_mapping)
         else:
-            numeric = pd.to_numeric(series, errors='coerce')
+            numeric = to_numeric(series, errors='coerce')
 
         sin_vals = np.sin(2 * np.pi * numeric / self.period)
         cos_vals = np.cos(2 * np.pi * numeric / self.period)

customer_retention/stages/transformation/pipeline.py

@@ -4,7 +4,7 @@ from typing import Optional
 
 import numpy as np
 
-from customer_retention.core.compat import DataFrame, pd
+from customer_retention.core.compat import DataFrame, notna
 from customer_retention.core.config import ColumnType
 from customer_retention.stages.cleaning import MissingValueHandler, OutlierHandler, OutlierTreatmentStrategy
 
@@ -198,7 +198,7 @@ class TransformationPipeline:
             if col in working_df.columns and working_df[col].isna().any():
                 # Fill with median for extracted datetime features
                 median_val = working_df[col].median()
-                if pd.notna(median_val):
+                if notna(median_val):
                     working_df[col] = working_df[col].fillna(median_val)
 
         for col, transformer in self._numeric_transformers.items():

customer_retention/stages/validation/data_quality_gate.py

@@ -1,6 +1,6 @@
 import time
 
-from customer_retention.core.compat import DataFrame, Timestamp, is_datetime64_any_dtype, pd
+from customer_retention.core.compat import DataFrame, Timestamp, is_datetime64_any_dtype, to_datetime, to_numeric
 from customer_retention.core.config.column_config import ColumnType
 from customer_retention.core.config.pipeline_config import BronzeConfig, PipelineConfig
 
@@ -159,7 +159,7 @@ class DataQualityGate(ValidationGate):
                     continue
 
                 if not is_datetime64_any_dtype(df_temp):
-                    df_temp = pd.to_datetime(df_temp, errors='coerce', format='mixed')
+                    df_temp = to_datetime(df_temp, errors='coerce', format='mixed')
 
                 future_dates = df_temp > Timestamp.now()
                 future_count = future_dates.sum()
@@ -185,8 +185,8 @@ class DataQualityGate(ValidationGate):
                 if len(df_temp) == 0:
                     return issues
 
-                created = pd.to_datetime(df_temp['created'], errors='coerce', format='mixed')
-                firstorder = pd.to_datetime(df_temp['firstorder'], errors='coerce', format='mixed')
+                created = to_datetime(df_temp['created'], errors='coerce', format='mixed')
+                firstorder = to_datetime(df_temp['firstorder'], errors='coerce', format='mixed')
 
                 violations = created > firstorder
                 violation_count = violations.sum()
@@ -214,7 +214,7 @@ class DataQualityGate(ValidationGate):
 
                 if col_config.is_numeric() and column_data.dtype == 'object':
                     try:
-                        pd.to_numeric(column_data.dropna(), errors='raise')
+                        to_numeric(column_data.dropna(), errors='raise')
                         issues.append(self.create_issue(
                             "DQ040", "Numeric column stored as string",
                             Severity.MEDIUM, col_config.name, len(df), len(df),

customer_retention/stages/validation/data_validators.py

@@ -8,7 +8,7 @@ including duplicate detection, date logic validation, and value range validation
 from dataclasses import dataclass, field
 from typing import Any, Dict, List, Optional
 
-from customer_retention.core.compat import DataFrame, pd
+from customer_retention.core.compat import DataFrame, is_datetime64_any_dtype, pd, to_datetime
 from customer_retention.core.components.enums import Severity
 
 
@@ -249,8 +249,8 @@ class DataValidator:
         # Convert to datetime if needed
         df_dates = df[order].copy()
         for col in order:
-            if not pd.api.types.is_datetime64_any_dtype(df_dates[col]):
-                df_dates[col] = pd.to_datetime(df_dates[col], errors='coerce', format='mixed')
+            if not is_datetime64_any_dtype(df_dates[col]):
+                df_dates[col] = to_datetime(df_dates[col], errors='coerce', format='mixed')
 
         # Check sequential ordering
         violations = []

customer_retention/stages/validation/leakage_gate.py

@@ -1,7 +1,7 @@
 from dataclasses import dataclass
 from typing import TYPE_CHECKING, Any, Dict, List, Optional
 
-from customer_retention.core.compat import DataFrame, Timestamp, is_numeric_dtype, pd
+from customer_retention.core.compat import DataFrame, Timestamp, is_numeric_dtype, notna, to_datetime
 from customer_retention.core.components.enums import Severity
 
 if TYPE_CHECKING:
@@ -124,7 +124,7 @@ class LeakageGate:
         for feature in numeric_features:
             try:
                 corr = df[feature].corr(df[self.target_column])
-                if pd.notna(corr):
+                if notna(corr):
                     correlations[feature] = corr
             except Exception:
                 continue
@@ -153,7 +153,7 @@ class LeakageGate:
 
     @staticmethod
     def _parse_datetime(series, errors="coerce"):
-        return pd.to_datetime(series, errors=errors, format='mixed')
+        return to_datetime(series, errors=errors, format='mixed')
 
     def _check_perfect_separation(
         self,
@@ -236,7 +236,7 @@ class LeakageGate:
                 mean_0 = df[df[self.target_column] == target_values[0]][feature].mean()
                 mean_1 = df[df[self.target_column] == target_values[1]][feature].mean()
 
-                if (pd.notna(var_0) and pd.notna(var_1) and
+                if (notna(var_0) and notna(var_1) and
                     var_0 < 0.01 and var_1 < 0.01 and
                     abs(mean_0 - mean_1) > 0.1):
                     issues.append(LeakageIssue(

customer_retention/stages/validation/timeseries_detector.py

@@ -11,7 +11,7 @@ from datetime import timedelta
 from enum import Enum
 from typing import Any, Dict, List, Optional, Tuple
 
-from customer_retention.core.compat import DataFrame, pd
+from customer_retention.core.compat import DataFrame, is_datetime64_any_dtype, pd, to_datetime, to_pandas
 
 
 class DatasetType(Enum):
@@ -181,6 +181,7 @@ class TimeSeriesDetector:
         TimeSeriesCharacteristics
             Detected characteristics of the dataset
         """
+        df = to_pandas(df)
         evidence = []
 
         # Auto-detect entity column if not provided
@@ -255,7 +256,7 @@ class TimeSeriesDetector:
 
         if timestamp_column and timestamp_column in df.columns:
             # Convert to datetime if needed
-            ts_series = pd.to_datetime(
+            ts_series = to_datetime(
                 df[timestamp_column], errors='coerce', format='mixed'
             )
             valid_ts = ts_series.notna()
@@ -342,7 +343,7 @@ class TimeSeriesDetector:
             name_match = any(pattern in col_lower for pattern in self.TIMESTAMP_PATTERNS)
 
             # Check if column is datetime type
-            is_datetime = pd.api.types.is_datetime64_any_dtype(df[col])
+            is_datetime = is_datetime64_any_dtype(df[col])
 
             # Try to parse as datetime
             can_parse = False
@@ -350,7 +351,7 @@ class TimeSeriesDetector:
                 try:
                     with warnings.catch_warnings():
                         warnings.filterwarnings('ignore', category=FutureWarning)
-                        parsed = pd.to_datetime(
+                        parsed = to_datetime(
                             df[col].head(100), errors='coerce', format='mixed'
                         )
                     can_parse = parsed.notna().mean() > 0.8
@@ -389,7 +390,7 @@ class TimeSeriesDetector:
             if len(entity_data) < 2:
                 continue
 
-            ts = pd.to_datetime(
+            ts = to_datetime(
                 entity_data[timestamp_column], errors='coerce', format='mixed'
             )
             ts = ts.dropna().sort_values()
@@ -510,6 +511,8 @@ class TimeSeriesValidator:
         """
         issues = []
 
+        df = to_pandas(df)
+
         # Validate inputs
         if entity_column not in df.columns:
             return TimeSeriesValidationResult(
@@ -525,7 +528,7 @@ class TimeSeriesValidator:
 
         # Convert timestamp
         df_copy = df.copy()
-        df_copy['_ts'] = pd.to_datetime(
+        df_copy['_ts'] = to_datetime(
             df_copy[timestamp_column], errors='coerce', format='mixed'
         )
 

customer_retention/transforms/ops.py

@@ -12,7 +12,7 @@ from typing import Any
 
 import numpy as np
 
-from customer_retention.core.compat import DataFrame, pd
+from customer_retention.core.compat import DataFrame, get_dummies, pd
 
 
 def _requires_column(fn):
@@ -113,7 +113,7 @@ def apply_cap_then_log(df: DataFrame, column: str) -> DataFrame:
 
 @_requires_column
 def apply_one_hot_encode(df: DataFrame, column: str) -> DataFrame:
-    return pd.get_dummies(df, columns=[column], prefix=column)
+    return get_dummies(df, columns=[column], prefix=column)
 
 
 def apply_feature_select(df: DataFrame, column: str) -> DataFrame: