featcopilot 0.1.0__py3-none-any.whl → 0.3.0__py3-none-any.whl

featcopilot/engines/timeseries.py

@@ -12,6 +12,9 @@ from pydantic import Field
 
 from featcopilot.core.base import BaseEngine, EngineConfig
 from featcopilot.core.feature import FeatureSet
+from featcopilot.utils.logger import get_logger
+
+logger = get_logger(__name__)
 
 
 class TimeSeriesEngineConfig(EngineConfig):
@@ -25,6 +28,10 @@ class TimeSeriesEngineConfig(EngineConfig):
             "autocorrelation",
             "peaks",
             "trends",
+            "entropy",
+            "energy",
+            "complexity",
+            "counts",
         ],
         description="Feature groups to extract",
     )
@@ -33,6 +40,7 @@ class TimeSeriesEngineConfig(EngineConfig):
     )
     n_fft_coefficients: int = Field(default=10, description="Number of FFT coefficients")
     n_autocorr_lags: int = Field(default=10, description="Number of autocorrelation lags")
+    entropy_bins: int = Field(default=10, description="Number of bins for binned entropy")
 
 
 class TimeSeriesEngine(BaseEngine):
@@ -63,7 +71,7 @@ class TimeSeriesEngine(BaseEngine):
     >>> X_features = engine.fit_transform(time_series_df)
     """
 
-    # Feature extraction functions
+    # Feature extraction functions (tsfresh-inspired)
     FEATURE_EXTRACTORS = {
         "basic_stats": "_extract_basic_stats",
         "distribution": "_extract_distribution",
@@ -72,6 +80,10 @@ class TimeSeriesEngine(BaseEngine):
         "trends": "_extract_trends",
         "rolling": "_extract_rolling",
         "fft": "_extract_fft",
+        "entropy": "_extract_entropy",
+        "energy": "_extract_energy",
+        "complexity": "_extract_complexity",
+        "counts": "_extract_counts",
     }
 
     def __init__(
@@ -123,7 +135,7 @@ class TimeSeriesEngine(BaseEngine):
         self._time_columns = X.select_dtypes(include=[np.number]).columns.tolist()
 
         if self.config.verbose:
-            print(f"TimeSeriesEngine: Found {len(self._time_columns)} numeric columns")
+            logger.info(f"TimeSeriesEngine: Found {len(self._time_columns)} numeric columns")
 
         self._is_fitted = True
         return self
@@ -177,7 +189,7 @@ class TimeSeriesEngine(BaseEngine):
         self._feature_names = list(result.columns)
 
         if self.config.verbose:
-            print(f"TimeSeriesEngine: Extracted {len(self._feature_names)} features")
+            logger.info(f"TimeSeriesEngine: Extracted {len(self._feature_names)} features")
 
         return result
 
@@ -397,6 +409,226 @@ class TimeSeriesEngine(BaseEngine):
 
         return features
 
+    def _extract_entropy(self, series: np.ndarray, col: str) -> dict[str, float]:
+        """Extract entropy-based features (tsfresh-inspired)."""
+        features = {}
+        prefix = col
+
+        series_clean = series[~np.isnan(series)]
+        if len(series_clean) < 4:
+            return features
+
+        # Binned entropy
+        try:
+            hist, _ = np.histogram(series_clean, bins=self.config.entropy_bins)
+            hist = hist[hist > 0]
+            probs = hist / hist.sum()
+            features[f"{prefix}_binned_entropy"] = -np.sum(probs * np.log(probs + 1e-10))
+        except Exception:
+            features[f"{prefix}_binned_entropy"] = 0
+
+        # Sample entropy (simplified implementation)
+        try:
+            features[f"{prefix}_sample_entropy"] = self._sample_entropy(series_clean, m=2, r=0.2)
+        except Exception:
+            features[f"{prefix}_sample_entropy"] = 0
+
+        # Approximate entropy
+        try:
+            features[f"{prefix}_approximate_entropy"] = self._approximate_entropy(series_clean, m=2, r=0.2)
+        except Exception:
+            features[f"{prefix}_approximate_entropy"] = 0
+
+        return features
+
+    def _sample_entropy(self, series: np.ndarray, m: int = 2, r: float = 0.2) -> float:
+        """Compute sample entropy of a time series."""
+        n = len(series)
+        if n < m + 2:
+            return 0
+
+        # Normalize r by std
+        r = r * np.std(series)
+        if r == 0:
+            return 0
+
+        def _count_matches(template_length):
+            count = 0
+            templates = np.array([series[i : i + template_length] for i in range(n - template_length)])
+            for i in range(len(templates)):
+                for j in range(i + 1, len(templates)):
+                    if np.max(np.abs(templates[i] - templates[j])) < r:
+                        count += 1
+            return count
+
+        a = _count_matches(m)
+        b = _count_matches(m + 1)
+
+        if a == 0 or b == 0:
+            return 0
+
+        return -np.log(b / a)
+
+    def _approximate_entropy(self, series: np.ndarray, m: int = 2, r: float = 0.2) -> float:
+        """Compute approximate entropy of a time series."""
+        n = len(series)
+        if n < m + 2:
+            return 0
+
+        r = r * np.std(series)
+        if r == 0:
+            return 0
+
+        def _phi(m_val):
+            patterns = np.array([series[i : i + m_val] for i in range(n - m_val + 1)])
+            counts = np.zeros(len(patterns))
+            for i, pattern in enumerate(patterns):
+                for other in patterns:
+                    if np.max(np.abs(pattern - other)) < r:
+                        counts[i] += 1
+            counts = counts / len(patterns)
+            return np.sum(np.log(counts + 1e-10)) / len(patterns)
+
+        return _phi(m) - _phi(m + 1)
+
+    def _extract_energy(self, series: np.ndarray, col: str) -> dict[str, float]:
+        """Extract energy-based features (tsfresh-inspired)."""
+        features = {}
+        prefix = col
+
+        series_clean = series[~np.isnan(series)]
+        if len(series_clean) < 2:
+            return features
+
+        # Absolute energy: sum of squared values
+        features[f"{prefix}_abs_energy"] = np.sum(series_clean**2)
+
+        # Mean absolute change
+        features[f"{prefix}_mean_abs_change"] = np.mean(np.abs(np.diff(series_clean)))
+
+        # Mean second derivative central
+        if len(series_clean) >= 3:
+            second_deriv = series_clean[2:] - 2 * series_clean[1:-1] + series_clean[:-2]
+            features[f"{prefix}_mean_second_deriv_central"] = np.mean(second_deriv)
+
+        # Root mean square
+        features[f"{prefix}_rms"] = np.sqrt(np.mean(series_clean**2))
+
+        # Crest factor (peak/rms)
+        rms = features[f"{prefix}_rms"]
+        if rms > 0:
+            features[f"{prefix}_crest_factor"] = np.max(np.abs(series_clean)) / rms
+
+        return features
+
+    def _extract_complexity(self, series: np.ndarray, col: str) -> dict[str, float]:
+        """Extract complexity features (tsfresh-inspired)."""
+        features = {}
+        prefix = col
+
+        series_clean = series[~np.isnan(series)]
+        if len(series_clean) < 3:
+            return features
+
+        # CID_CE: Complexity-invariant distance
+        diff = np.diff(series_clean)
+        features[f"{prefix}_cid_ce"] = np.sqrt(np.sum(diff**2))
+
+        # C3: Time series complexity (lag 1)
+        if len(series_clean) >= 3:
+            n = len(series_clean)
+            c3 = np.sum(series_clean[2:n] * series_clean[1 : n - 1] * series_clean[0 : n - 2]) / (n - 2)
+            features[f"{prefix}_c3"] = c3
+
+        # Ratio of unique values to length
+        features[f"{prefix}_ratio_unique_values"] = len(np.unique(series_clean)) / len(series_clean)
+
+        # Has duplicate
+        features[f"{prefix}_has_duplicate"] = 1 if len(np.unique(series_clean)) < len(series_clean) else 0
+
+        # Has duplicate max
+        max_val = np.max(series_clean)
+        features[f"{prefix}_has_duplicate_max"] = 1 if np.sum(series_clean == max_val) > 1 else 0
+
+        # Has duplicate min
+        min_val = np.min(series_clean)
+        features[f"{prefix}_has_duplicate_min"] = 1 if np.sum(series_clean == min_val) > 1 else 0
+
+        # Sum of reoccurring values
+        unique, counts = np.unique(series_clean, return_counts=True)
+        reoccurring_mask = counts > 1
+        features[f"{prefix}_sum_reoccurring_values"] = np.sum(unique[reoccurring_mask] * counts[reoccurring_mask])
+
+        # Sum of reoccurring data points
+        features[f"{prefix}_sum_reoccurring_data_points"] = np.sum(counts[reoccurring_mask])
+
+        # Percentage of reoccurring data points
+        features[f"{prefix}_pct_reoccurring_data_points"] = np.sum(counts[reoccurring_mask]) / len(series_clean)
+
+        return features
+
+    def _extract_counts(self, series: np.ndarray, col: str) -> dict[str, float]:
+        """Extract count-based features (tsfresh-inspired)."""
+        features = {}
+        prefix = col
+
+        series_clean = series[~np.isnan(series)]
+        if len(series_clean) < 2:
+            return features
+
+        mean_val = np.mean(series_clean)
+
+        # Count above mean
+        features[f"{prefix}_count_above_mean"] = np.sum(series_clean > mean_val)
+
+        # Count below mean
+        features[f"{prefix}_count_below_mean"] = np.sum(series_clean < mean_val)
+
+        # First location of maximum
+        features[f"{prefix}_first_loc_max"] = np.argmax(series_clean) / len(series_clean)
+
+        # First location of minimum
+        features[f"{prefix}_first_loc_min"] = np.argmin(series_clean) / len(series_clean)
+
+        # Last location of maximum
+        features[f"{prefix}_last_loc_max"] = (len(series_clean) - 1 - np.argmax(series_clean[::-1])) / len(series_clean)
+
+        # Last location of minimum
+        features[f"{prefix}_last_loc_min"] = (len(series_clean) - 1 - np.argmin(series_clean[::-1])) / len(series_clean)
+
+        # Longest strike above mean
+        above_mean = series_clean > mean_val
+        features[f"{prefix}_longest_strike_above_mean"] = self._longest_consecutive(above_mean)
+
+        # Longest strike below mean
+        below_mean = series_clean < mean_val
+        features[f"{prefix}_longest_strike_below_mean"] = self._longest_consecutive(below_mean)
+
+        # Number of crossings (mean)
+        crossings = np.sum(np.diff(np.sign(series_clean - mean_val)) != 0)
+        features[f"{prefix}_number_crossings_mean"] = crossings
+
+        # Number of zero crossings
+        zero_crossings = np.sum(np.diff(np.sign(series_clean)) != 0)
+        features[f"{prefix}_number_zero_crossings"] = zero_crossings
+
+        # Absolute sum of changes
+        features[f"{prefix}_abs_sum_changes"] = np.sum(np.abs(np.diff(series_clean)))
+
+        return features
+
+    def _longest_consecutive(self, bool_array: np.ndarray) -> int:
+        """Find longest consecutive True values in boolean array."""
+        max_len = 0
+        current_len = 0
+        for val in bool_array:
+            if val:
+                current_len += 1
+                max_len = max(max_len, current_len)
+            else:
+                current_len = 0
+        return max_len
+
     def get_feature_set(self) -> FeatureSet:
         """Get the feature set with metadata."""
         return self._feature_set

featcopilot/llm/__init__.py

@@ -1,16 +1,21 @@
 """LLM-powered feature engineering module.
 
