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

deltafq/core/exceptions.py

@@ -0,0 +1,35 @@
+"""
+Custom exceptions for DeltaFQ.
+"""
+
+
+class DeltaFQError(Exception):
+    """Base exception for DeltaFQ."""
+    pass
+
+
+class DataError(DeltaFQError):
+    """Exception raised for data-related errors."""
+    pass
+
+
+class TradingError(DeltaFQError):
+    """Exception raised for trading-related errors."""
+    pass
+
+
+class BacktestError(DeltaFQError):
+    """Exception raised for backtesting errors."""
+    pass
+
+
+class StrategyError(DeltaFQError):
+    """Exception raised for strategy-related errors."""
+    pass
+
+
+class IndicatorError(DeltaFQError):
+    """Exception raised for indicator calculation errors."""
+    pass
+
+

deltafq/core/logger.py

@@ -0,0 +1,46 @@
+"""
+Logging system for DeltaFQ.
+"""
+
+import logging
+import sys
+from typing import Optional
+
+
+class Logger:
+    """Logger for DeltaFQ components."""
+    
+    def __init__(self, name: str = "deltafq", level: str = "INFO"):
+        """Initialize logger."""
+        self.logger = logging.getLogger(name)
+        self.logger.setLevel(getattr(logging, level.upper()))
+        
+        if not self.logger.handlers:
+            handler = logging.StreamHandler(sys.stdout)
+            formatter = logging.Formatter(
+                '%(asctime)s - %(name)s - %(levelname)s - %(message)s'
+            )
+            handler.setFormatter(formatter)
+            self.logger.addHandler(handler)
+    
+    def debug(self, message: str):
+        """Log debug message."""
+        self.logger.debug(message)
+    
+    def info(self, message: str):
+        """Log info message."""
+        self.logger.info(message)
+    
+    def warning(self, message: str):
+        """Log warning message."""
+        self.logger.warning(message)
+    
+    def error(self, message: str):
+        """Log error message."""
+        self.logger.error(message)
+    
+    def critical(self, message: str):
+        """Log critical message."""
+        self.logger.critical(message)
+
+

deltafq/data/__init__.py

@@ -1,7 +1,17 @@
-"""数据获取和管理模块"""
-
-from deltafq.data.base import DataSource
-from deltafq.data.loader import get_stock_daily, get_stock_minute
-
-__all__ = ["DataSource", "get_stock_daily", "get_stock_minute"]
-
+"""
+Data management module for DeltaFQ.
+"""
+
+from .fetcher import DataFetcher
+from .cleaner import DataCleaner
+from .validator import DataValidator
+from .storage import DataStorage
+
+__all__ = [
+    "DataFetcher",
+    "DataCleaner", 
+    "DataValidator",
+    "DataStorage"
+]
+
+

deltafq/data/cleaner.py

@@ -0,0 +1,41 @@
+"""
+Data cleaning utilities for DeltaFQ.
+"""
+
+import pandas as pd
+from typing import Optional
+from ..core.base import BaseComponent
+
+
+class DataCleaner(BaseComponent):
+    """Data cleaning utilities."""
+    
+    def initialize(self) -> bool:
+        """Initialize the data cleaner."""
+        self.logger.info("Initializing data cleaner")
+        return True
+    
+    def clean_price_data(self, data: pd.DataFrame) -> pd.DataFrame:
+        """Clean price data by removing invalid values."""
+        # Remove rows with NaN values
+        cleaned_data = data.dropna()
+        
+        # Remove rows with zero or negative prices
+        price_columns = ['open', 'high', 'low', 'close']
+        for col in price_columns:
+            if col in cleaned_data.columns:
+                cleaned_data = cleaned_data[cleaned_data[col] > 0]
+        
+        self.logger.info(f"Cleaned data: {len(data)} -> {len(cleaned_data)} rows")
+        return cleaned_data
+    
+    def fill_missing_data(self, data: pd.DataFrame, method: str = "forward") -> pd.DataFrame:
+        """Fill missing data using specified method."""
+        if method == "forward":
+            return data.fillna(method='ffill')
+        elif method == "backward":
+            return data.fillna(method='bfill')
+        else:
+            return data.fillna(0)
+
+

deltafq/data/fetcher.py

