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

deltafq/__init__.py

@@ -1,31 +1,30 @@
-"""DeltaFQ - 专业的Python量化交易库
-
-一个面向量化策略开发者和量化研究人员的完整工具链。
-"""
-
-__version__ = "0.1.1"
-__author__ = "DeltaFQ Team"
-
-# 导入主要模块
-from deltafq import data
-from deltafq import indicators
-from deltafq import strategy
-from deltafq import backtest
-from deltafq import risk
-from deltafq import performance
-from deltafq import optimization
-from deltafq import trade
-from deltafq import utils
-
-__all__ = [
-    "data",
-    "indicators",
-    "strategy",
-    "backtest",
-    "risk",
-    "performance",
-    "optimization",
-    "trade",
-    "utils",
-]
-
+"""
+DeltaFQ - A comprehensive Python quantitative finance library.
+
+This library provides tools for strategy development, backtesting, 
+paper trading, and live trading.
+"""
+
+__version__ = "0.1.0"
+__author__ = "DeltaF"
+
+# Import core modules
+from . import core
+from . import data
+from . import strategy
+from . import backtest
+from . import indicators
+from . import trading
+from . import live
+
+__all__ = [
+    "core",
+    "data", 
+    "strategy",
+    "backtest",
+    "indicators",
+    "trading",
+    "live"
+]
+
+

deltafq/backtest/__init__.py

@@ -1,7 +1,17 @@
-"""回测引擎模块"""
-
-from deltafq.backtest.engine import BacktestEngine
-from deltafq.backtest.result import BacktestResult
-
-__all__ = ["BacktestEngine", "BacktestResult"]
-
+"""
+Backtesting module for DeltaFQ.
+"""
+
+from .engine import BacktestEngine
+from .performance import PerformanceAnalyzer
+from .metrics import MetricsCalculator
+from .reporter import BacktestReporter
+
+__all__ = [
+    "BacktestEngine",
+    "PerformanceAnalyzer",
+    "MetricsCalculator", 
+    "BacktestReporter"
+]
+
+

deltafq/backtest/engine.py

