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

deltafq/indicators/volatility.py

@@ -1,27 +1,67 @@
-"""波动率类指标"""
-
-import pandas as pd
-
-
-def BOLL(data: pd.Series, period: int = 20, std_dev: float = 2.0) -> pd.DataFrame:
-    """布林带
-    
-    Args:
-        data: 价格序列
-        period: 周期
-        std_dev: 标准差倍数
-        
-    Returns:
-        包含upper、middle、lower的DataFrame
-    """
-    middle = data.rolling(window=period).mean()
-    std = data.rolling(window=period).std()
-    upper = middle + std_dev * std
-    lower = middle - std_dev * std
-    
-    return pd.DataFrame({
-        'upper': upper,
-        'middle': middle,
-        'lower': lower
-    })
-
+"""
+Volatility indicators for DeltaFQ.
+"""
+
+import pandas as pd
+import numpy as np
+from ..core.base import BaseComponent
+
+
+class VolatilityIndicators(BaseComponent):
+    """Volatility-based technical indicators."""
+    
+    def initialize(self) -> bool:
+        """Initialize volatility indicators."""
+        self.logger.info("Initializing volatility indicators")
+        return True
+    
+    def atr(self, high: pd.Series, low: pd.Series, close: pd.Series, period: int = 14) -> pd.Series:
+        """Average True Range."""
+        # True Range
+        tr1 = high - low
+        tr2 = abs(high - close.shift())
+        tr3 = abs(low - close.shift())
+        tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
+        
+        # Average True Range
+        return tr.rolling(window=period).mean()
+    
+    def bollinger_bandwidth(self, data: pd.Series, period: int = 20, std_dev: float = 2) -> pd.Series:
+        """Bollinger Band Width."""
+        sma = data.rolling(window=period).mean()
+        std = data.rolling(window=period).std()
+        
+        upper_band = sma + (std * std_dev)
+        lower_band = sma - (std * std_dev)
+        
+        return (upper_band - lower_band) / sma
+    
+    def keltner_channels(self, high: pd.Series, low: pd.Series, close: pd.Series, 
+                        period: int = 20, multiplier: float = 2) -> pd.DataFrame:
+        """Keltner Channels."""
+        typical_price = (high + low + close) / 3
+        middle_line = typical_price.rolling(window=period).mean()
+        atr = self.atr(high, low, close, period)
+        
+        return pd.DataFrame({
+            'upper': middle_line + (multiplier * atr),
+            'middle': middle_line,
+            'lower': middle_line - (multiplier * atr)
+        })
+    
+    def donchian_channels(self, high: pd.Series, low: pd.Series, period: int = 20) -> pd.DataFrame:
+        """Donchian Channels."""
+        return pd.DataFrame({
+            'upper': high.rolling(window=period).max(),
+            'lower': low.rolling(window=period).min(),
+            'middle': (high.rolling(window=period).max() + low.rolling(window=period).min()) / 2
+        })
+    
+    def volatility_ratio(self, data: pd.Series, short_period: int = 10, long_period: int = 30) -> pd.Series:
+        """Volatility Ratio."""
+        short_vol = data.rolling(window=short_period).std()
+        long_vol = data.rolling(window=long_period).std()
+        
+        return short_vol / long_vol
+
+

deltafq/live/__init__.py

@@ -0,0 +1,17 @@
+"""
+Live trading module for DeltaFQ.
+"""
+
+from .data_feed import LiveDataFeed
+from .risk_control import LiveRiskControl
+from .monitoring import TradingMonitor
+from .connection import ConnectionManager
+
+__all__ = [
+    "LiveDataFeed",
+    "LiveRiskControl",
+    "TradingMonitor",
+    "ConnectionManager"
+]
+
+

deltafq/live/connection.py

