deltafq 0.4.0__py3-none-any.whl

deltafq/live/monitoring.py

@@ -0,0 +1,191 @@
+"""
+Trading monitoring and alerts for live trading.
+"""
+
+import pandas as pd
+from typing import Dict, List, Any, Optional, Callable
+from datetime import datetime, timedelta
+from ..core.base import BaseComponent
+
+
+class TradingMonitor(BaseComponent):
+    """Monitor trading activities and generate alerts."""
+    
+    def __init__(self, **kwargs):
+        """Initialize trading monitor."""
+        super().__init__(**kwargs)
+        self.alerts = []
+        self.monitoring_rules = {}
+        self.alert_callbacks = []
+        self.monitoring_active = False
+    
+    def initialize(self) -> bool:
+        """Initialize trading monitor."""
+        self.logger.info("Initializing trading monitor")
+        return True
+    
+    def add_monitoring_rule(self, rule_name: str, rule_func: Callable, 
+                           threshold: float = None, **kwargs) -> bool:
+        """Add a monitoring rule."""
+        try:
+            self.monitoring_rules[rule_name] = {
+                'function': rule_func,
+                'threshold': threshold,
+                'parameters': kwargs,
+                'active': True,
+                'last_triggered': None
+            }
+            
+            self.logger.info(f"Added monitoring rule: {rule_name}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to add monitoring rule: {str(e)}")
+            return False
+    
+    def add_alert_callback(self, callback: Callable) -> bool:
+        """Add alert callback function."""
+        self.alert_callbacks.append(callback)
+        return True
+    
+    def start_monitoring(self) -> bool:
+        """Start monitoring."""
+        try:
+            self.monitoring_active = True
+            self.logger.info("Trading monitoring started")
+            
+            # In a real implementation, this would start a monitoring loop
+            # For now, we'll provide the framework
+            
+            return True
+            
+        except Exception as e:
+            self.monitoring_active = False
+            self.logger.error(f"Failed to start monitoring: {str(e)}")
+            return False
+    
+    def stop_monitoring(self) -> bool:
+        """Stop monitoring."""
+        try:
+            self.monitoring_active = False
+            self.logger.info("Trading monitoring stopped")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to stop monitoring: {str(e)}")
+            return False
+    
+    def check_rule(self, rule_name: str, data: Dict[str, Any]) -> bool:
+        """Check a specific monitoring rule."""
+        if rule_name not in self.monitoring_rules:
+            return False
+        
+        rule = self.monitoring_rules[rule_name]
+        if not rule['active']:
+            return False
+        
+        try:
+            # Execute the rule function
+            result = rule['function'](data, rule['threshold'], **rule['parameters'])
+            
+            # Check if rule was triggered
+            if result:
+                self._trigger_alert(rule_name, data, result)
+                rule['last_triggered'] = datetime.now()
+                return True
+            
+            return False
+            
+        except Exception as e:
+            self.logger.error(f"Rule check failed for {rule_name}: {str(e)}")
+            return False
+    
+    def check_all_rules(self, data: Dict[str, Any]) -> Dict[str, bool]:
+        """Check all active monitoring rules."""
+        results = {}
+        
+        for rule_name in self.monitoring_rules:
+            if self.monitoring_rules[rule_name]['active']:
+                results[rule_name] = self.check_rule(rule_name, data)
+        
+        return results
+    
+    def _trigger_alert(self, rule_name: str, data: Dict[str, Any], result: Any):
+        """Trigger an alert."""
+        alert = {
+            'rule_name': rule_name,
+            'timestamp': datetime.now(),
+            'data': data,
+            'result': result,
+            'severity': self._determine_severity(rule_name, result)
+        }
+        
+        self.alerts.append(alert)
+        self.logger.warning(f"Alert triggered: {rule_name}")
+        
+        # Notify alert callbacks
+        for callback in self.alert_callbacks:
+            try:
+                callback(alert)
+            except Exception as e:
+                self.logger.error(f"Alert callback failed: {str(e)}")
+    
+    def _determine_severity(self, rule_name: str, result: Any) -> str:
+        """Determine alert severity."""
+        # Simple severity determination based on rule name
+        if 'loss' in rule_name.lower() or 'drawdown' in rule_name.lower():
+            return 'HIGH'
+        elif 'position' in rule_name.lower() or 'concentration' in rule_name.lower():
+            return 'MEDIUM'
+        else:
+            return 'LOW'
+    
+    def get_alerts(self, hours: int = 24) -> List[Dict[str, Any]]:
+        """Get alerts from the last N hours."""
+        cutoff_time = datetime.now() - timedelta(hours=hours)
+        return [alert for alert in self.alerts if alert['timestamp'] > cutoff_time]
+    
+    def clear_alerts(self, hours: int = None) -> int:
+        """Clear old alerts."""
+        if hours is None:
+            # Clear all alerts
+            count = len(self.alerts)
+            self.alerts.clear()
+        else:
+            # Clear alerts older than specified hours
+            cutoff_time = datetime.now() - timedelta(hours=hours)
+            original_count = len(self.alerts)
+            self.alerts = [alert for alert in self.alerts if alert['timestamp'] > cutoff_time]
+            count = original_count - len(self.alerts)
+        
+        self.logger.info(f"Cleared {count} alerts")
+        return count
+    
+    def enable_rule(self, rule_name: str) -> bool:
+        """Enable a monitoring rule."""
+        if rule_name in self.monitoring_rules:
+            self.monitoring_rules[rule_name]['active'] = True
+            return True
+        return False
+    
+    def disable_rule(self, rule_name: str) -> bool:
+        """Disable a monitoring rule."""
+        if rule_name in self.monitoring_rules:
+            self.monitoring_rules[rule_name]['active'] = False
+            return True
+        return False
+    
+    def get_monitoring_status(self) -> Dict[str, Any]:
+        """Get monitoring status."""
+        return {
+            'monitoring_active': self.monitoring_active,
+            'total_rules': len(self.monitoring_rules),
+            'active_rules': sum(1 for rule in self.monitoring_rules.values() if rule['active']),
+            'total_alerts': len(self.alerts),
+            'recent_alerts': len(self.get_alerts(hours=1)),
+            'rules': {name: {
+                'active': rule['active'],
+                'last_triggered': rule['last_triggered']
+            } for name, rule in self.monitoring_rules.items()}
+        }
+

