deltafq 0.1.0__tar.gz → 0.1.2__tar.gz

{deltafq-0.1.0 → deltafq-0.1.2}/LICENSE

@@ -1,22 +1,21 @@
-MIT License
-
-Copyright (c) 2025 DeltaFQ Team
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
+MIT License
+
+Copyright (c) 2025 DeltaF
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

deltafq-0.1.2/PKG-INFO

@@ -0,0 +1,89 @@
+Metadata-Version: 2.4
+Name: deltafq
+Version: 0.1.2
+Summary: A comprehensive Python quantitative finance library
+Author-email: DeltaF <leek_li@outlook.com>
+License: MIT
+Project-URL: Homepage, https://github.com/Delta-F/deltafq
+Project-URL: Repository, https://github.com/Delta-F/deltafq
+Project-URL: Issues, https://github.com/Delta-F/deltafq/issues
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.8
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Classifier: Topic :: Scientific/Engineering :: Mathematics
+Requires-Python: >=3.8
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: numpy>=1.21.0
+Requires-Dist: pandas>=1.3.0
+Requires-Dist: scipy>=1.7.0
+Requires-Dist: matplotlib>=3.4.0
+Requires-Dist: seaborn>=0.11.0
+Requires-Dist: plotly>=5.0.0
+Requires-Dist: yfinance>=0.1.70
+Requires-Dist: requests>=2.25.0
+Provides-Extra: dev
+Requires-Dist: pytest>=6.2.0; extra == "dev"
+Requires-Dist: pytest-cov>=2.12.0; extra == "dev"
+Requires-Dist: black>=21.0.0; extra == "dev"
+Requires-Dist: flake8>=3.9.0; extra == "dev"
+Requires-Dist: sphinx>=4.0.0; extra == "dev"
+Dynamic: license-file
+
+# DeltaFQ
+
+A comprehensive Python quantitative finance library for strategy development, backtesting, and live trading.
+
+## Features
+
+- **Data Management**: Efficient data fetching, cleaning, and storage
+- **Strategy Framework**: Flexible strategy development framework
+- **Backtesting**: High-performance historical data backtesting
+- **Paper Trading**: Risk-free strategy testing with simulated trading
+- **Live Trading**: Real-time trading with broker integration
+- **Technical Indicators**: Rich library of technical analysis indicators
+- **Risk Management**: Built-in risk control modules
+
+## Installation
+
+```bash
+pip install deltafq
+```
+
+## Quick Start
+
+```python
+import deltafq as dfq
+
+# Fetch market data
+data = dfq.data.fetch_stock_data('AAPL', start='2023-01-01')
+
+# Create and test a strategy
+strategy = dfq.strategy.MovingAverageStrategy(fast_period=10, slow_period=20)
+results = dfq.backtest.run_backtest(strategy, data)
+
+# Run paper trading
+simulator = dfq.trading.PaperTradingSimulator(initial_capital=100000)
+simulator.run_strategy(strategy, data)
+```
+
+## Documentation
+
+- [API Reference](docs/api_reference/)
+- [Tutorials](docs/tutorials/)
+- [Examples](examples/)
+
+## Contributing
+
+Please read our [Contributing Guide](CONTRIBUTING.md) for details on our code of conduct and the process for submitting pull requests.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

deltafq-0.1.2/README.md

@@ -0,0 +1,50 @@
+# DeltaFQ
+
+A comprehensive Python quantitative finance library for strategy development, backtesting, and live trading.
+
+## Features
+
+- **Data Management**: Efficient data fetching, cleaning, and storage
+- **Strategy Framework**: Flexible strategy development framework
+- **Backtesting**: High-performance historical data backtesting
+- **Paper Trading**: Risk-free strategy testing with simulated trading
+- **Live Trading**: Real-time trading with broker integration
+- **Technical Indicators**: Rich library of technical analysis indicators
+- **Risk Management**: Built-in risk control modules
+
+## Installation
+
+```bash
+pip install deltafq
+```
+
+## Quick Start
+
+```python
+import deltafq as dfq
+
+# Fetch market data
+data = dfq.data.fetch_stock_data('AAPL', start='2023-01-01')
+
+# Create and test a strategy
+strategy = dfq.strategy.MovingAverageStrategy(fast_period=10, slow_period=20)
+results = dfq.backtest.run_backtest(strategy, data)
+
+# Run paper trading
+simulator = dfq.trading.PaperTradingSimulator(initial_capital=100000)
+simulator.run_strategy(strategy, data)
+```
+
+## Documentation
+
+- [API Reference](docs/api_reference/)
+- [Tutorials](docs/tutorials/)
+- [Examples](examples/)
+
+## Contributing
+
+Please read our [Contributing Guide](CONTRIBUTING.md) for details on our code of conduct and the process for submitting pull requests.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

deltafq-0.1.2/deltafq/__init__.py

@@ -0,0 +1,30 @@
+"""
+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-0.1.2/deltafq/backtest/__init__.py

@@ -0,0 +1,17 @@
+"""
+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-0.1.2/deltafq/backtest/engine.py

@@ -0,0 +1,99 @@
+"""
+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-0.1.2/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-0.1.2/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-0.1.2/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-0.1.2/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-0.1.2/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
+        }
+
+