-Uses GitHub Copilot SDK for intelligent feature generation.
+Uses GitHub Copilot SDK or LiteLLM for intelligent feature generation.
 """
 
 from featcopilot.llm.code_generator import FeatureCodeGenerator
 from featcopilot.llm.copilot_client import CopilotFeatureClient
 from featcopilot.llm.explainer import FeatureExplainer
+from featcopilot.llm.litellm_client import LiteLLMFeatureClient, SyncLiteLLMFeatureClient
 from featcopilot.llm.semantic_engine import SemanticEngine
+from featcopilot.llm.transform_rule_generator import TransformRuleGenerator
 
 __all__ = [
     "CopilotFeatureClient",
+    "LiteLLMFeatureClient",
+    "SyncLiteLLMFeatureClient",
     "SemanticEngine",
     "FeatureExplainer",
     "FeatureCodeGenerator",
+    "TransformRuleGenerator",
 ]

featcopilot/llm/code_generator.py

@@ -10,6 +10,9 @@ import pandas as pd
 
 from featcopilot.core.feature import Feature, FeatureOrigin, FeatureType
 from featcopilot.llm.copilot_client import SyncCopilotFeatureClient
+from featcopilot.utils.logger import get_logger
+
+logger = get_logger(__name__)
 
 
 class FeatureCodeGenerator:
@@ -21,7 +24,7 @@ class FeatureCodeGenerator:
 
     Parameters
     ----------
-    model : str, default='gpt-5'
+    model : str, default='gpt-5.2'
         LLM model to use
     validate : bool, default=True
         Whether to validate generated code
@@ -35,7 +38,7 @@ class FeatureCodeGenerator:
     ... )
     """
 