deltafq/live/risk_control.py

@@ -0,0 +1,192 @@
+"""
+Real-time risk control for live trading.
+"""
+
+from typing import Dict, Any, Optional, List
+from datetime import datetime, timedelta
+from ..core.base import BaseComponent
+from ..core.exceptions import TradingError
+
+
+class LiveRiskControl(BaseComponent):
+    """Real-time risk control system."""
+    
+    def __init__(self, max_position_size: float = 0.1, max_daily_loss: float = 0.05, 
+                 max_drawdown: float = 0.15, **kwargs):
+        """Initialize risk control."""
+        super().__init__(**kwargs)
+        self.max_position_size = max_position_size
+        self.max_daily_loss = max_daily_loss
+        self.max_drawdown = max_drawdown
+        self.daily_pnl = 0.0
+        self.peak_equity = 0.0
+        self.risk_limits = {}
+        self.alert_callbacks = []
+    
+    def initialize(self) -> bool:
+        """Initialize risk control."""
+        self.logger.info("Initializing live risk control")
+        return True
+    
+    def add_alert_callback(self, callback) -> bool:
+        """Add alert callback function."""
+        self.alert_callbacks.append(callback)
+        return True
+    
+    def check_position_risk(self, symbol: str, quantity: float, portfolio_value: float, 
+                           current_price: float) -> bool:
+        """Check if position size is within risk limits."""
+        try:
+            position_value = abs(quantity) * current_price
+            position_ratio = position_value / portfolio_value
+            
+            # Check maximum position size
+            if position_ratio > self.max_position_size:
+                self._trigger_alert("POSITION_SIZE_EXCEEDED", {
+                    'symbol': symbol,
+                    'position_ratio': position_ratio,
+                    'max_allowed': self.max_position_size
+                })
+                return False
+            
+            # Check symbol-specific limits
+            if symbol in self.risk_limits:
+                symbol_limit = self.risk_limits[symbol]
+                if position_ratio > symbol_limit:
+                    self._trigger_alert("SYMBOL_LIMIT_EXCEEDED", {
+                        'symbol': symbol,
+                        'position_ratio': position_ratio,
+                        'symbol_limit': symbol_limit
+                    })
+                    return False
+            
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Risk check failed: {str(e)}")
+            return False
+    
+    def check_daily_loss_limit(self, current_equity: float, initial_equity: float) -> bool:
+        """Check if daily loss limit is exceeded."""
+        try:
+            daily_pnl = current_equity - initial_equity
+            daily_pnl_ratio = daily_pnl / initial_equity
+            
+            if daily_pnl_ratio < -self.max_daily_loss:
+                self._trigger_alert("DAILY_LOSS_LIMIT_EXCEEDED", {
+                    'daily_pnl': daily_pnl,
+                    'daily_pnl_ratio': daily_pnl_ratio,
+                    'max_daily_loss': self.max_daily_loss
+                })
+                return False
+            
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Daily loss check failed: {str(e)}")
+            return False
+    
+    def check_drawdown_limit(self, current_equity: float) -> bool:
+        """Check if maximum drawdown is exceeded."""
+        try:
+            if current_equity > self.peak_equity:
+                self.peak_equity = current_equity
+            
+            if self.peak_equity > 0:
+                drawdown = (self.peak_equity - current_equity) / self.peak_equity
+                
+                if drawdown > self.max_drawdown:
+                    self._trigger_alert("DRAWDOWN_LIMIT_EXCEEDED", {
+                        'current_drawdown': drawdown,
+                        'max_drawdown': self.max_drawdown,
+                        'peak_equity': self.peak_equity,
+                        'current_equity': current_equity
+                    })
+                    return False
+            
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Drawdown check failed: {str(e)}")
+            return False
+    
+    def check_concentration_risk(self, positions: Dict[str, float], portfolio_value: float) -> bool:
+        """Check portfolio concentration risk."""
+        try:
+            total_position_value = sum(abs(value) for value in positions.values())
+            
+            if total_position_value > portfolio_value * 0.95:  # 95% of portfolio
+                self._trigger_alert("CONCENTRATION_RISK_HIGH", {
+                    'total_position_value': total_position_value,
+                    'portfolio_value': portfolio_value,
+                    'concentration_ratio': total_position_value / portfolio_value
+                })
+                return False
+            
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Concentration risk check failed: {str(e)}")
+            return False
+    
+    def set_symbol_limit(self, symbol: str, limit: float) -> bool:
+        """Set position size limit for specific symbol."""
+        try:
+            self.risk_limits[symbol] = limit
+            self.logger.info(f"Set risk limit for {symbol}: {limit:.2%}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to set symbol limit: {str(e)}")
+            return False
+    
+    def comprehensive_risk_check(self, symbol: str, quantity: float, portfolio_value: float, 
+                               current_price: float, current_equity: float, 
+                               initial_equity: float, positions: Dict[str, float]) -> Dict[str, bool]:
+        """Perform comprehensive risk checks."""
+        results = {
+            'position_risk': self.check_position_risk(symbol, quantity, portfolio_value, current_price),
+            'daily_loss': self.check_daily_loss_limit(current_equity, initial_equity),
+            'drawdown': self.check_drawdown_limit(current_equity),
+            'concentration': self.check_concentration_risk(positions, portfolio_value)
+        }
+        
+        # Overall risk check passes only if all individual checks pass
+        results['overall'] = all(results.values())
+        
+        return results
+    
+    def _trigger_alert(self, alert_type: str, details: Dict[str, Any]):
+        """Trigger risk alert."""
+        alert = {
+            'type': alert_type,
+            'timestamp': datetime.now(),
+            'details': details
+        }
+        
+        self.logger.warning(f"Risk alert: {alert_type}")
+        
+        # Notify alert callbacks
+        for callback in self.alert_callbacks:
+            try:
+                callback(alert)
+            except Exception as e:
+                self.logger.error(f"Alert callback failed: {str(e)}")
+    
+    def reset_daily_limits(self):
+        """Reset daily risk limits (call at start of trading day)."""
+        self.daily_pnl = 0.0
+        self.logger.info("Daily risk limits reset")
+    
+    def get_risk_status(self) -> Dict[str, Any]:
+        """Get current risk status."""
+        return {
+            'max_position_size': self.max_position_size,
+            'max_daily_loss': self.max_daily_loss,
+            'max_drawdown': self.max_drawdown,
+            'current_daily_pnl': self.daily_pnl,
+            'peak_equity': self.peak_equity,
+            'symbol_limits': dict(self.risk_limits),
+            'active_alerts': len(self.alert_callbacks)
+        }
+

