deltafq 0.4.0__py3-none-any.whl

deltafq/indicators/technical.py

@@ -0,0 +1,251 @@
+"""
+Technical indicators for DeltaFQ.
+"""
+
+import pandas as pd
+import numpy as np
+from ..core.base import BaseComponent
+
+
+class TechnicalIndicators(BaseComponent):
+    """Basic technical indicators."""
+    
+    def initialize(self) -> bool:
+        """Initialize technical indicators."""
+        self.logger.info("Initializing technical indicators")
+        return True
+    
+    def sma(self, data: pd.Series, period: int) -> pd.Series:
+        """Calculate Simple Moving Average (SMA)."""
+        self.logger.info(f"Calculating SMA(period={period})")
+        return data.rolling(window=period).mean()
+    
+    def ema(self, data: pd.Series, period: int, method: str = 'pandas') -> pd.Series:
+        """
+        Calculate Exponential Moving Average (EMA).
+        Args:
+            data: Price series
+            period: Period for EMA calculation
+            method: 'pandas' uses pandas ewm (default), 'talib' uses inline calculation matching TA-Lib.
+                   Talib method is more precise but slightly slower.
+        """
+        self.logger.info(f"Calculating EMA(period={period}, method={method})")
+        
+        if method == 'talib':
+            # TA-Lib compatible: seed with SMA of the first full window
+            ema = pd.Series(index=data.index, dtype=float)
+            if len(data) == 0:
+                return ema
+            
+            alpha = 2.0 / (period + 1.0)
+            first_valid_idx = data.first_valid_index()
+            if first_valid_idx is None:
+                return ema
+            
+            first_valid_pos = data.index.get_loc(first_valid_idx)
+            # Require a full window for initial SMA
+            start = first_valid_pos
+            end = start + period  # exclusive
+            if end > len(data):
+                # Not enough data to seed
+                return ema
+            
+            # Attempt to find a clean initial window without NaNs
+            seed_pos = end - 1
+            initial_window = data.iloc[start:end]
+            if initial_window.isna().any():
+                clean_found = False
+                for shift in range(0, len(data) - start - period + 1):
+                    window = data.iloc[start + shift:start + shift + period]
+                    if not window.isna().any():
+                        seed_pos = start + shift + period - 1
+                        initial_window = window
+                        clean_found = True
+                        break
+                if not clean_found:
+                    return ema
+            
+            ema.iloc[seed_pos] = float(initial_window.mean())
+            
+            # Forward recursion from the next bar after seed
+            for i in range(seed_pos + 1, len(data)):
+                x = data.iloc[i]
+                prev = ema.iloc[i - 1]
+                if pd.isna(x):
+                    # Output NaN for this bar but keep previous state for the next step
+                    ema.iloc[i] = np.nan
+                else:
+                    # Use last non-NaN ema value as previous
+                    j = i - 1
+                    while j >= 0 and pd.isna(prev):
+                        j -= 1
+                        prev = ema.iloc[j] if j >= 0 else np.nan
+                    if pd.isna(prev):
+                        ema.iloc[i] = float(x)
+                    else:
+                        ema.iloc[i] = float(alpha * x + (1.0 - alpha) * prev)
+            return ema
+        else:
+            # Default: pandas ewm
+            return data.ewm(span=period, adjust=False).mean()
+
+    def rsi(self, data: pd.Series, period: int = 14, method: str = 'sma') -> pd.Series:
+        """
+        Calculate Relative Strength Index (RSI).
+        Args:
+            data: Price series
+            period: Period for RSI calculation. Default is 14.
+            method: 'sma' uses SMA for smoothing (default), 'rma' uses RMA (Wilder's Smoothing) matching TA-Lib.
+                   RMA gives more weight to historical data, making it less responsive to recent changes.
+        """
+        self.logger.info(f"Calculating RSI(period={period}, method={method})")
+        delta = data.diff()
+        gains = delta.where(delta > 0, 0)
+        losses = -delta.where(delta < 0, 0)
+        
+        if method == 'rma':
+            # TA-Lib compatible: RMA (Wilder's Smoothing)
+            avg_gain = pd.Series(index=data.index, dtype=float)
+            avg_loss = pd.Series(index=data.index, dtype=float)
+            
+            if len(data) >= period + 1:
+                avg_gain.iloc[period] = gains.iloc[1:period+1].mean()
+                avg_loss.iloc[period] = losses.iloc[1:period+1].mean()
+                
+                for i in range(period + 1, len(data)):
+                    if pd.notna(avg_gain.iloc[i - 1]) and pd.notna(gains.iloc[i]):
+                        avg_gain.iloc[i] = (avg_gain.iloc[i - 1] * (period - 1) + gains.iloc[i]) / period
+                    else:
+                        avg_gain.iloc[i] = np.nan
+                    
+                    if pd.notna(avg_loss.iloc[i - 1]) and pd.notna(losses.iloc[i]):
+                        avg_loss.iloc[i] = (avg_loss.iloc[i - 1] * (period - 1) + losses.iloc[i]) / period
+                    else:
+                        avg_loss.iloc[i] = np.nan
+            
+            rs = avg_gain / avg_loss
+        else:
+            # Default: SMA
+            avg_gain = gains.rolling(window=period).mean()
+            avg_loss = losses.rolling(window=period).mean()
+            rs = avg_gain / avg_loss
+        
+        return 100 - (100 / (1 + rs))
+      
+    def kdj(self, high: pd.Series, low: pd.Series, close: pd.Series, 
+            n: int = 9, m1: int = 3, m2: int = 3, method: str = 'ema') -> pd.DataFrame:
+        """
+        Calculate KDJ indicator (Stochastic Oscillator).
+        Args:
+            high: High price series
+            low: Low price series
+            close: Close price series
+            n: Period for RSV calculation. Default is 9.
+            m1: Period for K line smoothing. Default is 3.
+            m2: Period for D line smoothing. Default is 3.
+            method: 'ema' uses EMA for smoothing (default, more responsive),
+                   'sma' uses SMA for smoothing matching TA-Lib STOCH.
+        """
+        self.logger.info(f"Calculating KDJ(n={n}, m1={m1}, m2={m2}, method={method})")
+        
+        # Calculate RSV (Raw Stochastic Value)
+        lowest_low = low.rolling(window=n).min()
+        highest_high = high.rolling(window=n).max()
+        rsv = 100 * (close - lowest_low) / (highest_high - lowest_low)
+        rsv = rsv.fillna(50)  # Fill NaN with neutral value
+        
+        if method == 'sma':
+            # TA-Lib compatible: SMA smoothing
+            k = self.sma(rsv, m1)
+            d = self.sma(k, m2)
+        else:
+            # Default: EMA smoothing (more responsive)
+            k = self.ema(rsv, m1)
+            d = self.ema(k, m2)
+        
+        j = 3 * k - 2 * d
+        
+        return pd.DataFrame({
+            'k': k,
+            'd': d,
+            'j': j
+        })
+    
+    def boll(self, data: pd.Series, period: int = 20, std_dev: float = 2, method: str = 'sample') -> pd.DataFrame:
+        """
+        Calculate Bollinger Bands.
+        Args:
+            data: Price series
+            period: Period for Bollinger Bands calculation. Default is 20.
+            std_dev: Number of standard deviations. Default is 2.
+            method: 'sample' uses sample std (ddof=1, default), 'population' uses population std (ddof=0) matching TA-Lib.
+                   Population std is slightly smaller, making bands tighter. TA-Lib BBANDS uses population std.
+        """
+        self.logger.info(f"Calculating BOLL(period={period}, std_dev={std_dev}, method={method})")
+        sma = self.sma(data, period)
+        ddof = 0 if method == 'population' else 1
+        std = data.rolling(window=period).std(ddof=ddof)
+        
+        return pd.DataFrame({
+            'upper': sma + (std * std_dev),
+            'middle': sma,
+            'lower': sma - (std * std_dev)
+        })
+    
+    def atr(self, high: pd.Series, low: pd.Series, close: pd.Series, period: int = 14, method: str = 'sma') -> pd.Series:
+        """
+        Calculate Average True Range (ATR).
+        Args:
+            high: High price series
+            low: Low price series
+            close: Close price series
+            period: Period for ATR calculation. Default is 14.
+            method: 'sma' uses SMA for smoothing (default), 'rma' uses RMA (Wilder's Smoothing) matching TA-Lib.
+                   RMA gives more weight to historical data, making it less responsive to recent changes.
+        """
+        self.logger.info(f"Calculating ATR(period={period}, method={method})")
+
+        # Calculate True Range
+        tr1 = high - low
+        tr2 = abs(high - close.shift(1))
+        tr3 = abs(low - close.shift(1))
+        tr = pd.concat([tr1, tr2, tr3], axis=1).max(axis=1)
+
+        if method == 'rma':
+            # TA-Lib compatible: RMA (Wilder's Smoothing)
+            atr = pd.Series(index=tr.index, dtype=float)
+            if len(tr) >= period + 1:
+                atr.iloc[period] = tr.iloc[1:period+1].mean()
+                for i in range(period + 1, len(tr)):
+                    if pd.notna(atr.iloc[i - 1]) and pd.notna(tr.iloc[i]):
+                        atr.iloc[i] = (atr.iloc[i - 1] * (period - 1) + tr.iloc[i]) / period
+                    else:
+                        atr.iloc[i] = np.nan
+            return atr
+        else:
+            # Default: SMA
+            return tr.rolling(window=period).mean()
+    
+    def obv(self, close: pd.Series, volume: pd.Series) -> pd.Series:
+        """
+        Calculate On-Balance Volume (OBV).
+        Args:
+            close: Close price series
+            volume: Volume series
+        """
+        self.logger.info("Calculating OBV")
+        
+        # Calculate price change direction
+        price_change = close.diff()
+        
+        # Calculate signed volume based on price direction
+        signed_volume = volume.copy()
+        signed_volume[price_change > 0] = volume[price_change > 0]  # Add volume when price up
+        signed_volume[price_change < 0] = -volume[price_change < 0]  # Subtract volume when price down
+        signed_volume[price_change == 0] = 0  # No change when price unchanged
+        signed_volume.iloc[0] = volume.iloc[0]  # First value is first volume
+        
+        # Calculate cumulative OBV
+        obv = signed_volume.cumsum()
+        
+        return obv

deltafq/live/__init__.py

@@ -0,0 +1,16 @@
+"""
+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,158 @@
+"""
+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)
+        }
+