@@ -0,0 +1,52 @@
+"""
+Data fetching interfaces for DeltaFQ.
+"""
+
+import pandas as pd
+from typing import List, Optional
+from ..core.base import BaseComponent
+from ..core.exceptions import DataError
+
+
+class DataFetcher(BaseComponent):
+    """Data fetcher for various sources."""
+    
+    def __init__(self, source: str = "yahoo", **kwargs):
+        """Initialize data fetcher."""
+        super().__init__(**kwargs)
+        self.source = source
+    
+    def initialize(self) -> bool:
+        """Initialize the data fetcher."""
+        self.logger.info(f"Initializing data fetcher with source: {self.source}")
+        return True
+    
+    def fetch_stock_data(self, symbol: str, start_date: str, end_date: str = None) -> pd.DataFrame:
+        """Fetch stock data for given symbol."""
+        try:
+            # Placeholder implementation
+            self.logger.info(f"Fetching data for {symbol} from {start_date} to {end_date}")
+            
+            # This would be replaced with actual data fetching logic
+            dates = pd.date_range(start=start_date, end=end_date or "2024-01-01", freq='D')
+            data = pd.DataFrame({
+                'date': dates,
+                'open': 100.0,
+                'high': 105.0,
+                'low': 95.0,
+                'close': 102.0,
+                'volume': 1000000
+            })
+            
+            return data
+        except Exception as e:
+            raise DataError(f"Failed to fetch data for {symbol}: {str(e)}")
+    
+    def fetch_multiple_symbols(self, symbols: List[str], start_date: str, end_date: str = None) -> dict:
+        """Fetch data for multiple symbols."""
+        data_dict = {}
+        for symbol in symbols:
+            data_dict[symbol] = self.fetch_stock_data(symbol, start_date, end_date)
+        return data_dict
+
+

deltafq/data/storage.py

@@ -0,0 +1,56 @@
+"""
+Data storage management for DeltaFQ.
+"""
+
+import pandas as pd
+import os
+from pathlib import Path
+from typing import Optional
+from ..core.base import BaseComponent
+
+
+class DataStorage(BaseComponent):
+    """Data storage manager."""
+    
+    def __init__(self, storage_path: str = "./data_cache", **kwargs):
+        """Initialize data storage."""
+        super().__init__(**kwargs)
+        self.storage_path = Path(storage_path)
+        self.storage_path.mkdir(exist_ok=True)
+    
+    def initialize(self) -> bool:
+        """Initialize the data storage."""
+        self.logger.info(f"Initializing data storage at: {self.storage_path}")
+        return True
+    
+    def save_data(self, data: pd.DataFrame, filename: str) -> bool:
+        """Save data to storage."""
+        try:
+            filepath = self.storage_path / filename
+            data.to_csv(filepath, index=False)
+            self.logger.info(f"Saved data to: {filepath}")
+            return True
+        except Exception as e:
+            self.logger.error(f"Failed to save data: {str(e)}")
+            return False
+    
+    def load_data(self, filename: str) -> Optional[pd.DataFrame]:
+        """Load data from storage."""
+        try:
+            filepath = self.storage_path / filename
+            if filepath.exists():
+                data = pd.read_csv(filepath)
+                self.logger.info(f"Loaded data from: {filepath}")
+                return data
+            else:
+                self.logger.warning(f"File not found: {filepath}")
+                return None
+        except Exception as e:
+            self.logger.error(f"Failed to load data: {str(e)}")
+            return None
+    
+    def list_files(self) -> list:
+        """List all files in storage."""
+        return [f.name for f in self.storage_path.iterdir() if f.is_file()]
+
+

deltafq/data/validator.py