deltafq/strategy/__init__.py

@@ -0,0 +1,12 @@
+"""
+Strategy module for DeltaFQ.
+"""
+
+from .base import BaseStrategy
+from .signals import SignalGenerator
+
+__all__ = [
+    "BaseStrategy",
+    "SignalGenerator"
+]
+

deltafq/strategy/base.py

@@ -0,0 +1,34 @@
+"""Common utilities for simple trading strategies."""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+
+import pandas as pd
+
+from ..core.base import BaseComponent
+from ..core.exceptions import StrategyError
+
+
+class BaseStrategy(BaseComponent, ABC):
+    """Minimal base class: fetch signals from `generate_signals` and return them."""
+
+    def __init__(self, name: str | None = None, **kwargs: Any) -> None:
+        super().__init__(name=name, **kwargs)
+        self.signals: pd.DataFrame = pd.DataFrame()
+
+    def initialize(self) -> bool:
+        self.logger.info("Initializing strategy: %s", self.name)
+        return True
+
+    @abstractmethod
+    def generate_signals(self, data: pd.DataFrame) -> pd.DataFrame:
+        """Return a `DataFrame` containing strategy signals."""
+
+    def run(self, data: pd.DataFrame) -> Dict[str, Any]:
+        self.logger.info("Running strategy: %s", self.name)
+        try:
+            self.signals = self.generate_signals(data)
+            return {"strategy_name": self.name, "signals": self.signals}
+        except Exception as exc:  # pragma: no cover - thin wrapper
+            raise StrategyError(f"Strategy execution failed: {exc}") from exc
+