-    def __init__(self, model: str = "gpt-5", validate: bool = True, verbose: bool = False):
+    def __init__(self, model: str = "gpt-5.2", validate: bool = True, verbose: bool = False):
         self.model = model
         self.validate = validate
         self.verbose = verbose
@@ -98,7 +101,7 @@ class FeatureCodeGenerator:
             )
             if not validation["valid"]:
                 if self.verbose:
-                    print(f"Code validation failed: {validation['error']}")
+                    logger.warning(f"Code validation failed: {validation['error']}")
                 # Try to fix common issues
                 code = self._fix_common_issues(code, validation["error"])
 
@@ -144,7 +147,7 @@ class FeatureCodeGenerator:
                 features.append(feature)
             except Exception as e:
                 if self.verbose:
-                    print(f"Failed to generate feature for '{desc}': {e}")
+                    logger.error(f"Failed to generate feature for '{desc}': {e}")
 
         return features
 

featcopilot/llm/copilot_client.py

@@ -10,11 +10,15 @@ from typing import Any, Optional
 
 from pydantic import BaseModel, Field
 
+from featcopilot.utils.logger import get_logger
+
+logger = get_logger(__name__)
+
 
 class CopilotConfig(BaseModel):
     """Configuration for Copilot client."""
 
-    model: str = Field(default="gpt-5", description="Model to use")
+    model: str = Field(default="gpt-5.2", description="Model to use")
     temperature: float = Field(default=0.3, ge=0, le=1, description="Temperature for generation")
     max_tokens: int = Field(default=4096, description="Maximum tokens in response")
     timeout: float = Field(default=60.0, description="Timeout in seconds")