@@ -1,52 +1,99 @@
-"""回测引擎"""
-
-import pandas as pd
-from typing import Optional
-from deltafq.strategy.base import Strategy
-from deltafq.backtest.result import BacktestResult
-
-
-class BacktestEngine:
-    """回测引擎"""
-    
-    def __init__(
-        self,
-        initial_cash: float = 100000,
-        commission: float = 0.0003,
-        slippage: float = 0.0
-    ):
-        """初始化回测引擎
-        
-        Args:
-            initial_cash: 初始资金
-            commission: 手续费率
-            slippage: 滑点
-        """
-        self.initial_cash = initial_cash
-        self.commission = commission
-        self.slippage = slippage
-        
-    def run(
-        self,
-        data: pd.DataFrame,
-        strategy: Strategy
-    ) -> BacktestResult:
-        """运行回测
-        
-        Args:
-            data: 历史数据
-            strategy: 策略实例
-            
-        Returns:
-            回测结果
-        """
-        for idx, bar in data.iterrows():
-            strategy.on_bar(bar)
-        
-        result = BacktestResult(
-            initial_cash=self.initial_cash,
-            data=data,
-            signals=strategy.get_signals()
-        )
-        return result
-
+"""
+Backtesting engine for DeltaFQ.
+"""
+
+import pandas as pd
+from typing import Dict, Any, Optional
+from ..core.base import BaseComponent
+from ..core.exceptions import BacktestError
+
+
+class BacktestEngine(BaseComponent):
+    """Backtesting engine for strategy testing."""
+    
+    def __init__(self, initial_capital: float = 100000, commission: float = 0.001, **kwargs):
+        """Initialize backtest engine."""
+        super().__init__(**kwargs)
+        self.initial_capital = initial_capital
+        self.commission = commission
+        self.results = None
+    
+    def initialize(self) -> bool:
+        """Initialize backtest engine."""
+        self.logger.info(f"Initializing backtest engine with capital: {self.initial_capital}")
+        return True
+    
+    def run_backtest(self, strategy, data: pd.DataFrame) -> Dict[str, Any]:
+        """Run backtest for given strategy and data."""
+        try:
+            self.logger.info("Starting backtest")
+            
+            # Initialize portfolio
+            cash = self.initial_capital
+            positions = {}
+            trades = []
+            
+            # Run strategy on data
+            for i, (date, row) in enumerate(data.iterrows()):
+                # Get signals from strategy
+                signals = strategy.generate_signals(data.iloc[:i+1])
+                
+                if not signals.empty and i > 0:
+                    signal = signals.iloc[-1]
+                    
+                    # Execute trades based on signals
+                    if signal != 0:  # Buy or sell signal
+                        symbol = 'STOCK'  # Simplified for single asset
+                        price = row['close']
+                        quantity = int(signal * cash * 0.1 / price)  # Use 10% of cash
+                        
+                        if quantity > 0 and quantity * price <= cash:
+                            # Buy
+                            cost = quantity * price * (1 + self.commission)
+                            cash -= cost
+                            positions[symbol] = positions.get(symbol, 0) + quantity
+                            trades.append({
+                                'date': date,
+                                'symbol': symbol,
+                                'quantity': quantity,
+                                'price': price,
+                                'type': 'buy'
+                            })
+                        elif quantity < 0 and positions.get(symbol, 0) >= abs(quantity):
+                            # Sell
+                            quantity = abs(quantity)
+                            proceeds = quantity * price * (1 - self.commission)
+                            cash += proceeds
+                            positions[symbol] -= quantity
+                            trades.append({
+                                'date': date,
+                                'symbol': symbol,
+                                'quantity': -quantity,
+                                'price': price,
+                                'type': 'sell'
+                            })
+            
+            # Calculate final portfolio value
+            final_price = data['close'].iloc[-1]
+            final_value = cash + sum(positions.values()) * final_price
+            
+            self.results = {
+                'initial_capital': self.initial_capital,
+                'final_value': final_value,
+                'total_return': (final_value - self.initial_capital) / self.initial_capital,
+                'trades': trades,
+                'final_positions': positions,
+                'final_cash': cash
+            }
+            
+            self.logger.info(f"Backtest completed. Total return: {self.results['total_return']:.2%}")
+            return self.results
+            
+        except Exception as e:
+            raise BacktestError(f"Backtest failed: {str(e)}")
+    
+    def get_results(self) -> Optional[Dict[str, Any]]:
+        """Get backtest results."""
+        return self.results
+
+

deltafq/backtest/metrics.py