@@ -0,0 +1,235 @@
+"""
+Connection management 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 ConnectionManager(BaseComponent):
+    """Manage connections to trading systems."""
+    
+    def __init__(self, **kwargs):
+        """Initialize connection manager."""
+        super().__init__(**kwargs)
+        self.connections = {}
+        self.connection_configs = {}
+        self.health_check_interval = 60  # seconds
+        self.last_health_check = {}
+    
+    def initialize(self) -> bool:
+        """Initialize connection manager."""
+        self.logger.info("Initializing connection manager")
+        return True
+    
+    def add_connection(self, name: str, connection_type: str, config: Dict[str, Any]) -> bool:
+        """Add a connection configuration."""
+        try:
+            self.connection_configs[name] = {
+                'type': connection_type,
+                'config': config,
+                'created_at': datetime.now(),
+                'last_used': None,
+                'status': 'disconnected'
+            }
+            
+            self.logger.info(f"Added connection: {name} ({connection_type})")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to add connection: {str(e)}")
+            return False
+    
+    def connect(self, name: str) -> bool:
+        """Establish connection."""
+        try:
+            if name not in self.connection_configs:
+                raise TradingError(f"Connection {name} not found")
+            
+            config = self.connection_configs[name]
+            connection_type = config['type']
+            
+            # Create connection based on type
+            if connection_type == 'broker':
+                connection = self._create_broker_connection(config['config'])
+            elif connection == 'data_feed':
+                connection = self._create_data_feed_connection(config['config'])
+            else:
+                raise TradingError(f"Unknown connection type: {connection_type}")
+            
+            # Test connection
+            if self._test_connection(connection):
+                self.connections[name] = connection
+                self.connection_configs[name]['status'] = 'connected'
+                self.connection_configs[name]['last_used'] = datetime.now()
+                self.last_health_check[name] = datetime.now()
+                
+                self.logger.info(f"Connected: {name}")
+                return True
+            else:
+                self.logger.error(f"Connection test failed: {name}")
+                return False
+                
+        except Exception as e:
+            self.logger.error(f"Failed to connect {name}: {str(e)}")
+            return False
+    
+    def disconnect(self, name: str) -> bool:
+        """Disconnect from service."""
+        try:
+            if name in self.connections:
+                # Close connection
+                connection = self.connections[name]
+                if hasattr(connection, 'close'):
+                    connection.close()
+                
+                del self.connections[name]
+                self.connection_configs[name]['status'] = 'disconnected'
+                
+                self.logger.info(f"Disconnected: {name}")
+                return True
+            
+            return False
+            
+        except Exception as e:
+            self.logger.error(f"Failed to disconnect {name}: {str(e)}")
+            return False
+    
+    def get_connection(self, name: str):
+        """Get connection object."""
+        return self.connections.get(name)
+    
+    def is_connected(self, name: str) -> bool:
+        """Check if connection is active."""
+        return name in self.connections and self.connection_configs.get(name, {}).get('status') == 'connected'
+    
+    def health_check(self, name: str) -> bool:
+        """Perform health check on connection."""
+        try:
+            if name not in self.connections:
+                return False
+            
+            connection = self.connections[name]
+            
+            # Perform health check based on connection type
+            if hasattr(connection, 'ping'):
+                result = connection.ping()
+            elif hasattr(connection, 'is_connected'):
+                result = connection.is_connected()
+            else:
+                # Default health check
+                result = True
+            
+            # Update last health check time
+            self.last_health_check[name] = datetime.now()
+            
+            if not result:
+                self.logger.warning(f"Health check failed: {name}")
+                self.connection_configs[name]['status'] = 'unhealthy'
+            else:
+                self.connection_configs[name]['status'] = 'connected'
+            
+            return result
+            
+        except Exception as e:
+            self.logger.error(f"Health check error for {name}: {str(e)}")
+            self.connection_configs[name]['status'] = 'error'
+            return False
+    
+    def health_check_all(self) -> Dict[str, bool]:
+        """Perform health check on all connections."""
+        results = {}
+        
+        for name in self.connections:
+            results[name] = self.health_check(name)
+        
+        return results
+    
+    def auto_reconnect(self, name: str, max_attempts: int = 3) -> bool:
+        """Attempt to automatically reconnect."""
+        try:
+            if name not in self.connection_configs:
+                return False
+            
+            for attempt in range(max_attempts):
+                self.logger.info(f"Reconnection attempt {attempt + 1} for {name}")
+                
+                if self.connect(name):
+                    self.logger.info(f"Successfully reconnected: {name}")
+                    return True
+                
+                # Wait before next attempt
+                import time
+                time.sleep(5)
+            
+            self.logger.error(f"Failed to reconnect {name} after {max_attempts} attempts")
+            return False
+            
+        except Exception as e:
+            self.logger.error(f"Auto-reconnect failed for {name}: {str(e)}")
+            return False
+    
+    def _create_broker_connection(self, config: Dict[str, Any]):
+        """Create broker connection."""
+        # Placeholder for broker connection creation
+        return MockConnection('broker', config)
+    
+    def _create_data_feed_connection(self, config: Dict[str, Any]):
+        """Create data feed connection."""
+        # Placeholder for data feed connection creation
+        return MockConnection('data_feed', config)
+    
+    def _test_connection(self, connection) -> bool:
+        """Test connection."""
+        try:
+            # Simple connection test
+            if hasattr(connection, 'test'):
+                return connection.test()
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Connection test failed: {str(e)}")
+            return False
+    
+    def get_connection_status(self) -> Dict[str, Any]:
+        """Get status of all connections."""
+        return {
+            'total_connections': len(self.connection_configs),
+            'active_connections': len(self.connections),
+            'connections': {
+                name: {
+                    'type': config['type'],
+                    'status': config['status'],
+                    'last_used': config['last_used'],
+                    'last_health_check': self.last_health_check.get(name)
+                }
+                for name, config in self.connection_configs.items()
+            }
+        }
+
+
+class MockConnection:
+    """Mock connection for testing."""
+    
+    def __init__(self, connection_type: str, config: Dict[str, Any]):
+        self.connection_type = connection_type
+        self.config = config
+        self.connected = True
+    
+    def test(self) -> bool:
+        """Test connection."""
+        return True
+    
+    def ping(self) -> bool:
+        """Ping connection."""
+        return True
+    
+    def is_connected(self) -> bool:
+        """Check if connected."""
+        return self.connected
+    
+    def close(self):
+        """Close connection."""
+        self.connected = False

deltafq/live/data_feed.py

@@ -0,0 +1,159 @@
+"""
+Live data feed management for real-time trading.
+"""
+
+import pandas as pd
+from typing import Dict, List, Callable, Optional, Any
+from datetime import datetime
+from ..core.base import BaseComponent
+from ..core.exceptions import TradingError
+
+
+class LiveDataFeed(BaseComponent):
+    """Manages real-time market data feeds."""
+    
+    def __init__(self, **kwargs):
+        """Initialize live data feed."""
+        super().__init__(**kwargs)
+        self.subscribers = {}
+        self.data_callbacks = []
+        self.is_running = False
+        self.last_prices = {}
+    
+    def initialize(self) -> bool:
+        """Initialize live data feed."""
+        self.logger.info("Initializing live data feed")
+        return True
+    
+    def subscribe(self, symbols: List[str], callback: Optional[Callable] = None) -> bool:
+        """Subscribe to live data for given symbols."""
+        try:
+            for symbol in symbols:
+                if symbol not in self.subscribers:
+                    self.subscribers[symbol] = []
+                
+                if callback:
+                    self.subscribers[symbol].append(callback)
+                
+                self.logger.info(f"Subscribed to {symbol}")
+            
+            return True
+            
+        except Exception as e:
+            raise TradingError(f"Failed to subscribe to symbols: {str(e)}")
+    
+    def unsubscribe(self, symbols: List[str]) -> bool:
+        """Unsubscribe from live data."""
+        try:
+            for symbol in symbols:
+                if symbol in self.subscribers:
+                    del self.subscribers[symbol]
+                    self.logger.info(f"Unsubscribed from {symbol}")
+            
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to unsubscribe: {str(e)}")
+            return False
+    
+    def add_data_callback(self, callback: Callable) -> bool:
+        """Add a general data callback."""
+        self.data_callbacks.append(callback)
+        return True
+    
+    def start_feed(self) -> bool:
+        """Start the live data feed."""
+        try:
+            self.is_running = True
+            self.logger.info("Live data feed started")
+            
+            # In a real implementation, this would start the actual data feed
+            # For now, we'll simulate with periodic updates
+            self._simulate_data_feed()
+            
+            return True
+            
+        except Exception as e:
+            self.is_running = False
+            raise TradingError(f"Failed to start data feed: {str(e)}")
+    
+    def stop_feed(self) -> bool:
+        """Stop the live data feed."""
+        try:
+            self.is_running = False
+            self.logger.info("Live data feed stopped")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to stop data feed: {str(e)}")
+            return False
+    
+    def get_latest_price(self, symbol: str) -> Optional[float]:
+        """Get latest price for a symbol."""
+        return self.last_prices.get(symbol)
+    
+    def get_latest_prices(self, symbols: List[str]) -> Dict[str, float]:
+        """Get latest prices for multiple symbols."""
+        return {symbol: self.last_prices.get(symbol) for symbol in symbols if symbol in self.last_prices}
+    
+    def _simulate_data_feed(self):
+        """Simulate live data feed for testing."""
+        import time
+        import random
+        
+        base_prices = {
+            'AAPL': 150.0,
+            'GOOGL': 2500.0,
+            'MSFT': 300.0,
+            'TSLA': 200.0
+        }
+        
+        while self.is_running:
+            for symbol in self.subscribers.keys():
+                if symbol in base_prices:
+                    # Simulate price movement
+                    current_price = self.last_prices.get(symbol, base_prices[symbol])
+                    change = random.uniform(-0.02, 0.02)  # ±2% change
+                    new_price = current_price * (1 + change)
+                    
+                    self.last_prices[symbol] = new_price
+                    
+                    # Create data point
+                    data_point = {
+                        'symbol': symbol,
+                        'price': new_price,
+                        'timestamp': datetime.now(),
+                        'volume': random.randint(1000, 10000)
+                    }
+                    
+                    # Notify subscribers
+                    self._notify_subscribers(symbol, data_point)
+            
+            time.sleep(1)  # Update every second
+    
+    def _notify_subscribers(self, symbol: str, data_point: Dict[str, Any]):
+        """Notify subscribers of new data."""
+        try:
+            # Notify symbol-specific subscribers
+            if symbol in self.subscribers:
+                for callback in self.subscribers[symbol]:
+                    callback(data_point)
+            
+            # Notify general data callbacks
+            for callback in self.data_callbacks:
+                callback(data_point)
+                
+        except Exception as e:
+            self.logger.error(f"Error notifying subscribers: {str(e)}")
+    
+    def get_feed_status(self) -> Dict[str, Any]:
+        """Get feed status information."""
+        return {
+            'is_running': self.is_running,
+            'subscribed_symbols': list(self.subscribers.keys()),
+            'total_subscribers': sum(len(callbacks) for callbacks in self.subscribers.values()),
+            'data_callbacks': len(self.data_callbacks),
+            'latest_prices': dict(self.last_prices)
+        }
+
+