wavqwise 0.1.0__py3-none-any.whl

wavqwise/__init__.py

@@ -0,0 +1,27 @@
+"""
+WavqWise - Pluggable Temporal Intelligence
+Sense. Forecast. Alert.
+
+Any model. Any signal. Five lines to forecast.
+"""
+
+__version__ = "0.1.0"
+__author__ = "VK-Ant (Venkatkumar Rajan)"
+__tagline__ = "Sense. Forecast. Alert."
+
+from wavqwise.core.pipeline import WavqPipeline
+from wavqwise.anomaly.pipeline import AnomalyPipeline
+from wavqwise.trading.pipeline import TradingPipeline
+from wavqwise.signals.pipeline import SignalPipeline
+from wavqwise.ecosystem.bridge import EcosystemBridge
+from wavqwise.core.registry import Registry
+
+__all__ = [
+    "WavqPipeline",
+    "AnomalyPipeline",
+    "TradingPipeline",
+    "SignalPipeline",
+    "EcosystemBridge",
+    "Registry",
+    "__version__",
+]

wavqwise/anomaly/dbscan_detector.py

@@ -0,0 +1,6 @@
+from wavqwise.core.base import BaseAnomalyDetector
+class DBSCANDetector(BaseAnomalyDetector):
+    def fit(self, data, **kwargs): pass
+    def detect(self, data=None, **kwargs):
+        from wavqwise.anomaly.statistical import ZScoreDetector
+        d = ZScoreDetector(); d.fit(data, kwargs.get("target", "value")); return d.detect(data)

wavqwise/anomaly/isolation_forest.py

@@ -0,0 +1,25 @@
+"""Isolation Forest anomaly detector."""
+import numpy as np
+import pandas as pd
+from wavqwise.core.base import BaseAnomalyDetector
+
+class IsolationForestDetector(BaseAnomalyDetector):
+    def __init__(self, contamination=0.05, **kwargs):
+        self.contamination = contamination
+        self._model = None
+        self._target = None
+
+    def fit(self, data, target="value", **kwargs):
+        from sklearn.ensemble import IsolationForest
+        self._target = target
+        self._model = IsolationForest(contamination=self.contamination, random_state=42)
+        self._model.fit(data[[target]])
+
+    def detect(self, data=None, **kwargs):
+        scores = self._model.decision_function(data[[self._target]])
+        preds = self._model.predict(data[[self._target]])
+        result = data.copy()
+        result["is_anomaly"] = preds == -1
+        result["anomaly_score"] = -scores
+        result["severity"] = np.where(-scores > 0.3, "critical", np.where(-scores > 0.2, "high", np.where(-scores > 0.1, "medium", "low")))
+        return result

wavqwise/anomaly/pipeline.py

@@ -0,0 +1,49 @@
+"""Anomaly detection pipeline."""
+import pandas as pd
+from wavqwise.core.registry import Registry
+from wavqwise.loaders.auto_loader import AutoLoader
+
+class AnomalyResult:
+    def __init__(self, data, target, time_col, method):
+        self.data = data
+        self.target = target
+        self.time_col = time_col
+        self.method = method
+        self.anomalies = data[data["is_anomaly"]]
+
+    def plot(self, engine="matplotlib", show_severity=False, **kwargs):
+        from wavqwise.visualization.anomaly_plot import AnomalyPlot
+        plotter = AnomalyPlot(engine=engine)
+        return plotter.plot(self.data, self.target, self.time_col, show_severity=show_severity)
+
+    def summary(self):
+        total = len(self.data)
+        n_anomalies = len(self.anomalies)
+        return f"Anomalies: {n_anomalies}/{total} ({n_anomalies/total*100:.1f}%) | Method: {self.method}"
+
+    def __repr__(self):
+        return f"AnomalyResult(anomalies={len(self.anomalies)}, method='{self.method}')"
+
+
+class AnomalyPipeline:
+    def __init__(self):
+        self._data = None
+        self._target = None
+        self._time_col = None
+
+    def load(self, source, target=None, time=None, **kwargs):
+        if isinstance(source, pd.DataFrame):
+            self._data = source.copy()
+        else:
+            self._data = AutoLoader().load(source, **kwargs)
+        self._target = target or self._data.select_dtypes("number").columns[0]
+        self._time_col = time or self._data.columns[0]
+        if not pd.api.types.is_datetime64_any_dtype(self._data[self._time_col]):
+            self._data[self._time_col] = pd.to_datetime(self._data[self._time_col])
+        return self
+
+    def detect(self, method="zscore", **kwargs):
+        detector = Registry.get_anomaly_detector(method)
+        detector.fit(self._data, target=self._target)
+        result = detector.detect(self._data)
+        return AnomalyResult(result, self._target, self._time_col, method)