@@ -0,0 +1,113 @@
+"""
+Backtest metrics calculation.
+"""
+
+import pandas as pd
+import numpy as np
+from typing import Dict, Any
+from ..core.base import BaseComponent
+
+
+class MetricsCalculator(BaseComponent):
+    """Calculate various backtest metrics."""
+    
+    def initialize(self) -> bool:
+        """Initialize metrics calculator."""
+        self.logger.info("Initializing metrics calculator")
+        return True
+    
+    def calculate_trade_metrics(self, trades: list) -> Dict[str, Any]:
+        """Calculate trade-based metrics."""
+        if not trades:
+            return {}
+        
+        trade_df = pd.DataFrame(trades)
+        
+        # Separate buy and sell trades
+        buy_trades = trade_df[trade_df['type'] == 'buy']
+        sell_trades = trade_df[trade_df['type'] == 'sell']
+        
+        # Calculate P&L for each trade (simplified)
+        pnl = []
+        for _, sell_trade in sell_trades.iterrows():
+            # Find corresponding buy trade
+            buy_trade = buy_trades[buy_trades['symbol'] == sell_trade['symbol']].iloc[0]
+            trade_pnl = (sell_trade['price'] - buy_trade['price']) * sell_trade['quantity']
+            pnl.append(trade_pnl)
+        
+        if pnl:
+            pnl_series = pd.Series(pnl)
+            return {
+                'total_trades': len(pnl),
+                'winning_trades': (pnl_series > 0).sum(),
+                'losing_trades': (pnl_series < 0).sum(),
+                'win_rate': (pnl_series > 0).mean(),
+                'avg_win': pnl_series[pnl_series > 0].mean() if (pnl_series > 0).any() else 0,
+                'avg_loss': pnl_series[pnl_series < 0].mean() if (pnl_series < 0).any() else 0,
+                'total_pnl': pnl_series.sum()
+            }
+        
+        return {}
+    
+    def calculate_risk_metrics(self, returns: pd.Series) -> Dict[str, float]:
+        """Calculate risk-related metrics."""
+        if len(returns) == 0:
+            return {}
+        
+        # Value at Risk (VaR)
+        var_95 = np.percentile(returns, 5)
+        var_99 = np.percentile(returns, 1)
+        
+        # Conditional Value at Risk (CVaR)
+        cvar_95 = returns[returns <= var_95].mean()
+        cvar_99 = returns[returns <= var_99].mean()
+        
+        # Skewness and Kurtosis
+        skewness = returns.skew()
+        kurtosis = returns.kurtosis()
+        
+        return {
+            'var_95': var_95,
+            'var_99': var_99,
+            'cvar_95': cvar_95,
+            'cvar_99': cvar_99,
+            'skewness': skewness,
+            'kurtosis': kurtosis
+        }
+    
+    def calculate_portfolio_metrics(self, portfolio_values: pd.Series) -> Dict[str, float]:
+        """Calculate portfolio-level metrics."""
+        if len(portfolio_values) < 2:
+            return {}
+        
+        returns = portfolio_values.pct_change().dropna()
+        
+        # Rolling metrics
+        rolling_returns = returns.rolling(window=252)  # Annual window
+        
+        return {
+            'total_return': (portfolio_values.iloc[-1] / portfolio_values.iloc[0]) - 1,
+            'annualized_return': (1 + returns.mean()) ** 252 - 1,
+            'volatility': returns.std() * np.sqrt(252),
+            'sharpe_ratio': returns.mean() / returns.std() * np.sqrt(252) if returns.std() > 0 else 0,
+            'max_drawdown': self._calculate_max_drawdown(portfolio_values),
+            'calmar_ratio': self._calculate_calmar_ratio(returns)
+        }
+    
+    def _calculate_max_drawdown(self, values: pd.Series) -> float:
+        """Calculate maximum drawdown."""
+        peak = values.expanding().max()
+        drawdown = (values - peak) / peak
+        return drawdown.min()
+    
+    def _calculate_calmar_ratio(self, returns: pd.Series) -> float:
+        """Calculate Calmar ratio."""
+        annual_return = (1 + returns.mean()) ** 252 - 1
+        max_dd = abs(self._calculate_max_drawdown((1 + returns).cumprod()))
+        
+        if max_dd == 0:
+            return float('inf') if annual_return > 0 else 0.0
+        
+        return annual_return / max_dd
+
+

deltafq/backtest/performance.py