deltafq/strategy/signals.py

@@ -0,0 +1,193 @@
+"""Essential signal generation and combination utilities."""
+
+import pandas as pd
+import numpy as np
+from typing import Dict, Any, Optional
+from ..core.base import BaseComponent
+
+
+class SignalGenerator(BaseComponent):
+    """Generate trading signals from precomputed indicators and combine them."""
+    
+    def initialize(self) -> bool:
+        """Initialize signal generator."""
+        self.logger.info("Initializing signal generator")
+        return True
+
+    def _log_signal_counts(self, label: str, series: pd.Series) -> None:
+        """Log the number of buy, sell, and flat signals."""
+        buy = int((series == 1).sum())
+        sell = int((series == -1).sum())
+        flat = int((series == 0).sum())
+        self.logger.info(f"{label} signals -> buy={buy}, sell={sell}, flat={flat}")
+        
+    # --- SMA -----------------------------------------------------------------
+    def sma_signals(self, fast_ma: pd.Series, slow_ma: pd.Series) -> pd.Series:
+        """Bullish when the fast MA is above the slow MA, bearish when below."""
+        if not fast_ma.index.equals(slow_ma.index):
+            slow_ma = slow_ma.reindex(fast_ma.index)
+        signals = pd.Series(
+            np.where(fast_ma > slow_ma, 1, np.where(fast_ma < slow_ma, -1, 0)),
+            index=fast_ma.index,
+            dtype=int,
+        )
+        self._log_signal_counts("SMA crossover", signals)
+        return signals
+
+    def ma_signals(self, fast_ma: pd.Series, slow_ma: pd.Series) -> pd.Series:
+        """Alias for backwards compatibility."""
+        return self.sma_signals(fast_ma, slow_ma)
+
+    # --- EMA -----------------------------------------------------------------
+    def ema_signals(self, price: pd.Series, ema: pd.Series) -> pd.Series:
+        """Bullish when price sits above the EMA, bearish when it falls below."""
+        if not price.index.equals(ema.index):
+            ema = ema.reindex(price.index)
+        signals = pd.Series(
+            np.where(price > ema, 1, np.where(price < ema, -1, 0)),
+            index=price.index,
+            dtype=int,
+        )
+        self._log_signal_counts("EMA price-vs-ema", signals)
+        return signals
+
+    # --- RSI -----------------------------------------------------------------
+    def rsi_signals(self, rsi: pd.Series, oversold: float = 30, overbought: float = 70) -> pd.Series:
+        """Buy when RSI drops beneath the oversold band, sell when above overbought."""
+        signals = pd.Series(
+            np.where(rsi < oversold, 1, np.where(rsi > overbought, -1, 0)),
+            index=rsi.index,
+            dtype=int,
+        )
+        self._log_signal_counts("RSI", signals)
+        return signals
+
+    # --- KDJ -----------------------------------------------------------------
+    def kdj_signals(self, kdj: pd.DataFrame) -> pd.Series:
+        """Bullish on K crossing above D, bearish on K crossing beneath D."""
+        for col in ("k", "d"):
+            if col not in kdj:
+                raise ValueError("kdj must contain 'k' and 'd' columns")
+        signals = pd.Series(
+            np.where(kdj["k"] > kdj["d"], 1, np.where(kdj["k"] < kdj["d"], -1, 0)),
+            index=kdj.index,
+            dtype=int,
+        )
+        self._log_signal_counts("KDJ K>D", signals)
+        return signals
+
+    # --- BOLL ----------------------------------------------------------------
+    def boll_signals(self, price: pd.Series, bands: pd.DataFrame, method: str = "cross") -> pd.Series:
+        """Bollinger logic: touch or cross of the outer bands triggers entries."""
+        if method not in ["touch", "cross", "cross_current"]:
+            raise ValueError("Invalid method")
+        if not all(col in bands for col in ("upper", "middle", "lower")):
+            raise ValueError("bands missing required columns")
+
+        signals = pd.Series(0, index=price.index, dtype=int)
+
+        if method == "touch":
+            buy_condition = price <= bands["lower"]
+            sell_condition = price >= bands["upper"]
+            signals = np.where(buy_condition, 1, np.where(sell_condition, -1, 0))
+
+        elif method == "cross":
+            prev_price = price.shift(1)
+            prev_bands = bands.shift(1)
+            buy_condition = (prev_price <= prev_bands["lower"]) & (price >= bands["lower"])
+            sell_condition = (prev_price >= prev_bands["upper"]) & (price <= bands["upper"])
+            signals = np.where(buy_condition, 1, np.where(sell_condition, -1, 0))
+
+        elif method == "cross_current":
+            prev_price = price.shift(1)
+            buy_condition = (prev_price <= bands["lower"]) & (price >= bands["lower"])
+            sell_condition = (prev_price >= bands["upper"]) & (price <= bands["upper"])
+            signals = np.where(buy_condition, 1, np.where(sell_condition, -1, 0))
+
+        series = pd.Series(signals, index=price.index, dtype=int)
+        self._log_signal_counts(f"Boll ({method})", series)
+        return series
+
+    # --- OBV -----------------------------------------------------------------
+    def obv_signals(self, obv: pd.Series) -> pd.Series:
+        """Positive OBV slope hints at buying pressure; negative slope at selling."""
+        obv_change = obv.diff().fillna(0)
+        signals = pd.Series(
+            np.where(obv_change > 0, 1, np.where(obv_change < 0, -1, 0)),
+            index=obv.index,
+            dtype=int,
+        )
+        self._log_signal_counts("OBV slope", signals)
+        return signals
+    
+    def combine_signals(
+        self,
+        signals_dict: Dict[str, pd.Series],
+        method: str = 'vote',
+        weights: Optional[Dict[str, float]] = None,
+        threshold: float = 0.5
+    ) -> pd.Series:
+        """Combine multiple {-1,0,1} Series using 'vote' | 'weighted' | 'threshold'."""
+        if not signals_dict:
+            raise ValueError("signals_dict cannot be empty")
+        
+        signal_names = list(signals_dict.keys())
+        first_signal = signals_dict[signal_names[0]]
+        index = first_signal.index
+        
+        for name, signal in signals_dict.items():
+            if len(signal) != len(first_signal):
+                raise ValueError(f"Signal '{name}' has different length")
+            if not signal.index.equals(index):
+                signals_dict[name] = signal.reindex(index)
+                self.logger.info(f"Aligned signal '{name}' index")
+        
+        signals_df = pd.DataFrame(signals_dict)
+        
+        if method == 'vote':
+            buy_votes = (signals_df == 1).sum(axis=1)
+            sell_votes = (signals_df == -1).sum(axis=1)
+            combined = pd.Series(0, index=index, dtype=int)
+            combined = np.where(buy_votes > sell_votes, 1, combined)
+            combined = np.where(sell_votes > buy_votes, -1, combined)
+            
+        elif method == 'weighted':
+            if weights is None:
+                weights = {name: 1.0 / len(signals_dict) for name in signal_names}
+            else:
+                total_weight = sum(weights.values())
+                if total_weight == 0:
+                    raise ValueError("Total weight cannot be zero")
+                weights = {k: v / total_weight for k, v in weights.items()}
+            
+            weighted_sum = pd.Series(0.0, index=index)
+            for name in signal_names:
+                weighted_sum += signals_df[name] * weights.get(name, 0)
+            
+            combined = pd.Series(0, index=index, dtype=int)
+            combined = np.where(weighted_sum > 0.33, 1, combined)
+            combined = np.where(weighted_sum < -0.33, -1, combined)
+            
+        elif method == 'threshold':
+            if weights is None:
+                weights = {name: 1.0 / len(signals_dict) for name in signal_names}
+            else:
+                total_weight = sum(weights.values())
+                if total_weight == 0:
+                    raise ValueError("Total weight cannot be zero")
+                weights = {k: v / total_weight for k, v in weights.items()}
+            
+            weighted_sum = pd.Series(0.0, index=index)
+            for name in signal_names:
+                weighted_sum += signals_df[name] * weights.get(name, 0)
+            
+            combined = pd.Series(0, index=index, dtype=int)
+            combined = np.where(weighted_sum >= threshold, 1, combined)
+            combined = np.where(weighted_sum <= -threshold, -1, combined)
+            
+        else:
+            raise ValueError("Invalid method")
+        
+        combined_series = pd.Series(combined, index=index, dtype=int)
+        self._log_signal_counts(f"Combined ({method})", combined_series)
+        return combined_series

deltafq/trader/__init__.py

@@ -0,0 +1,16 @@
+"""
+Trader module for DeltaFQ.
+"""
+
+from .broker import Broker
+from .order_manager import OrderManager
+from .position_manager import PositionManager
+from .engine import ExecutionEngine
+
+__all__ = [
+    "Broker",
+    "OrderManager",
+    "PositionManager",
+    "ExecutionEngine"
+]
+