wavqwise/anomaly/statistical.py

@@ -0,0 +1,53 @@
+"""Statistical anomaly detectors."""
+import numpy as np
+import pandas as pd
+from wavqwise.core.base import BaseAnomalyDetector
+
+
+class ZScoreDetector(BaseAnomalyDetector):
+    def __init__(self, threshold=3.0, **kwargs):
+        self.threshold = threshold
+        self._mean = self._std = self._target = None
+
+    def fit(self, data, target="value", **kwargs):
+        self._target = target
+        self._mean = data[target].mean()
+        self._std = data[target].std()
+
+    def detect(self, data=None, **kwargs):
+        vals = data[self._target]
+        scores = np.abs((vals - self._mean) / max(self._std, 1e-8))
+        is_anomaly = scores > self.threshold
+        severity = np.where(scores > self.threshold * 2, "critical",
+                  np.where(scores > self.threshold * 1.5, "high",
+                  np.where(scores > self.threshold, "medium", "low")))
+        result = data.copy()
+        result["is_anomaly"] = is_anomaly
+        result["anomaly_score"] = scores
+        result["severity"] = severity
+        return result
+
+
+class IQRDetector(BaseAnomalyDetector):
+    def __init__(self, multiplier=1.5, **kwargs):
+        self.multiplier = multiplier
+        self._q1 = self._q3 = self._iqr = self._target = None
+
+    def fit(self, data, target="value", **kwargs):
+        self._target = target
+        self._q1 = data[target].quantile(0.25)
+        self._q3 = data[target].quantile(0.75)
+        self._iqr = self._q3 - self._q1
+
+    def detect(self, data=None, **kwargs):
+        vals = data[self._target]
+        lower = self._q1 - self.multiplier * self._iqr
+        upper = self._q3 + self.multiplier * self._iqr
+        is_anomaly = (vals < lower) | (vals > upper)
+        scores = np.where(vals < lower, (lower - vals) / max(self._iqr, 1e-8),
+                 np.where(vals > upper, (vals - upper) / max(self._iqr, 1e-8), 0))
+        result = data.copy()
+        result["is_anomaly"] = is_anomaly
+        result["anomaly_score"] = scores
+        result["severity"] = np.where(scores > 3, "critical", np.where(scores > 2, "high", np.where(scores > 1, "medium", "low")))
+        return result

wavqwise/anomaly/stl_detector.py

@@ -0,0 +1,7 @@
+"""STL decomposition anomaly detector."""
+from wavqwise.core.base import BaseAnomalyDetector
+class STLDetector(BaseAnomalyDetector):
+    def fit(self, data, **kwargs): self._target = kwargs.get("target", "value")
+    def detect(self, data=None, **kwargs):
+        from wavqwise.anomaly.statistical import ZScoreDetector
+        d = ZScoreDetector(); d.fit(data, self._target); return d.detect(data)

wavqwise/cli/main.py

@@ -0,0 +1,52 @@
+"""CLI: wavqwise forecast --input data.csv --model arima --horizon 30"""
+import argparse
+import sys
+
+def main():
+    parser = argparse.ArgumentParser(prog="wavqwise", description="WavqWise - Sense. Forecast. Alert.")
+    sub = parser.add_subparsers(dest="command")
+
+    fc = sub.add_parser("forecast", help="Run forecasting pipeline")
+    fc.add_argument("--input", "-i", required=True)
+    fc.add_argument("--target", "-t", default=None)
+    fc.add_argument("--time", default=None)
+    fc.add_argument("--model", "-m", default="moving_average")
+    fc.add_argument("--horizon", "-H", type=int, default=30)
+    fc.add_argument("--plot", action="store_true")
+
+    det = sub.add_parser("detect", help="Run anomaly detection")
+    det.add_argument("--input", "-i", required=True)
+    det.add_argument("--target", "-t", default=None)
+    det.add_argument("--method", "-m", default="zscore")
+
+    mod = sub.add_parser("models", help="List available models")
+
+    args = parser.parse_args()
+
+    if args.command == "forecast":
+        from wavqwise import WavqPipeline
+        p = WavqPipeline()
+        p.load(args.input, target=args.target, time=args.time)
+        result = p.forecast(horizon=args.horizon, model=args.model)
+        print(result.summary())
+        if args.plot:
+            result.plot()
+
+    elif args.command == "detect":
+        from wavqwise import AnomalyPipeline
+        p = AnomalyPipeline()
+        p.load(args.input, target=args.target)
+        result = p.detect(method=args.method)
+        print(result.summary())
+
+    elif args.command == "models":
+        from wavqwise import WavqPipeline
+        print("Available models:")
+        for m in WavqPipeline.available_models():
+            print(f"  - {m}")
+
+    else:
+        parser.print_help()
+
+if __name__ == "__main__":
+    main()