@@ -0,0 +1,81 @@
+"""
+Performance analysis for backtests.
+"""
+
+import pandas as pd
+import numpy as np
+from typing import Dict, List, Any
+from ..core.base import BaseComponent
+
+
+class PerformanceAnalyzer(BaseComponent):
+    """Analyze backtest performance."""
+    
+    def initialize(self) -> bool:
+        """Initialize performance analyzer."""
+        self.logger.info("Initializing performance analyzer")
+        return True
+    
+    def calculate_returns(self, prices: pd.Series) -> pd.Series:
+        """Calculate returns from price series."""
+        return prices.pct_change().dropna()
+    
+    def calculate_sharpe_ratio(self, returns: pd.Series, risk_free_rate: float = 0.02) -> float:
+        """Calculate Sharpe ratio."""
+        if len(returns) == 0 or returns.std() == 0:
+            return 0.0
+        
+        excess_returns = returns - risk_free_rate / 252  # Daily risk-free rate
+        return excess_returns.mean() / returns.std() * np.sqrt(252)
+    
+    def calculate_max_drawdown(self, returns: pd.Series) -> float:
+        """Calculate maximum drawdown."""
+        cumulative = (1 + returns).cumprod()
+        running_max = cumulative.expanding().max()
+        drawdown = (cumulative - running_max) / running_max
+        return drawdown.min()
+    
+    def calculate_volatility(self, returns: pd.Series) -> float:
+        """Calculate annualized volatility."""
+        return returns.std() * np.sqrt(252)
+    
+    def analyze_performance(self, returns: pd.Series, benchmark_returns: pd.Series = None) -> Dict[str, float]:
+        """Comprehensive performance analysis."""
+        analysis = {
+            'total_return': (1 + returns).prod() - 1,
+            'annualized_return': (1 + returns).prod() ** (252 / len(returns)) - 1,
+            'volatility': self.calculate_volatility(returns),
+            'sharpe_ratio': self.calculate_sharpe_ratio(returns),
+            'max_drawdown': self.calculate_max_drawdown(returns),
+            'win_rate': (returns > 0).mean(),
+            'profit_factor': self._calculate_profit_factor(returns)
+        }
+        
+        if benchmark_returns is not None:
+            analysis['alpha'] = self._calculate_alpha(returns, benchmark_returns)
+            analysis['beta'] = self._calculate_beta(returns, benchmark_returns)
+        
+        return analysis
+    
+    def _calculate_profit_factor(self, returns: pd.Series) -> float:
+        """Calculate profit factor."""
+        positive_returns = returns[returns > 0].sum()
+        negative_returns = abs(returns[returns < 0].sum())
+        
+        if negative_returns == 0:
+            return float('inf') if positive_returns > 0 else 0.0
+        
+        return positive_returns / negative_returns
+    
+    def _calculate_alpha(self, returns: pd.Series, benchmark_returns: pd.Series) -> float:
+        """Calculate alpha."""
+        # Simplified calculation
+        return returns.mean() - benchmark_returns.mean()
+    
+    def _calculate_beta(self, returns: pd.Series, benchmark_returns: pd.Series) -> float:
+        """Calculate beta."""
+        if benchmark_returns.var() == 0:
+            return 0.0
+        return returns.cov(benchmark_returns) / benchmark_returns.var()
+
+

deltafq/backtest/reporter.py

@@ -0,0 +1,91 @@
+"""
+Backtest report generation.
+"""
+
+import pandas as pd
+from typing import Dict, Any, Optional
+from ..core.base import BaseComponent
+
+
+class BacktestReporter(BaseComponent):
+    """Generate backtest reports."""
+    
+    def initialize(self) -> bool:
+        """Initialize backtest reporter."""
+        self.logger.info("Initializing backtest reporter")
+        return True
+    
+    def generate_summary_report(self, results: Dict[str, Any]) -> str:
+        """Generate a summary report."""
+        report = f"""
+=== Backtest Summary Report ===
+
+Initial Capital: ${results.get('initial_capital', 0):,.2f}
+Final Value: ${results.get('final_value', 0):,.2f}
+Total Return: {results.get('total_return', 0):.2%}
+
+Trades:
+- Total Trades: {len(results.get('trades', []))}
+- Final Cash: ${results.get('final_cash', 0):,.2f}
+- Final Positions: {results.get('final_positions', {})}
+
+=== End of Report ===
+        """
+        return report
+    
+    def generate_detailed_report(self, results: Dict[str, Any], performance_metrics: Dict[str, float]) -> str:
+        """Generate detailed report with performance metrics."""
+        report = f"""
+=== Detailed Backtest Report ===
+
+PORTFOLIO PERFORMANCE
+====================
+Initial Capital: ${results.get('initial_capital', 0):,.2f}
+Final Value: ${results.get('final_value', 0):,.2f}
+Total Return: {results.get('total_return', 0):.2%}
+
+PERFORMANCE METRICS
+==================
+Annualized Return: {performance_metrics.get('annualized_return', 0):.2%}
+Volatility: {performance_metrics.get('volatility', 0):.2%}
+Sharpe Ratio: {performance_metrics.get('sharpe_ratio', 0):.2f}
+Maximum Drawdown: {performance_metrics.get('max_drawdown', 0):.2%}
+Calmar Ratio: {performance_metrics.get('calmar_ratio', 0):.2f}
+
+TRADING METRICS
+===============
+Total Trades: {len(results.get('trades', []))}
+Final Cash: ${results.get('final_cash', 0):,.2f}
+Final Positions: {results.get('final_positions', {})}
+
+=== End of Detailed Report ===
+        """
+        return report
+    
+    def save_report(self, report: str, filename: str) -> bool:
+        """Save report to file."""
+        try:
+            with open(filename, 'w') as f:
+                f.write(report)
+            self.logger.info(f"Report saved to: {filename}")
+            return True
+        except Exception as e:
+            self.logger.error(f"Failed to save report: {str(e)}")
+            return False
+    
+    def export_trades_to_csv(self, trades: list, filename: str) -> bool:
+        """Export trades to CSV file."""
+        try:
+            if trades:
+                trade_df = pd.DataFrame(trades)
+                trade_df.to_csv(filename, index=False)
+                self.logger.info(f"Trades exported to: {filename}")
+                return True
+            else:
+                self.logger.warning("No trades to export")
+                return False
+        except Exception as e:
+            self.logger.error(f"Failed to export trades: {str(e)}")
+            return False
+
+