@@ -0,0 +1,52 @@
+"""
+Data validation for DeltaFQ.
+"""
+
+import pandas as pd
+from typing import List, Optional
+from ..core.base import BaseComponent
+from ..core.exceptions import DataError
+
+
+class DataValidator(BaseComponent):
+    """Data validator for ensuring data quality."""
+    
+    def initialize(self) -> bool:
+        """Initialize the data validator."""
+        self.logger.info("Initializing data validator")
+        return True
+    
+    def validate_price_data(self, data: pd.DataFrame) -> bool:
+        """Validate price data structure and values."""
+        required_columns = ['open', 'high', 'low', 'close']
+        
+        # Check required columns
+        missing_columns = [col for col in required_columns if col not in data.columns]
+        if missing_columns:
+            raise DataError(f"Missing required columns: {missing_columns}")
+        
+        # Check for negative prices
+        for col in required_columns:
+            if (data[col] <= 0).any():
+                raise DataError(f"Found non-positive values in {col} column")
+        
+        # Check high >= low
+        if (data['high'] < data['low']).any():
+            raise DataError("Found high < low values")
+        
+        self.logger.info("Price data validation passed")
+        return True
+    
+    def validate_data_continuity(self, data: pd.DataFrame, date_column: str = 'date') -> bool:
+        """Validate data continuity."""
+        if date_column not in data.columns:
+            raise DataError(f"Date column '{date_column}' not found")
+        
+        # Check for duplicate dates
+        if data[date_column].duplicated().any():
+            raise DataError("Found duplicate dates in data")
+        
+        self.logger.info("Data continuity validation passed")
+        return True
+
+

deltafq/indicators/__init__.py

@@ -1,8 +1,17 @@
-"""技术指标计算模块"""
-
-from deltafq.indicators.trend import SMA, EMA, MACD
-from deltafq.indicators.momentum import RSI
-from deltafq.indicators.volatility import BOLL
-
-__all__ = ["SMA", "EMA", "MACD", "RSI", "BOLL"]
-
+"""
+Technical indicators module for DeltaFQ.
+"""
+
+from .technical import TechnicalIndicators
+from .momentum import MomentumIndicators
+from .trend import TrendIndicators
+from .volatility import VolatilityIndicators
+
+__all__ = [
+    "TechnicalIndicators",
+    "MomentumIndicators",
+    "TrendIndicators",
+    "VolatilityIndicators"
+]
+
+

deltafq/indicators/momentum.py

@@ -1,23 +1,56 @@
-"""动量类指标"""
-
-import pandas as pd
-
-
-def RSI(data: pd.Series, period: int = 14) -> pd.Series:
-    """相对强弱指标
-    
-    Args:
-        data: 价格序列
-        period: 周期
-        
-    Returns:
-        RSI序列
-    """
-    delta = data.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))
-    return rsi
-
+"""
+Momentum indicators for DeltaFQ.
+"""
+
+import pandas as pd
+import numpy as np
+from ..core.base import BaseComponent
+
+
+class MomentumIndicators(BaseComponent):
+    """Momentum-based technical indicators."""
+    
+    def initialize(self) -> bool:
+        """Initialize momentum indicators."""
+        self.logger.info("Initializing momentum indicators")
+        return True
+    
+    def roc(self, data: pd.Series, period: int) -> pd.Series:
+        """Rate of Change."""
+        return data.pct_change(period) * 100
+    
+    def momentum(self, data: pd.Series, period: int) -> pd.Series:
+        """Momentum indicator."""
+        return data - data.shift(period)
+    
+    def williams_r(self, high: pd.Series, low: pd.Series, close: pd.Series, period: int = 14) -> pd.Series:
+        """Williams %R."""
+        highest_high = high.rolling(window=period).max()
+        lowest_low = low.rolling(window=period).min()
+        return -100 * (highest_high - close) / (highest_high - lowest_low)
+    
+    def stochastic(self, high: pd.Series, low: pd.Series, close: pd.Series, 
+                   k_period: int = 14, d_period: int = 3) -> pd.DataFrame:
+        """Stochastic Oscillator."""
+        lowest_low = low.rolling(window=k_period).min()
+        highest_high = high.rolling(window=k_period).max()
+        
+        k_percent = 100 * (close - lowest_low) / (highest_high - lowest_low)
+        d_percent = k_percent.rolling(window=d_period).mean()
+        
+        return pd.DataFrame({
+            'k_percent': k_percent,
+            'd_percent': d_percent
+        })
+    
+    def cci(self, high: pd.Series, low: pd.Series, close: pd.Series, period: int = 20) -> pd.Series:
+        """Commodity Channel Index."""
+        typical_price = (high + low + close) / 3
+        sma_tp = typical_price.rolling(window=period).mean()
+        mean_deviation = typical_price.rolling(window=period).apply(
+            lambda x: np.mean(np.abs(x - x.mean()))
+        )
+        
+        return (typical_price - sma_tp) / (0.015 * mean_deviation)
+
+

deltafq/indicators/technical.py

