deltafq 0.1.0__py3-none-any.whl → 0.1.2__py3-none-any.whl

deltafq/live/monitoring.py

@@ -0,0 +1,192 @@
+"""
+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,193 @@
+"""
+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

@@ -1,6 +1,17 @@
-"""策略框架模块"""
-
-from deltafq.strategy.base import Strategy
-
-__all__ = ["Strategy"]
-
+"""
+Strategy module for DeltaFQ.
+"""
+
+from .base_strategy import BaseStrategy
+from .signal_generator import SignalGenerator
+from .portfolio import Portfolio
+from .risk_manager import RiskManager
+
+__all__ = [
+    "BaseStrategy",
+    "SignalGenerator",
+    "Portfolio",
+    "RiskManager"
+]
+
+

deltafq/strategy/base_strategy.py

@@ -0,0 +1,53 @@
+"""
+Base strategy class for DeltaFQ.
+"""
+
+import pandas as pd
+from abc import ABC, abstractmethod
+from typing import Dict, Any, Optional
+from ..core.base import BaseComponent
+from ..core.exceptions import StrategyError
+
+
+class BaseStrategy(BaseComponent):
+    """Base class for all trading strategies."""
+    
+    def __init__(self, name: str = None, **kwargs):
+        """Initialize base strategy."""
+        super().__init__(name=name, **kwargs)
+        self.signals = pd.DataFrame()
+        self.positions = pd.DataFrame()
+    
+    def initialize(self) -> bool:
+        """Initialize the strategy."""
+        self.logger.info(f"Initializing strategy: {self.name}")
+        return True
+    
+    @abstractmethod
+    def generate_signals(self, data: pd.DataFrame) -> pd.DataFrame:
+        """Generate trading signals from market data."""
+        pass
+    
+    def run(self, data: pd.DataFrame) -> Dict[str, Any]:
+        """Run the strategy on given data."""
+        try:
+            self.logger.info(f"Running strategy: {self.name}")
+            signals = self.generate_signals(data)
+            return {
+                "strategy_name": self.name,
+                "signals": signals,
+                "performance": self._calculate_performance(signals, data)
+            }
+        except Exception as e:
+            raise StrategyError(f"Strategy execution failed: {str(e)}")
+    
+    def _calculate_performance(self, signals: pd.DataFrame, data: pd.DataFrame) -> Dict[str, float]:
+        """Calculate basic performance metrics."""
+        # Placeholder implementation
+        return {
+            "total_return": 0.0,
+            "sharpe_ratio": 0.0,
+            "max_drawdown": 0.0
+        }
+
+

deltafq/strategy/portfolio.py

@@ -0,0 +1,82 @@
+"""
+Portfolio management for DeltaFQ.
+"""
+
+import pandas as pd
+from typing import Dict, List, Optional
+from ..core.base import BaseComponent
+
+
+class Portfolio(BaseComponent):
+    """Portfolio management system."""
+    
+    def __init__(self, initial_capital: float = 100000, **kwargs):
+        """Initialize portfolio."""
+        super().__init__(**kwargs)
+        self.initial_capital = initial_capital
+        self.cash = initial_capital
+        self.positions = {}
+        self.trades = []
+    
+    def initialize(self) -> bool:
+        """Initialize portfolio."""
+        self.logger.info(f"Initializing portfolio with capital: {self.initial_capital}")
+        return True
+    
+    def get_position(self, symbol: str) -> float:
+        """Get current position for symbol."""
+        return self.positions.get(symbol, 0.0)
+    
+    def get_portfolio_value(self, prices: Dict[str, float]) -> float:
+        """Calculate total portfolio value."""
+        total_value = self.cash
+        for symbol, quantity in self.positions.items():
+            if symbol in prices:
+                total_value += quantity * prices[symbol]
+        return total_value
+    
+    def execute_trade(self, symbol: str, quantity: int, price: float, commission: float = 0.001):
+        """Execute a trade."""
+        cost = quantity * price * (1 + commission)
+        
+        if quantity > 0:  # Buy
+            if cost <= self.cash:
+                self.cash -= cost
+                self.positions[symbol] = self.positions.get(symbol, 0) + quantity
+                self.trades.append({
+                    'symbol': symbol,
+                    'quantity': quantity,
+                    'price': price,
+                    'type': 'buy',
+                    'timestamp': pd.Timestamp.now()
+                })
+                self.logger.info(f"Bought {quantity} shares of {symbol} at {price}")
+            else:
+                self.logger.warning(f"Insufficient cash for trade: {symbol}")
+        else:  # Sell
+            quantity = abs(quantity)
+            if self.positions.get(symbol, 0) >= quantity:
+                self.cash += quantity * price * (1 - commission)
+                self.positions[symbol] -= quantity
+                self.trades.append({
+                    'symbol': symbol,
+                    'quantity': -quantity,
+                    'price': price,
+                    'type': 'sell',
+                    'timestamp': pd.Timestamp.now()
+                })
+                self.logger.info(f"Sold {quantity} shares of {symbol} at {price}")
+            else:
+                self.logger.warning(f"Insufficient position for trade: {symbol}")
+    
+    def get_portfolio_summary(self, prices: Dict[str, float]) -> Dict[str, float]:
+        """Get portfolio summary."""
+        total_value = self.get_portfolio_value(prices)
+        return {
+            'total_value': total_value,
+            'cash': self.cash,
+            'total_return': (total_value - self.initial_capital) / self.initial_capital,
+            'positions': dict(self.positions)
+        }
+
+