@@ -35,12 +39,12 @@ class CopilotFeatureClient:
     ----------
     config : CopilotConfig, optional
         Configuration for the client
-    model : str, default='gpt-5'
+    model : str, default='gpt-5.2'
         Model to use for generation
 
     Examples
     --------
-    >>> client = CopilotFeatureClient(model='gpt-5')
+    >>> client = CopilotFeatureClient(model='gpt-5.2')
     >>> await client.start()
     >>> suggestions = await client.suggest_features(
     ...     column_info={'age': 'int', 'income': 'float'},
@@ -49,7 +53,7 @@ class CopilotFeatureClient:
     >>> await client.stop()
     """
 
-    def __init__(self, config: Optional[CopilotConfig] = None, model: str = "gpt-5", **kwargs):
+    def __init__(self, config: Optional[CopilotConfig] = None, model: str = "gpt-5.2", **kwargs):
         self.config = config or CopilotConfig(model=model, **kwargs)
         self._client = None
         self._session = None
@@ -82,13 +86,13 @@ class CopilotFeatureClient:
             # Copilot SDK not installed - use mock mode
             self._copilot_available = False
             self._is_started = True
-            print("Warning: copilot-sdk not installed. Using mock LLM responses.")
+            logger.warning("copilot-sdk not installed. Using mock LLM responses.")
 
         except Exception as e:
             # Copilot not available - use mock mode
             self._copilot_available = False
             self._is_started = True
-            print(f"Warning: Could not connect to Copilot: {e}. Using mock LLM responses.")
+            logger.warning(f"Could not connect to Copilot: {e}. Using mock LLM responses.")
 
         return self
 
@@ -469,7 +473,37 @@ result = df['col1'] / (df['col2'] + 1e-8)
                 local_vars = {"df": df, "np": np, "pd": pd}
                 exec(
                     code,
-                    {"__builtins__": {"len": len, "sum": sum, "max": max, "min": min}},
+                    {
+                        "__builtins__": {
+                            "len": len,
+                            "sum": sum,
+                            "max": max,
+                            "min": min,
+                            "int": int,
+                            "float": float,
+                            "str": str,
+                            "bool": bool,
+                            "abs": abs,
+                            "round": round,
+                            "pow": pow,
+                            "range": range,
+                            "list": list,
+                            "dict": dict,
+                            "set": set,
+                            "tuple": tuple,
+                            "sorted": sorted,
+                            "reversed": reversed,
+                            "enumerate": enumerate,
+                            "zip": zip,
+                            "any": any,
+                            "all": all,
+                            "map": map,
+                            "filter": filter,
+                            "isinstance": isinstance,
+                            "hasattr": hasattr,
+                            "getattr": getattr,
+                        }
+                    },
                     local_vars,
                 )
 
@@ -491,31 +525,74 @@ class SyncCopilotFeatureClient:
         self._async_client = CopilotFeatureClient(**kwargs)
         self._loop = None
 
-    def _get_loop(self):
+    def _get_or_create_loop(self):
+        """Get or create a persistent event loop for this client."""
         if self._loop is None or self._loop.is_closed():
+            self._loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(self._loop)
+        return self._loop
+
+    def _run_async(self, coro):
+        """Run an async coroutine, handling various event loop scenarios."""
+        try:
+            # First, try to get the running loop
             try:
-                self._loop = asyncio.get_event_loop()
+                loop = asyncio.get_running_loop()
+                # We're in a running loop - use nest_asyncio if available
+                try:
+                    import nest_asyncio
+
+                    nest_asyncio.apply()
+                    return loop.run_until_complete(coro)
+                except ImportError:
+                    # nest_asyncio not available, use thread pool
+                    import concurrent.futures
+
+                    with concurrent.futures.ThreadPoolExecutor() as executor:
+                        future = executor.submit(self._run_in_new_loop, coro)
+                        return future.result(timeout=120)
             except RuntimeError:
-                self._loop = asyncio.new_event_loop()
-                asyncio.set_event_loop(self._loop)
-        return self._loop
+                # No running event loop - use our persistent loop
+                loop = self._get_or_create_loop()
+                return loop.run_until_complete(coro)
+        except Exception as e:
+            # Last resort - create a completely fresh loop
+            try:
+                return self._run_in_new_loop(coro)
+            except Exception:
+                raise e from None
+
+    def _run_in_new_loop(self, coro):
+        """Run coroutine in a fresh event loop."""
+        loop = asyncio.new_event_loop()
+        try:
+            asyncio.set_event_loop(loop)
+            return loop.run_until_complete(coro)
+        finally:
+            loop.close()
 
     def start(self):
-        return self._get_loop().run_until_complete(self._async_client.start())
+        return self._run_async(self._async_client.start())
 
     def stop(self):
-        return self._get_loop().run_until_complete(self._async_client.stop())
+        result = self._run_async(self._async_client.stop())
+        # Close our loop if it exists
+        if self._loop is not None and not self._loop.is_closed():
+            self._loop.close()
+            self._loop = None
+        return result
 
     def suggest_features(self, **kwargs):
-        return self._get_loop().run_until_complete(self._async_client.suggest_features(**kwargs))
+        return self._run_async(self._async_client.suggest_features(**kwargs))
+
+    def send_prompt(self, prompt: str):
+        return self._run_async(self._async_client.send_prompt(prompt))
 
     def explain_feature(self, **kwargs):
-        return self._get_loop().run_until_complete(self._async_client.explain_feature(**kwargs))
+        return self._run_async(self._async_client.explain_feature(**kwargs))
 
     def generate_feature_code(self, **kwargs):
-        return self._get_loop().run_until_complete(self._async_client.generate_feature_code(**kwargs))
+        return self._run_async(self._async_client.generate_feature_code(**kwargs))
 
     def validate_feature_code(self, code: str, sample_data=None):
-        return self._get_loop().run_until_complete(
-            self._async_client.validate_feature_code(code=code, sample_data=sample_data)
-        )
+        return self._run_async(self._async_client.validate_feature_code(code=code, sample_data=sample_data))

featcopilot/llm/explainer.py

@@ -9,6 +9,9 @@ import pandas as pd
 
 from featcopilot.core.feature import Feature, FeatureSet
 from featcopilot.llm.copilot_client import SyncCopilotFeatureClient
+from featcopilot.utils.logger import get_logger
+
+logger = get_logger(__name__)
 
 
 class FeatureExplainer:
@@ -20,7 +23,7 @@ class FeatureExplainer:
 
     Parameters
     ----------
-    model : str, default='gpt-5'
+    model : str, default='gpt-5.2'
         LLM model to use
 
     Examples
@@ -29,7 +32,7 @@ class FeatureExplainer:
     >>> explanations = explainer.explain_features(feature_set, task='predict churn')
     """
 
-    def __init__(self, model: str = "gpt-5", verbose: bool = False):
+    def __init__(self, model: str = "gpt-5.2", verbose: bool = False):
         self.model = model
         self.verbose = verbose
         self._client: Optional[SyncCopilotFeatureClient] = None
@@ -115,7 +118,7 @@ class FeatureExplainer:
 
             except Exception as e:
                 if self.verbose:
-                    print(f"Could not explain {feature.name}: {e}")
+                    logger.error(f"Could not explain {feature.name}: {e}")
                 explanations[feature.name] = f"Feature based on: {', '.join(feature.source_columns)}"
 
         return explanations