@@ -0,0 +1,59 @@
+"""
+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:
+        """Simple Moving Average."""
+        return data.rolling(window=period).mean()
+    
+    def ema(self, data: pd.Series, period: int) -> pd.Series:
+        """Exponential Moving Average."""
+        return data.ewm(span=period).mean()
+    
+    def rsi(self, data: pd.Series, period: int = 14) -> pd.Series:
+        """Relative Strength Index."""
+        delta = data.diff()
+        gain = (delta.where(delta > 0, 0)).rolling(window=period).mean()
+        loss = (-delta.where(delta < 0, 0)).rolling(window=period).mean()
+        rs = gain / loss
+        return 100 - (100 / (1 + rs))
+    
+    def macd(self, data: pd.Series, fast: int = 12, slow: int = 26, signal: int = 9) -> pd.DataFrame:
+        """MACD indicator."""
+        ema_fast = self.ema(data, fast)
+        ema_slow = self.ema(data, slow)
+        macd_line = ema_fast - ema_slow
+        signal_line = self.ema(macd_line, signal)
+        histogram = macd_line - signal_line
+        
+        return pd.DataFrame({
+            'macd': macd_line,
+            'signal': signal_line,
+            'histogram': histogram
+        })
+    
+    def bollinger_bands(self, data: pd.Series, period: int = 20, std_dev: float = 2) -> pd.DataFrame:
+        """Bollinger Bands."""
+        sma = self.sma(data, period)
+        std = data.rolling(window=period).std()
+        
+        return pd.DataFrame({
+            'upper': sma + (std * std_dev),
+            'middle': sma,
+            'lower': sma - (std * std_dev)
+        })
+
+

deltafq/indicators/trend.py

@@ -1,61 +1,129 @@
-"""趋势类指标"""
-
-import pandas as pd
-from typing import Union
-
-
-def SMA(data: Union[pd.Series, pd.DataFrame], period: int) -> pd.Series:
-    """简单移动平均线
-    
-    Args:
-        data: 价格序列
-        period: 周期
-        
-    Returns:
-        SMA序列
-    """
-    return data.rolling(window=period).mean()
-
-
-def EMA(data: Union[pd.Series, pd.DataFrame], period: int) -> pd.Series:
-    """指数移动平均线
-    
-    Args:
-        data: 价格序列
-        period: 周期
-        
-    Returns:
-        EMA序列
-    """
-    return data.ewm(span=period, adjust=False).mean()
-
-
-def MACD(
-    data: pd.Series,
-    fast_period: int = 12,
-    slow_period: int = 26,
-    signal_period: int = 9
-) -> pd.DataFrame:
-    """MACD指标
-    
-    Args:
-        data: 价格序列
-        fast_period: 快线周期
-        slow_period: 慢线周期
-        signal_period: 信号线周期
-        
-    Returns:
-        包含DIF、DEA、MACD的DataFrame
-    """
-    fast = EMA(data, fast_period)
-    slow = EMA(data, slow_period)
-    dif = fast - slow
-    dea = EMA(dif, signal_period)
-    macd = (dif - dea) * 2
-    
-    return pd.DataFrame({
-        'dif': dif,
-        'dea': dea,
-        'macd': macd
-    })
-
+"""
+Trend indicators for DeltaFQ.
+"""
+
+import pandas as pd
+import numpy as np
+from ..core.base import BaseComponent
+
+
+class TrendIndicators(BaseComponent):
+    """Trend-based technical indicators."""
+    
+    def initialize(self) -> bool:
+        """Initialize trend indicators."""
+        self.logger.info("Initializing trend indicators")
+        return True
+    
+    def adx(self, high: pd.Series, low: pd.Series, close: pd.Series, period: int = 14) -> pd.DataFrame:
+        """Average Directional Index."""
+        # 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)
+        
+        # Directional Movement
+        dm_plus = np.where((high.diff() > low.diff().abs()) & (high.diff() > 0), high.diff(), 0)
+        dm_minus = np.where((low.diff().abs() > high.diff()) & (low.diff() < 0), low.diff().abs(), 0)
+        
+        dm_plus = pd.Series(dm_plus, index=high.index)
+        dm_minus = pd.Series(dm_minus, index=high.index)
+        
+        # Smoothed values
+        atr = tr.rolling(window=period).mean()
+        di_plus = 100 * (dm_plus.rolling(window=period).mean() / atr)
+        di_minus = 100 * (dm_minus.rolling(window=period).mean() / atr)
+        
+        # ADX
+        dx = 100 * abs(di_plus - di_minus) / (di_plus + di_minus)
+        adx = dx.rolling(window=period).mean()
+        
+        return pd.DataFrame({
+            'adx': adx,
+            'di_plus': di_plus,
+            'di_minus': di_minus
+        })
+    
+    def parabolic_sar(self, high: pd.Series, low: pd.Series, close: pd.Series, 
+                      acceleration: float = 0.02, maximum: float = 0.2) -> pd.Series:
+        """Parabolic SAR."""
+        # Simplified implementation
+        psar = pd.Series(index=close.index, dtype=float)
+        trend = pd.Series(index=close.index, dtype=int)
+        af = pd.Series(index=close.index, dtype=float)
+        ep = pd.Series(index=close.index, dtype=float)
+        
+        # Initialize
+        psar.iloc[0] = low.iloc[0]
+        trend.iloc[0] = 1
+        af.iloc[0] = acceleration
+        ep.iloc[0] = high.iloc[0]
+        
+        for i in range(1, len(close)):
+            if trend.iloc[i-1] == 1:  # Uptrend
+                psar.iloc[i] = psar.iloc[i-1] + af.iloc[i-1] * (ep.iloc[i-1] - psar.iloc[i-1])
+                
+                if low.iloc[i] <= psar.iloc[i]:
+                    trend.iloc[i] = -1
+                    psar.iloc[i] = ep.iloc[i-1]
+                    ep.iloc[i] = low.iloc[i]
+                    af.iloc[i] = acceleration
+                else:
+                    trend.iloc[i] = 1
+                    if high.iloc[i] > ep.iloc[i-1]:
+                        ep.iloc[i] = high.iloc[i]
+                        af.iloc[i] = min(af.iloc[i-1] + acceleration, maximum)
+                    else:
+                        ep.iloc[i] = ep.iloc[i-1]
+                        af.iloc[i] = af.iloc[i-1]
+            else:  # Downtrend
+                psar.iloc[i] = psar.iloc[i-1] + af.iloc[i-1] * (ep.iloc[i-1] - psar.iloc[i-1])
+                
+                if high.iloc[i] >= psar.iloc[i]:
+                    trend.iloc[i] = 1
+                    psar.iloc[i] = ep.iloc[i-1]
+                    ep.iloc[i] = high.iloc[i]
+                    af.iloc[i] = acceleration
+                else:
+                    trend.iloc[i] = -1
+                    if low.iloc[i] < ep.iloc[i-1]:
+                        ep.iloc[i] = low.iloc[i]
+                        af.iloc[i] = min(af.iloc[i-1] + acceleration, maximum)
+                    else:
+                        ep.iloc[i] = ep.iloc[i-1]
+                        af.iloc[i] = af.iloc[i-1]
+        
+        return psar
+    
+    def ichimoku(self, high: pd.Series, low: pd.Series, close: pd.Series,
+                 conversion_period: int = 9, base_period: int = 26, 
+                 leading_span_b_period: int = 52, displacement: int = 26) -> pd.DataFrame:
+        """Ichimoku Cloud."""
+        # Conversion Line (Tenkan-sen)
+        conversion_line = (high.rolling(window=conversion_period).max() + 
+                          low.rolling(window=conversion_period).min()) / 2
+        
+        # Base Line (Kijun-sen)
+        base_line = (high.rolling(window=base_period).max() + 
+                    low.rolling(window=base_period).min()) / 2
+        
+        # Leading Span A (Senkou Span A)
+        leading_span_a = ((conversion_line + base_line) / 2).shift(displacement)
+        
+        # Leading Span B (Senkou Span B)
+        leading_span_b = ((high.rolling(window=leading_span_b_period).max() + 
+                          low.rolling(window=leading_span_b_period).min()) / 2).shift(displacement)
+        
+        # Lagging Span (Chikou Span)
+        lagging_span = close.shift(-displacement)
+        
+        return pd.DataFrame({
+            'conversion_line': conversion_line,
+            'base_line': base_line,
+            'leading_span_a': leading_span_a,
+            'leading_span_b': leading_span_b,
+            'lagging_span': lagging_span
+        })
+
+