deltafq/strategy/risk_manager.py

@@ -0,0 +1,64 @@
+"""
+Risk management for DeltaFQ.
+"""
+
+from typing import Dict, Any, Optional
+from ..core.base import BaseComponent
+
+
+class RiskManager(BaseComponent):
+    """Risk management system."""
+    
+    def __init__(self, max_position_size: float = 0.1, max_drawdown: float = 0.2, **kwargs):
+        """Initialize risk manager."""
+        super().__init__(**kwargs)
+        self.max_position_size = max_position_size
+        self.max_drawdown = max_drawdown
+        self.peak_value = 0.0
+    
+    def initialize(self) -> bool:
+        """Initialize risk manager."""
+        self.logger.info("Initializing risk manager")
+        return True
+    
+    def check_position_size(self, symbol: str, quantity: float, portfolio_value: float) -> bool:
+        """Check if position size is within limits."""
+        position_value = abs(quantity) * self._get_current_price(symbol)
+        position_ratio = position_value / portfolio_value
+        
+        if position_ratio > self.max_position_size:
+            self.logger.warning(f"Position size exceeds limit: {symbol}")
+            return False
+        return True
+    
+    def check_drawdown(self, current_value: float) -> bool:
+        """Check if drawdown is within limits."""
+        if current_value > self.peak_value:
+            self.peak_value = current_value
+        
+        drawdown = (self.peak_value - current_value) / self.peak_value
+        
+        if drawdown > self.max_drawdown:
+            self.logger.warning(f"Drawdown exceeds limit: {drawdown:.2%}")
+            return False
+        return True
+    
+    def _get_current_price(self, symbol: str) -> float:
+        """Get current price for symbol (placeholder)."""
+        # This would be replaced with actual price fetching
+        return 100.0
+    
+    def get_risk_metrics(self, portfolio_value: float) -> Dict[str, float]:
+        """Get current risk metrics."""
+        drawdown = 0.0
+        if self.peak_value > 0:
+            drawdown = (self.peak_value - portfolio_value) / self.peak_value
+        
+        return {
+            'current_drawdown': drawdown,
+            'max_drawdown_limit': self.max_drawdown,
+            'peak_value': self.peak_value,
+            'max_position_size': self.max_position_size
+        }
+
+

deltafq/strategy/signal_generator.py

@@ -0,0 +1,52 @@
+"""
+Signal generator for trading strategies.
+"""
+
+import pandas as pd
+import numpy as np
+from typing import Dict, Any
+from ..core.base import BaseComponent
+
+
+class SignalGenerator(BaseComponent):
+    """Generate trading signals from market data."""
+    
+    def initialize(self) -> bool:
+        """Initialize signal generator."""
+        self.logger.info("Initializing signal generator")
+        return True
+    
+    def moving_average_crossover(self, data: pd.DataFrame, fast_period: int = 10, slow_period: int = 20) -> pd.Series:
+        """Generate signals based on moving average crossover."""
+        if 'close' not in data.columns:
+            raise ValueError("Data must contain 'close' column")
+        
+        # Calculate moving averages
+        fast_ma = data['close'].rolling(window=fast_period).mean()
+        slow_ma = data['close'].rolling(window=slow_period).mean()
+        
+        # Generate signals: 1 for buy, -1 for sell, 0 for hold
+        signals = np.where(fast_ma > slow_ma, 1, np.where(fast_ma < slow_ma, -1, 0))
+        
+        self.logger.info(f"Generated MA crossover signals: {fast_period}/{slow_period}")
+        return pd.Series(signals, index=data.index)
+    
+    def rsi_signals(self, data: pd.DataFrame, period: int = 14, oversold: float = 30, overbought: float = 70) -> pd.Series:
+        """Generate signals based on RSI."""
+        if 'close' not in data.columns:
+            raise ValueError("Data must contain 'close' column")
+        
+        # Calculate RSI (simplified)
+        delta = data['close'].diff()
+        gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
+        loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
+        rs = gain / loss
+        rsi = 100 - (100 / (1 + rs))
+        
+        # Generate signals
+        signals = np.where(rsi < oversold, 1, np.where(rsi > overbought, -1, 0))
+        
+        self.logger.info(f"Generated RSI signals: period={period}")
+        return pd.Series(signals, index=data.index)
+
+

deltafq/trading/__init__.py

@@ -0,0 +1,19 @@
+"""
+Trading module for DeltaFQ.
+"""
+
+from .simulator import PaperTradingSimulator
+from .broker import Broker
+from .order_manager import OrderManager
+from .position_manager import PositionManager
+from .execution import ExecutionEngine
+
+__all__ = [
+    "PaperTradingSimulator",
+    "Broker",
+    "OrderManager",
+    "PositionManager",
+    "ExecutionEngine"
+]
+
+