deltafq/core/__init__.py

@@ -0,0 +1,19 @@
+"""
+Core functionality for DeltaFQ.
+"""
+
+from .config import Config
+from .logger import Logger
+from .exceptions import DeltaFQError, DataError, TradingError
+from .base import BaseComponent
+
+__all__ = [
+    "Config",
+    "Logger", 
+    "DeltaFQError",
+    "DataError",
+    "TradingError",
+    "BaseComponent"
+]
+
+

deltafq/core/base.py

@@ -0,0 +1,37 @@
+"""
+Base classes for DeltaFQ components.
+"""
+
+from abc import ABC, abstractmethod
+from typing import Any, Dict
+from .logger import Logger
+from .config import Config
+
+
+class BaseComponent(ABC):
+    """Base class for all DeltaFQ components."""
+    
+    def __init__(self, name: str = None, config: Config = None):
+        """Initialize base component."""
+        self.name = name or self.__class__.__name__
+        self.config = config or Config()
+        self.logger = Logger(self.name)
+    
+    @abstractmethod
+    def initialize(self) -> bool:
+        """Initialize the component."""
+        pass
+    
+    def cleanup(self):
+        """Cleanup resources."""
+        pass
+    
+    def get_info(self) -> Dict[str, Any]:
+        """Get component information."""
+        return {
+            "name": self.name,
+            "class": self.__class__.__name__,
+            "config": self.config.config
+        }
+
+

deltafq/core/config.py

@@ -0,0 +1,63 @@
+"""
+Configuration management for DeltaFQ.
+"""
+
+import os
+from typing import Dict, Any
+from pathlib import Path
+
+
+class Config:
+    """Configuration manager for DeltaFQ."""
+    
+    def __init__(self, config_file: str = None):
+        """Initialize configuration."""
+        self.config = self._load_default_config()
+        if config_file and os.path.exists(config_file):
+            self._load_config_file(config_file)
+    
+    def _load_default_config(self) -> Dict[str, Any]:
+        """Load default configuration."""
+        return {
+            "data": {
+                "cache_dir": "./data_cache",
+                "default_source": "yahoo"
+            },
+            "trading": {
+                "initial_capital": 100000,
+                "commission": 0.001,
+                "slippage": 0.0005
+            },
+            "logging": {
+                "level": "INFO",
+                "format": "%(asctime)s - %(name)s - %(levelname)s - %(message)s"
+            }
+        }
+    
+    def _load_config_file(self, config_file: str):
+        """Load configuration from file."""
+        # Placeholder for config file loading
+        pass
+    
+    def get(self, key: str, default: Any = None) -> Any:
+        """Get configuration value."""
+        keys = key.split('.')
+        value = self.config
+        for k in keys:
+            if isinstance(value, dict) and k in value:
+                value = value[k]
+            else:
+                return default
+        return value
+    
+    def set(self, key: str, value: Any):
+        """Set configuration value."""
+        keys = key.split('.')
+        config = self.config
+        for k in keys[:-1]:
+            if k not in config:
+                config[k] = {}
+            config = config[k]
+        config[keys[-1]] = value
+
+