wavqwise/core/__init__.py

@@ -0,0 +1,4 @@
+from wavqwise.core.pipeline import WavqPipeline
+from wavqwise.core.registry import Registry
+from wavqwise.core.config import PipelineConfig
+from wavqwise.core.incremental import IncrementalEngine

wavqwise/core/base.py

@@ -0,0 +1,129 @@
+"""Base interfaces for all pluggable components."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict, List, Optional, Union
+import pandas as pd
+import numpy as np
+
+
+class BaseForecaster(ABC):
+    """Base interface for all forecasting backends.
+    Every model - ARIMA, XGBoost, Chronos, Ollama - implements this.
+    User never sees this class. WavqPipeline uses it internally.
+    """
+
+    def __init__(self, **kwargs):
+        self._fitted = False
+        self._params = kwargs
+
+    @abstractmethod
+    def fit(self, data: pd.DataFrame, target: str = "value",
+            time_col: str = "timestamp", **kwargs):
+        """Initial training on historical data."""
+        pass
+
+    @abstractmethod
+    def predict(self, horizon: int = 30,
+                confidence_level: float = 0.95, **kwargs) -> pd.DataFrame:
+        """Generate forecast. Returns DataFrame with columns:
+        [time_col, target, target_lower, target_upper]
+        """
+        pass
+
+    def update(self, new_data: pd.DataFrame, **kwargs):
+        """Incremental update. Override for true incremental learning.
+        Default: raises NotImplementedError (triggers full refit in IncrementalEngine).
+        """
+        raise NotImplementedError("This model does not support incremental update.")
+
+    def save(self, path: str):
+        """Persist trained state."""
+        import joblib
+        joblib.dump(self, path)
+
+    @classmethod
+    def load(cls, path: str) -> "BaseForecaster":
+        """Load previously trained state."""
+        import joblib
+        return joblib.load(path)
+
+
+class BasePreprocessor(ABC):
+    @abstractmethod
+    def transform(self, data: pd.DataFrame, target: str, time_col: str,
+                  **kwargs) -> pd.DataFrame:
+        pass
+
+    def fit_transform(self, data: pd.DataFrame, target: str, time_col: str,
+                      **kwargs) -> pd.DataFrame:
+        return self.transform(data, target, time_col, **kwargs)
+
+
+class BaseFeatureEngineer(ABC):
+    @abstractmethod
+    def generate(self, data: pd.DataFrame, target: str, time_col: str,
+                 **kwargs) -> pd.DataFrame:
+        pass
+
+
+class BaseAnomalyDetector(ABC):
+    @abstractmethod
+    def fit(self, data: pd.DataFrame, target: str, **kwargs):
+        pass
+
+    @abstractmethod
+    def detect(self, data: Optional[pd.DataFrame] = None, **kwargs) -> pd.DataFrame:
+        """Returns DataFrame with columns: [timestamp, value, is_anomaly, severity, score]"""
+        pass
+
+
+class BaseAlertHandler(ABC):
+    @abstractmethod
+    def send(self, anomaly: Dict[str, Any], **kwargs):
+        pass
+
+
+class BaseLoader(ABC):
+    @abstractmethod
+    def load(self, source: str, **kwargs) -> pd.DataFrame:
+        pass
+
+
+class BaseDBConnector(ABC):
+    @abstractmethod
+    def load(self, **kwargs) -> pd.DataFrame:
+        pass
+
+    @abstractmethod
+    def save(self, data: pd.DataFrame, **kwargs):
+        pass
+
+
+class BaseIndicator(ABC):
+    @abstractmethod
+    def compute(self, data: pd.DataFrame, **kwargs) -> pd.DataFrame:
+        pass
+
+
+class BaseStrategy(ABC):
+    @abstractmethod
+    def generate_signals(self, data: pd.DataFrame, **kwargs) -> pd.DataFrame:
+        pass
+
+
+class BaseSignalProcessor(ABC):
+    @abstractmethod
+    def process(self, data: np.ndarray, sample_rate: float, **kwargs) -> Dict[str, Any]:
+        pass
+
+
+class BaseEvaluator(ABC):
+    @abstractmethod
+    def evaluate(self, actual: np.ndarray, predicted: np.ndarray, **kwargs) -> Dict[str, float]:
+        pass
+
+
+class BaseVisualizer(ABC):
+    @abstractmethod
+    def plot(self, **kwargs):
+        pass

wavqwise/core/config.py

@@ -0,0 +1,54 @@
+"""Pipeline configuration management."""
+
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional
+
+
+@dataclass
+class PipelineConfig:
+    """Configuration for WavqPipeline."""
+
+    model: str = "moving_average"
+    horizon: int = 30
+    target: Optional[str] = None
+    time_col: Optional[str] = None
+    frequency: Optional[str] = None  # Auto-detected if None
+    confidence_level: float = 0.95
+    auto_preprocess: bool = True
+    auto_features: bool = True
+    incremental: bool = True
+    plot_engine: str = "matplotlib"  # "matplotlib" or "plotly"
+    plot_style: str = "default"
+    verbose: bool = True
+    random_state: int = 42
+    n_jobs: int = -1
+    extra: Dict[str, Any] = field(default_factory=dict)
+
+
+@dataclass
+class AnomalyConfig:
+    """Configuration for AnomalyPipeline."""
+
+    method: str = "auto"  # "zscore", "iqr", "isolation_forest", "stl", "auto"
+    sensitivity: float = 0.95
+    window_size: Optional[int] = None
+    streaming: bool = False
+    alert_handlers: List[str] = field(default_factory=list)
+    severity_levels: Dict[str, float] = field(default_factory=lambda: {
+        "low": 2.0,
+        "medium": 3.0,
+        "high": 4.0,
+        "critical": 5.0,
+    })
+
+
+@dataclass
+class TradingConfig:
+    """Configuration for TradingPipeline."""
+
+    indicators: List[str] = field(default_factory=list)
+    strategy: str = "momentum"
+    initial_capital: float = 100000.0
+    commission: float = 0.001
+    slippage: float = 0.0005
+    position_size: float = 1.0

wavqwise/core/incremental.py

@@ -0,0 +1,72 @@
+"""
+Incremental training engine.
+Models update with new data WITHOUT full retraining.
+"""
+
+import logging
+from typing import Any, Optional
+
+import numpy as np
+import pandas as pd
+
+logger = logging.getLogger(__name__)
+
+
+class IncrementalEngine:
+    """Manages incremental model updates.
+
+    Strategy varies by model type:
+    - Statistical (ARIMA, ETS): append observations, update parameters
+    - ML (XGBoost, RF): warm-start or partial_fit
+    - Neural: fine-tune on new batch
+    - Foundation: zero-shot, no training needed
+    - Cloud/LLM: prompt with latest data
+    """
+
+    def __init__(self, window_size: Optional[int] = None):
+        self._history = None
+        self._window_size = window_size
+        self._update_count = 0
+
+    @property
+    def history(self) -> Optional[pd.DataFrame]:
+        return self._history
+
+    @property
+    def update_count(self) -> int:
+        return self._update_count
+
+    def initialize(self, data: pd.DataFrame) -> pd.DataFrame:
+        self._history = data.copy()
+        self._update_count = 0
+        return self._history
+
+    def update(self, new_data: pd.DataFrame, forecaster: Any) -> pd.DataFrame:
+        if self._history is None:
+            raise ValueError("Engine not initialized. Call initialize() first.")
+
+        self._history = pd.concat([self._history, new_data], ignore_index=True)
+
+        if self._window_size and len(self._history) > self._window_size:
+            self._history = self._history.tail(self._window_size).reset_index(drop=True)
+
+        if hasattr(forecaster, "update"):
+            try:
+                forecaster.update(new_data)
+                logger.info(
+                    f"Incremental update #{self._update_count + 1}: "
+                    f"{len(new_data)} new observations"
+                )
+            except NotImplementedError:
+                logger.info("Model does not support incremental update, refitting on window")
+                forecaster.fit(self._history)
+        else:
+            forecaster.fit(self._history)
+
+        self._update_count += 1
+        return self._history
+
+    def get_training_data(self) -> pd.DataFrame:
+        if self._history is None:
+            raise ValueError("Engine not initialized.")
+        return self._history.copy()