deltafq 0.4.0__py3-none-any.whl

deltafq/core/exceptions.py

@@ -0,0 +1,34 @@
+"""
+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,44 @@
+"""
+Logging system for DeltaFQ.
+"""
+
+import logging
+import sys
+
+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)-20s >>> %(levelname)-8s >>> %(message)s',
+                datefmt='%H:%M:%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

@@ -0,0 +1,16 @@
+"""
+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,39 @@
+"""
+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 dropna(self, data: pd.DataFrame) -> pd.DataFrame:
+        """Remove rows with NaN values."""
+        cleaned_data = data.dropna()
+        self.logger.info(f"Dropped NaN rows: {len(data)} -> {len(cleaned_data)} rows")
+        return cleaned_data
+    
+    def fillna(self, data: pd.DataFrame, method: str = "forward") -> pd.DataFrame:
+        """Fill missing data using specified method."""
+        na_count_before = data.isna().sum().sum()
+        
+        if method == "forward":
+            filled_data = data.fillna(method='ffill')
+        elif method == "backward":
+            filled_data = data.fillna(method='bfill')
+        else:
+            filled_data = data.fillna(0)
+        
+        na_count_after = filled_data.isna().sum().sum()
+        self.logger.info(f"Filled NaN: {na_count_before} -> {na_count_after} (method: {method})")
+        
+        return filled_data
+

deltafq/data/fetcher.py

@@ -0,0 +1,58 @@
+"""
+Data fetching interfaces for DeltaFQ.
+"""
+
+import pandas as pd
+import yfinance as yf
+from typing import List, Optional
+from ..core.base import BaseComponent
+from ..core.exceptions import DataError
+from .cleaner import DataCleaner
+import warnings
+warnings.filterwarnings('ignore')
+
+
+class DataFetcher(BaseComponent):
+    """Data fetcher for various sources."""
+    
+    def __init__(self, source: str = "yahoo", **kwargs):
+        """Initialize data fetcher."""
+        super().__init__(**kwargs)
+        self.source = source
+        self.cleaner = None
+    
+    def initialize(self) -> bool:
+        """Initialize the data fetcher."""
+        self.logger.info(f"Initializing data fetcher with source: {self.source}")
+        return True
+    
+    def _ensure_cleaner(self):
+        """Lazy initialization of cleaner."""
+        if self.cleaner is None:
+            self.cleaner = DataCleaner()
+            self.cleaner.initialize()
+    
+    def fetch_data(self, symbol: str, start_date: str, end_date: str = None, clean: bool = False) -> pd.DataFrame:
+        """Fetch stock data for given symbol."""
+        try:
+            self.logger.info(f"Fetching data for {symbol} from {start_date} to {end_date}")
+            
+            data = yf.download(symbol, start=start_date, end=end_date, progress=False)
+            data = data.droplevel(level=1, axis=1)  # Drop the multi-index level
+            
+            if clean:
+                self._ensure_cleaner()
+                data = self.cleaner.dropna(data)
+                
+            return data
+        except Exception as e:
+            raise DataError(f"Failed to fetch data for {symbol}: {str(e)}")
+    
+    def fetch_data_multiple(self, symbols: List[str], start_date: str, end_date: str = None, clean: bool = False) -> dict:
+        """Fetch data for multiple symbols."""
+        data_dict = {}
+        for symbol in symbols:
+            data_dict[symbol] = self.fetch_data(symbol, start_date, end_date, clean)
+        return data_dict
+
+

deltafq/data/storage.py

@@ -0,0 +1,264 @@
+"""
+Data storage management for DeltaFQ.
+"""
+
+import pandas as pd
+import os
+from pathlib import Path
+from typing import Optional, Dict, Any
+from datetime import datetime
+from ..core.base import BaseComponent
+
+
+class DataStorage(BaseComponent):
+    """
+    Data storage manager with categorized storage.
+    
+    Directory structure:
+        data_cache/
+        ├── price/          # Price data
+        │   └── {symbol}/
+        ├── backtest/       # Backtest results
+        │   └── {symbol}/
+        ├── indicators/     # Technical indicators
+        └── misc/          # Other data
+    """
+    
+    def __init__(self, base_path: str = None, **kwargs):
+        """Initialize data storage."""
+        super().__init__(**kwargs)
+        
+        # Auto-detect project root if base_path not provided
+        if base_path is None:
+            project_root = self._get_project_root()
+            base_path = project_root / "data_cache"
+        
+        self.base_path = Path(base_path)
+        self._init_directories()
+    
+    def _get_project_root(self) -> Path:
+        """Get project root directory by finding setup.py or pyproject.toml."""
+        current = Path(__file__).resolve()
+        # Go up from deltafq/data/storage.py to project root
+        for parent in current.parents:
+            if (parent / "setup.py").exists() or (parent / "pyproject.toml").exists():
+                return parent
+        # Fallback to current working directory
+        return Path.cwd()
+    
+    def _init_directories(self):
+        """Initialize directory structure."""
+        self.price_dir = self.base_path / "price"
+        self.backtest_dir = self.base_path / "backtest"
+        self.indicators_dir = self.base_path / "indicators"
+        self.misc_dir = self.base_path / "misc"
+        
+        # Create directories
+        for dir_path in [self.price_dir, self.backtest_dir, 
+                        self.indicators_dir, self.misc_dir]:
+            dir_path.mkdir(parents=True, exist_ok=True)
+    
+    def initialize(self) -> bool:
+        """Initialize the data storage."""
+        self.logger.info(f"Initializing data storage at: {self.base_path}")
+        return True
+    
+    # ============================================================================
+    # Price Data Storage
+    # ============================================================================
+    
+    def save_price_data(self, data: pd.DataFrame, symbol: str, 
+                       start_date: Optional[str] = None, 
+                       end_date: Optional[str] = None) -> Path:
+        """Save price data to storage."""
+        symbol_dir = self.price_dir / symbol.replace('.', '_')
+        symbol_dir.mkdir(exist_ok=True)
+        
+        # Generate filename
+        if start_date and end_date:
+            filename = f"{symbol}_{start_date}_{end_date}.csv"
+        else:
+            filename = f"{symbol}_{datetime.now().strftime('%Y%m%d')}.csv"
+        
+        filepath = symbol_dir / filename
+        data.to_csv(filepath, encoding='utf-8-sig', index=True)
+        self.logger.info(f"Saved price data to: {filepath}")
+        return filepath
+    
+    def load_price_data(self, symbol: str, start_date: Optional[str] = None,
+                       end_date: Optional[str] = None) -> Optional[pd.DataFrame]:
+        """Load price data from storage."""
+        symbol_dir = self.price_dir / symbol.replace('.', '_')
+        
+        if start_date and end_date:
+            filename = f"{symbol}_{start_date}_{end_date}.csv"
+        else:
+            # Try to find the latest file
+            files = list(symbol_dir.glob(f"{symbol}_*.csv"))
+            if not files:
+                self.logger.warning(f"No price data found for {symbol}")
+                return None
+            filename = sorted(files)[-1].name
+        
+        filepath = symbol_dir / filename
+        if filepath.exists():
+            data = pd.read_csv(filepath, index_col=0, parse_dates=True)
+            self.logger.info(f"Loaded price data from: {filepath}")
+            return data
+        return None
+    
+    # ============================================================================
+    # Backtest Data Storage
+    # ============================================================================
+    
+    def save_backtest_results(self, trades_df: pd.DataFrame, 
+                             values_df: pd.DataFrame, symbol: str,
+                             strategy_name: Optional[str] = None) -> Dict[str, Path]:
+        """Save backtest results to storage."""
+        symbol_dir = self.backtest_dir / symbol.replace('.', '_')
+        symbol_dir.mkdir(exist_ok=True)
+        
+        timestamp = datetime.now().strftime('%Y%m%d_%H%M%S')
+        strategy_suffix = f"_{strategy_name}" if strategy_name else ""
+        
+        trades_path = symbol_dir / f"{symbol}_trades{strategy_suffix}_{timestamp}.csv"
+        values_path = symbol_dir / f"{symbol}_values{strategy_suffix}_{timestamp}.csv"
+        
+        trades_df.to_csv(trades_path, encoding='utf-8-sig', index=False)
+        values_df.to_csv(values_path, encoding='utf-8-sig', index=False)
+        
+        self.logger.info(f"Saved backtest results to: {symbol_dir}")
+        return {'trades': trades_path, 'values': values_path}
+    
+    def load_backtest_results(self, symbol: str, strategy_name: Optional[str] = None,
+                             latest: bool = True) -> Optional[Dict[str, pd.DataFrame]]:
+        """Load backtest results from storage."""
+        symbol_dir = self.backtest_dir / symbol.replace('.', '_')
+        
+        if not symbol_dir.exists():
+            self.logger.warning(f"No backtest results found for {symbol}")
+            return None
+        
+        # Find trades and values files
+        if strategy_name:
+            trades_files = list(symbol_dir.glob(f"{symbol}_trades_{strategy_name}_*.csv"))
+            values_files = list(symbol_dir.glob(f"{symbol}_values_{strategy_name}_*.csv"))
+        else:
+            trades_files = list(symbol_dir.glob(f"{symbol}_trades*.csv"))
+            values_files = list(symbol_dir.glob(f"{symbol}_values*.csv"))
+        
+        if not trades_files or not values_files:
+            self.logger.warning(f"No backtest results found for {symbol}")
+            return None
+        
+        if latest:
+            trades_file = sorted(trades_files)[-1]
+            values_file = sorted(values_files)[-1]
+            return {
+                'trades': pd.read_csv(trades_file, encoding='utf-8-sig'),
+                'values': pd.read_csv(values_file, encoding='utf-8-sig')
+            }
+        else:
+            # Return all files
+            return {
+                'trades': [pd.read_csv(f, encoding='utf-8-sig') for f in trades_files],
+                'values': [pd.read_csv(f, encoding='utf-8-sig') for f in values_files]
+            }
+    
+    # ============================================================================
+    # Generic Storage Methods
+    # ============================================================================
+    
+    def save_data(self, data: pd.DataFrame, filename: str, 
+                 category: str = "misc", subdir: Optional[str] = None) -> Path:
+        """Save data to storage with category."""
+        if category == "price":
+            target_dir = self.price_dir
+        elif category == "backtest":
+            target_dir = self.backtest_dir
+        elif category == "indicators":
+            target_dir = self.indicators_dir
+        else:
+            target_dir = self.misc_dir
+        
+        if subdir:
+            target_dir = target_dir / subdir
+            target_dir.mkdir(parents=True, exist_ok=True)
+        
+        filepath = target_dir / filename
+        data.to_csv(filepath, encoding='utf-8-sig', index=False)
+        self.logger.info(f"Saved data to: {filepath}")
+        return filepath
+    
+    def load_data(self, filename: str, category: str = "misc", 
+                 subdir: Optional[str] = None) -> Optional[pd.DataFrame]:
+        """Load data from storage."""
+        if category == "price":
+            target_dir = self.price_dir
+        elif category == "backtest":
+            target_dir = self.backtest_dir
+        elif category == "indicators":
+            target_dir = self.indicators_dir
+        else:
+            target_dir = self.misc_dir
+        
+        if subdir:
+            target_dir = target_dir / subdir
+        
+        filepath = target_dir / filename
+        if filepath.exists():
+            data = pd.read_csv(filepath, encoding='utf-8-sig')
+            self.logger.info(f"Loaded data from: {filepath}")
+            return data
+        else:
+            self.logger.warning(f"File not found: {filepath}")
+            return None
+    
+    # ============================================================================
+    # Utility Methods
+    # ============================================================================
+    
+    def list_files(self, category: Optional[str] = None, 
+                  subdir: Optional[str] = None) -> list:
+        """List all files in storage."""
+        if category == "price":
+            target_dir = self.price_dir
+        elif category == "backtest":
+            target_dir = self.backtest_dir
+        elif category == "indicators":
+            target_dir = self.indicators_dir
+        elif category == "misc":
+            target_dir = self.misc_dir
+        else:
+            target_dir = self.base_path
+        
+        if subdir:
+            target_dir = target_dir / subdir
+        
+        if not target_dir.exists():
+            return []
+        
+        files = []
+        for item in target_dir.rglob('*.csv'):
+            if item.is_file():
+                files.append(str(item.relative_to(self.base_path)))
+        return files
+    
+    def get_storage_info(self) -> Dict[str, Any]:
+        """Get storage information."""
+        return {
+            'base_path': str(self.base_path),
+            'price_files': len(list(self.price_dir.rglob('*.csv'))),
+            'backtest_files': len(list(self.backtest_dir.rglob('*.csv'))),
+            'indicators_files': len(list(self.indicators_dir.rglob('*.csv'))),
+            'misc_files': len(list(self.misc_dir.rglob('*.csv'))),
+            'total_size_mb': self._calculate_size()
+        }
+    
+    def _calculate_size(self) -> float:
+        """Calculate total storage size in MB."""
+        total_size = 0
+        for file_path in self.base_path.rglob('*'):
+            if file_path.is_file():
+                total_size += file_path.stat().st_size
+        return round(total_size / (1024 * 1024), 2)

deltafq/data/validator.py

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

@@ -0,0 +1,14 @@
+"""
+Technical indicators module for DeltaFQ.
+"""
+
+from .technical import TechnicalIndicators
+from .talib_indicators import TalibIndicators
+from .fundamental import FundamentalIndicators
+
+__all__ = [
+    "TechnicalIndicators",
+    "TalibIndicators",
+    "FundamentalIndicators"
+]
+

deltafq/indicators/fundamental.py

@@ -0,0 +1,28 @@
+"""
+Fundamental indicators (placeholders).
+"""
+
+import pandas as pd
+from ..core.base import BaseComponent
+
+
+class FundamentalIndicators(BaseComponent):
+    """Basic fundamental indicators computed from preloaded fundamentals."""
+
+    def initialize(self) -> bool:
+        self.logger.info("Initializing fundamental indicators")
+        return True
+
+    def pe(self, price: pd.Series, eps_ttm: pd.Series) -> pd.Series:
+        eps = eps_ttm.reindex(price.index).ffill()
+        return price / eps
+
+    def pb(self, price: pd.Series, bvps: pd.Series) -> pd.Series:
+        bvps = bvps.reindex(price.index).ffill()
+        return price / bvps
+
+    def earnings_yield(self, price: pd.Series, eps_ttm: pd.Series) -> pd.Series:
+        pe_series = self.pe(price, eps_ttm)
+        return 1.0 / pe_series
+
+

deltafq/indicators/talib_indicators.py

@@ -0,0 +1,67 @@
+"""
+Technical indicators using TA-Lib library.
+"""
+
+import pandas as pd
+import talib
+from ..core.base import BaseComponent
+
+
+class TalibIndicators(BaseComponent):
+    """Technical indicators using TA-Lib library."""
+    
+    def initialize(self) -> bool:
+        """Initialize technical indicators."""
+        self.logger.info("Initializing TA-Lib technical indicators")
+        return True
+    
+    def sma(self, data: pd.Series, period: int) -> pd.Series:
+        """Calculate Simple Moving Average (SMA) using TA-Lib."""
+        self.logger.info(f"Calculating SMA(period={period})")
+        return pd.Series(talib.SMA(data.values.astype(float), timeperiod=period), index=data.index)
+    
+    def ema(self, data: pd.Series, period: int) -> pd.Series:
+        """Calculate Exponential Moving Average (EMA) using TA-Lib."""
+        self.logger.info(f"Calculating EMA(period={period})")
+        return pd.Series(talib.EMA(data.values.astype(float), timeperiod=period), index=data.index)
+    
+    def rsi(self, data: pd.Series, period: int = 14) -> pd.Series:
+        """Calculate Relative Strength Index (RSI) using TA-Lib."""
+        self.logger.info(f"Calculating RSI(period={period})")
+        return pd.Series(talib.RSI(data.values.astype(float), timeperiod=period), index=data.index)
+    
+    def kdj(self, high: pd.Series, low: pd.Series, close: pd.Series, 
+            n: int = 9, m1: int = 3, m2: int = 3) -> pd.DataFrame:
+        """Calculate KDJ indicator using TA-Lib."""
+        self.logger.info(f"Calculating KDJ(n={n}, m1={m1}, m2={m2})")
+        k, d = talib.STOCH(high.values.astype(float), low.values.astype(float), close.values.astype(float),
+                           fastk_period=n, slowk_period=m1, slowd_period=m2)
+        return pd.DataFrame({
+            'k': pd.Series(k, index=close.index),
+            'd': pd.Series(d, index=close.index),
+            'j': pd.Series(3 * k - 2 * d, index=close.index)
+        })
+    
+    def boll(self, data: pd.Series, period: int = 20, std_dev: float = 2) -> pd.DataFrame:
+        """Calculate Bollinger Bands using TA-Lib."""
+        self.logger.info(f"Calculating BOLL(period={period}, std_dev={std_dev})")
+        upper, middle, lower = talib.BBANDS(data.values.astype(float), timeperiod=period, 
+                                            nbdevup=std_dev, nbdevdn=std_dev, matype=0)
+        return pd.DataFrame({
+            'upper': pd.Series(upper, index=data.index),
+            'middle': pd.Series(middle, index=data.index),
+            'lower': pd.Series(lower, index=data.index)
+        })
+    
+    # Note: No separate alias; use boll() for consistency across providers
+    
+    def atr(self, high: pd.Series, low: pd.Series, close: pd.Series, period: int = 14) -> pd.Series:
+        """Calculate Average True Range (ATR) using TA-Lib."""
+        self.logger.info(f"Calculating ATR(period={period})")
+        return pd.Series(talib.ATR(high.values.astype(float), low.values.astype(float), 
+                                   close.values.astype(float), timeperiod=period), index=close.index)
+    
+    def obv(self, close: pd.Series, volume: pd.Series) -> pd.Series:
+        """Calculate On-Balance Volume (OBV) using TA-Lib."""
+        self.logger.info("Calculating OBV")
+        return pd.Series(talib.OBV(close.values.astype(float), volume.values.astype(float)), index=close.index)