deltafq 0.4.0__py3-none-any.whl

deltafq/trader/broker.py

@@ -0,0 +1,119 @@
+"""
+Broker interface for live trading.
+"""
+
+import pandas as pd
+from abc import ABC, abstractmethod
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+from ..core.base import BaseComponent
+from ..core.exceptions import TradingError
+
+
+class Broker(BaseComponent, ABC):
+    """Abstract broker interface for live trading."""
+    
+    def initialize(self) -> bool:
+        """Initialize broker connection."""
+        self.logger.info("Initializing broker connection")
+        return self._connect()
+    
+    @abstractmethod
+    def _connect(self) -> bool:
+        """Connect to broker."""
+        pass
+    
+    @abstractmethod
+    def place_order(self, symbol: str, quantity: int, order_type: str, 
+                   price: Optional[float] = None) -> str:
+        """Place an order with the broker."""
+        pass
+    
+    @abstractmethod
+    def cancel_order(self, order_id: str) -> bool:
+        """Cancel an order."""
+        pass
+    
+    @abstractmethod
+    def get_order_status(self, order_id: str) -> Dict[str, Any]:
+        """Get order status."""
+        pass
+    
+    @abstractmethod
+    def get_account_info(self) -> Dict[str, Any]:
+        """Get account information."""
+        pass
+    
+    @abstractmethod
+    def get_positions(self) -> Dict[str, Dict[str, Any]]:
+        """Get current positions."""
+        pass
+    
+    @abstractmethod
+    def get_current_price(self, symbol: str) -> float:
+        """Get current price for symbol."""
+        pass
+
+
+class MockBroker(Broker):
+    """Mock broker for testing purposes."""
+    
+    def __init__(self, **kwargs):
+        """Initialize mock broker."""
+        super().__init__(**kwargs)
+        self.orders = {}
+        self.positions = {}
+        self.account_balance = 100000
+        self.order_counter = 0
+    
+    def _connect(self) -> bool:
+        """Mock connection."""
+        self.logger.info("Connected to mock broker")
+        return True
+    
+    def place_order(self, symbol: str, quantity: int, order_type: str, 
+                   price: Optional[float] = None) -> str:
+        """Place a mock order."""
+        self.order_counter += 1
+        order_id = f"MOCK_{self.order_counter}"
+        
+        self.orders[order_id] = {
+            'symbol': symbol,
+            'quantity': quantity,
+            'order_type': order_type,
+            'price': price,
+            'status': 'pending',
+                        'timestamp': datetime.now()
+        }
+        
+        self.logger.info(f"Mock order placed: {order_id}")
+        return order_id
+    
+    def cancel_order(self, order_id: str) -> bool:
+        """Cancel a mock order."""
+        if order_id in self.orders:
+            self.orders[order_id]['status'] = 'cancelled'
+            self.logger.info(f"Mock order cancelled: {order_id}")
+            return True
+        return False
+    
+    def get_order_status(self, order_id: str) -> Dict[str, Any]:
+        """Get mock order status."""
+        return self.orders.get(order_id, {})
+    
+    def get_account_info(self) -> Dict[str, Any]:
+        """Get mock account info."""
+        return {
+            'balance': self.account_balance,
+            'buying_power': self.account_balance,
+            'equity': self.account_balance
+        }
+    
+    def get_positions(self) -> Dict[str, Dict[str, Any]]:
+        """Get mock positions."""
+        return self.positions
+    
+    def get_current_price(self, symbol: str) -> float:
+        """Get mock current price."""
+        # Return a mock price
+        return 100.0

deltafq/trader/engine.py

@@ -0,0 +1,174 @@
+"""
+Trade execution engine for DeltaFQ.
+"""
+
+import pandas as pd
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+from ..core.base import BaseComponent
+from ..core.exceptions import TradingError
+from .order_manager import OrderManager
+from .position_manager import PositionManager
+
+
+class ExecutionEngine(BaseComponent):
+    """
+    Trade execution engine for real-time trading.
+    Supports paper trading (broker=None) and live trading (broker=Broker).
+    Paper trading manages cash internally. Live trading uses broker for account info.
+    """
+    
+    def __init__(self, broker=None, initial_capital: Optional[float] = None,
+                 commission: float = 0.001, **kwargs):
+        """
+        Initialize execution engine.
+        Args:
+            broker: Broker for live trading. None for paper trading.
+            initial_capital: Initial capital for paper trading. Defaults to 1000000.
+            commission: Commission rate for paper trading. Defaults to 0.001.
+        """
+        super().__init__(**kwargs)
+        self.broker = broker
+        self.order_manager = OrderManager()
+        self.position_manager = PositionManager()
+        
+        # Paper trading mode: manage cash internally
+        if broker is None:
+            self.initial_capital = initial_capital if initial_capital is not None else 1000000
+            self.cash = self.initial_capital
+            self.commission = commission
+            self.trades: List[Dict[str, Any]] = []
+            self.is_paper_trading = True
+        else:
+            # Live trading mode: get account info from broker
+            self.cash = None
+            self.commission = None
+            self.trades = []
+            self.is_paper_trading = False
+    
+    def initialize(self) -> bool:
+        """Initialize execution engine."""
+        if self.is_paper_trading:
+            self.logger.info(f"Initializing paper trading execution engine with capital: {self.initial_capital}")
+        else:
+            self.logger.info("Initializing live trading execution engine")
+        
+        if self.broker:
+            return self.broker.initialize()
+        
+        return True
+    
+    def execute_order(self, symbol: str, quantity: int, order_type: str = "limit", 
+                     price: Optional[float] = None, timestamp: Optional[datetime] = None) -> str:
+        """Execute an order. Default is limit order (price required)."""
+        try:
+            # Validate price for limit orders
+            if order_type == "limit" and price is None:
+                raise TradingError("Price is required for limit orders")
+            
+            # Create order
+            order_id = self.order_manager.create_order(
+                symbol=symbol,
+                quantity=quantity,
+                order_type=order_type,
+                price=price
+            )
+            
+            # Execute through broker
+            if self.broker:
+                broker_order_id = self.broker.place_order(
+                    symbol=symbol,
+                    quantity=quantity,
+                    order_type=order_type,
+                    price=price
+                )
+                
+                # Update order with broker ID
+                order = self.order_manager.get_order(order_id)
+                if order:
+                    order['broker_order_id'] = broker_order_id
+                
+                self.logger.info(f"Order executed through broker: {order_id} -> {broker_order_id}")
+            else:
+                self._execute_paper_trade(order_id, price, timestamp)
+                self.logger.info(f"Order executed in paper trading: {order_id}, timestamp: {timestamp}")
+            
+            return order_id
+            
+        except Exception as e:
+            raise TradingError(f"Failed to execute order: {str(e)}")
+    
+    def _execute_paper_trade(self, order_id: str, execution_price: float, timestamp: Optional[datetime] = None):
+        """Execute paper trading with cash management."""
+        order = self.order_manager.get_order(order_id)
+        if not order:
+            return
+        
+        symbol = order['symbol']
+        quantity = order['quantity']
+        timestamp = timestamp or datetime.now()
+        
+        if quantity > 0:  # Buy
+            gross_cost = quantity * execution_price
+            commission_amount = gross_cost * self.commission
+            total_cost = gross_cost + commission_amount
+            
+            if total_cost <= self.cash:
+                self.cash -= total_cost
+                self.position_manager.add_position(symbol, quantity, execution_price)
+                self.order_manager.mark_executed(order_id, execution_price)
+                
+                # Record trade (unified record with full details)
+                self.trades.append({
+                    'order_id': order_id,
+                    'symbol': symbol,
+                    'quantity': quantity,
+                    'price': execution_price,
+                    'type': 'buy',
+                    'timestamp': timestamp,
+                    'commission': commission_amount,
+                    'cost': total_cost
+                })
+            else:
+                self.logger.warning(f"Insufficient cash for buy: need {total_cost:.2f}, have {self.cash:.2f}")
+                self.order_manager.cancel_order(order_id)
+        else:  # Sell
+            quantity = abs(quantity)
+            if self.position_manager.can_sell(symbol, quantity):
+                gross_revenue = quantity * execution_price
+                commission_amount = gross_revenue * self.commission
+                net_revenue = gross_revenue - commission_amount
+                
+                # Calculate profit/loss
+                buy_cost = self._get_latest_buy_cost(symbol)
+                profit_loss = net_revenue - buy_cost if buy_cost else net_revenue
+                
+                self.position_manager.reduce_position(symbol, quantity, execution_price)
+                self.cash += net_revenue
+                self.order_manager.mark_executed(order_id, execution_price)
+                
+                # Record trade (unified record with full details)
+                self.trades.append({
+                    'order_id': order_id,
+                    'symbol': symbol,
+                    'quantity': quantity,
+                    'price': execution_price,
+                    'type': 'sell',
+                    'timestamp': timestamp,
+                    'commission': commission_amount,
+                    'gross_revenue': gross_revenue,
+                    'net_revenue': net_revenue,
+                    'buy_cost': buy_cost,
+                    'profit_loss': profit_loss
+                })
+            else:
+                self.logger.warning(f"Insufficient position for sell: {symbol}, need {quantity}")
+                self.order_manager.cancel_order(order_id)
+    
+    def _get_latest_buy_cost(self, symbol: str) -> float:
+        """Get the latest buy cost for a symbol (for PnL calculation)."""
+        for trade in reversed(self.trades):
+            if trade.get('symbol') == symbol and trade.get('type') == 'buy':
+                return float(trade.get('cost', 0.0))
+        return 0.0
+

deltafq/trader/order_manager.py

@@ -0,0 +1,110 @@
+"""
+Order management system for DeltaFQ.
+"""
+
+import pandas as pd
+from typing import Dict, List, Optional, Any
+from datetime import datetime
+from ..core.base import BaseComponent
+
+
+class OrderManager(BaseComponent):
+    """Manage trading orders."""
+    
+    def __init__(self, **kwargs):
+        """Initialize order manager."""
+        super().__init__(**kwargs)
+        self.orders = {}
+        self.order_counter = 0
+    
+    def initialize(self) -> bool:
+        """Initialize order manager."""
+        self.logger.info("Initializing order manager")
+        return True
+    
+    def create_order(self, symbol: str, quantity: int, order_type: str = "limit", 
+                    price: Optional[float] = None, stop_price: Optional[float] = None) -> str:
+        """Create a new order."""
+        self.order_counter += 1
+        order_id = f"ORD_{self.order_counter:06d}"
+        
+        order = {
+            'id': order_id,
+            'symbol': symbol,
+            'quantity': quantity,
+            'order_type': order_type,
+            'price': price,
+            'stop_price': stop_price,
+            'status': 'pending',
+            'created_at': datetime.now(),
+            'updated_at': datetime.now()
+        }
+        
+        self.orders[order_id] = order
+        self.logger.info(f"Order created: {order_id}")
+        return order_id
+    
+    def get_order(self, order_id: str) -> Optional[Dict[str, Any]]:
+        """Get order by ID."""
+        return self.orders.get(order_id)
+    
+    def update_order_status(self, order_id: str, status: str) -> bool:
+        """Update order status."""
+        if order_id in self.orders:
+            self.orders[order_id]['status'] = status
+            self.orders[order_id]['updated_at'] = datetime.now()
+            return True
+        return False
+    
+    def mark_executed(self, order_id: str, execution_price: Optional[float] = None) -> bool:
+        """Mark order as executed."""
+        if order_id in self.orders:
+            self.orders[order_id]['status'] = 'executed'
+            self.orders[order_id]['execution_price'] = execution_price
+            self.orders[order_id]['executed_at'] = datetime.now()
+            self.orders[order_id]['updated_at'] = datetime.now()
+            return True
+        return False
+    
+    def cancel_order(self, order_id: str) -> bool:
+        """Cancel an order."""
+        if order_id in self.orders and self.orders[order_id]['status'] == 'pending':
+            self.orders[order_id]['status'] = 'cancelled'
+            self.orders[order_id]['updated_at'] = datetime.now()
+            return True
+        return False
+    
+    def get_orders_by_symbol(self, symbol: str) -> List[Dict[str, Any]]:
+        """Get all orders for a symbol."""
+        return [order for order in self.orders.values() if order['symbol'] == symbol]
+    
+    def get_orders_by_status(self, status: str) -> List[Dict[str, Any]]:
+        """Get all orders with specific status."""
+        return [order for order in self.orders.values() if order['status'] == status]
+    
+    def get_pending_orders(self) -> List[Dict[str, Any]]:
+        """Get all pending orders."""
+        return self.get_orders_by_status('pending')
+    
+    def get_executed_orders(self) -> List[Dict[str, Any]]:
+        """Get all executed orders."""
+        return self.get_orders_by_status('executed')
+    
+    def get_order_history(self) -> List[Dict[str, Any]]:
+        """Get complete order history."""
+        return list(self.orders.values())
+    
+    def cleanup_old_orders(self, days: int = 30) -> int:
+        """Clean up old orders."""
+        cutoff_date = datetime.now() - pd.Timedelta(days=days)
+        old_orders = [
+            order_id for order_id, order in self.orders.items()
+            if order['created_at'] < cutoff_date and order['status'] in ['executed', 'cancelled']
+        ]
+        
+        for order_id in old_orders:
+            del self.orders[order_id]
+        
+        self.logger.info(f"Cleaned up {len(old_orders)} old orders")
+        return len(old_orders)
+

deltafq/trader/position_manager.py

@@ -0,0 +1,92 @@
+"""
+Position management for DeltaFQ.
+"""
+
+from typing import Dict, Optional
+from datetime import datetime
+from ..core.base import BaseComponent
+
+
+class PositionManager(BaseComponent):
+    """Manage trading positions."""
+    
+    def __init__(self, **kwargs):
+        """Initialize position manager."""
+        super().__init__(**kwargs)
+        self.positions = {}
+    
+    def initialize(self) -> bool:
+        """Initialize position manager."""
+        self.logger.info("Initializing position manager")
+        return True
+    
+    def add_position(self, symbol: str, quantity: int, price: Optional[float] = None) -> bool:
+        """Add to existing position or create new position."""
+        if symbol in self.positions:
+            # Update existing position
+            current_quantity = self.positions[symbol]['quantity']
+            current_avg_price = self.positions[symbol]['avg_price']
+            
+            new_quantity = current_quantity + quantity
+            if price:
+                new_avg_price = ((current_quantity * current_avg_price) + (quantity * price)) / new_quantity
+            else:
+                new_avg_price = current_avg_price
+            
+            self.positions[symbol]['quantity'] = new_quantity
+            self.positions[symbol]['avg_price'] = new_avg_price
+            self.positions[symbol]['updated_at'] = datetime.now()
+        else:
+            # Create new position
+            self.positions[symbol] = {
+                'symbol': symbol,
+                'quantity': quantity,
+                'avg_price': price or 0.0,
+                'created_at': datetime.now(),
+                'updated_at': datetime.now()
+            }
+        
+        self.logger.info(f"Position updated: {symbol} -> {self.positions[symbol]['quantity']}")
+        return True
+    
+    def reduce_position(self, symbol: str, quantity: int, price: Optional[float] = None) -> bool:
+        """Reduce existing position."""
+        if symbol not in self.positions:
+            self.logger.warning(f"No position found for symbol: {symbol}")
+            return False
+        
+        current_quantity = self.positions[symbol]['quantity']
+        if current_quantity < quantity:
+            self.logger.warning(f"Insufficient position: {symbol}")
+            return False
+        
+        new_quantity = current_quantity - quantity
+        
+        if new_quantity == 0:
+            del self.positions[symbol]
+        else:
+            self.positions[symbol]['quantity'] = new_quantity
+            self.positions[symbol]['updated_at'] = datetime.now()
+        
+        self.logger.info(f"Position reduced: {symbol} -> {new_quantity}")
+        return True
+    
+    def get_position(self, symbol: str) -> int:
+        """Get current position quantity for symbol."""
+        return self.positions.get(symbol, {}).get('quantity', 0)
+    
+    def get_all_positions(self) -> Dict[str, int]:
+        """Get all current positions."""
+        return {symbol: pos['quantity'] for symbol, pos in self.positions.items()}
+    
+    def can_sell(self, symbol: str, quantity: int) -> bool:
+        """Check if we can sell the specified quantity."""
+        return self.get_position(symbol) >= quantity
+    
+    def close_position(self, symbol: str, price: Optional[float] = None) -> bool:
+        """Close entire position for symbol."""
+        if symbol not in self.positions:
+            return False
+        
+        quantity = self.positions[symbol]['quantity']
+        return self.reduce_position(symbol, quantity, price)

deltafq-0.4.0.dist-info/METADATA

@@ -0,0 +1,115 @@
+Metadata-Version: 2.4
+Name: deltafq
+Version: 0.4.0
+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: yfinance>=0.1.70
+Requires-Dist: requests>=2.25.0
+Provides-Extra: viz
+Requires-Dist: plotly>=5.0.0; extra == "viz"
+Provides-Extra: talib
+Requires-Dist: TA-Lib>=0.4.24; extra == "talib"
+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
+
+Modern Python library for strategy research, backtesting, paper/live trading, and streamlined reporting.
+
+## Highlights
+
+- **Clean architecture**: `data` → `strategy` (signals) → `backtest` (execution + metrics)
+- **Execution engine**: Unified order routing for paper/live trading via a `Broker` abstraction
+- **Indicators**: Rich `TechnicalIndicators` (SMA/EMA/RSI/KDJ/BOLL/ATR/…)
+- **Signals**: Simple, composable `SignalGenerator` helpers (e.g., Bollinger `touch`/`cross`/`cross_current`)
+- **Reports**: Console-friendly summary with i18n (Chinese/English) powered by `PerformanceReporter`
+- **Charts**: `PerformanceChart` delivers Matplotlib or Plotly (optional) performance dashboards
+
+## Install
+
+```bash
+pip install deltafq
+```
+
+## 60-second Quick Start (Bollinger strategy)
+
+```python
+import deltafq as dfq
+
+symbol = "AAPL"
+fetcher = dfq.data.DataFetcher()
+indicators = dfq.indicators.TechnicalIndicators()
+generator = dfq.strategy.SignalGenerator()
+engine = dfq.backtest.BacktestEngine(initial_capital=100_000)
+reporter = dfq.backtest.PerformanceReporter()
+chart = dfq.charts.PerformanceChart()
+
+data = fetcher.fetch_data(symbol, "2023-01-01", "2023-12-31", clean=True)
+bands = indicators.boll(data["Close"], period=20, std_dev=2)
+signals = generator.boll_signals(price=data["Close"], bands=bands, method="cross_current")
+
+trades_df, values_df = engine.run_backtest(symbol, signals, data["Close"], strategy_name="BOLL")
+
+# Text summary (zh/en available)
+reporter.print_summary(
+    symbol=symbol,
+    trades_df=trades_df,
+    values_df=values_df,
+    title=f"{symbol} BOLL Strategy",
+    language="en",
+)
+
+# Optional performance dashboard (Matplotlib by default; set use_plotly=True for interactive charts)
+chart.plot_backtest_charts(values_df=values_df, benchmark_close=data["Close"], title=f"{symbol} BOLL Strategy")
+```
+
+## What’s inside
+
+- `deltafq/data`: fetching, cleaning, validation
+- `deltafq/indicators`: classic TA indicators
+- `deltafq/strategy`: signal generation + BaseStrategy helpers
+- `deltafq/backtest`: execution via `ExecutionEngine`; reporting via `PerformanceReporter`
+- `deltafq/charts`: signal and performance charts (Matplotlib + optional Plotly)
+
+## Examples
+
+See the `examples/` folder for ready-to-run scripts:
+
+- `04_backtest_result.py`: Bollinger strategy summary + charts
+- `05_visualize_charts.py`: standalone visualization demos
+- `06_base_strategy`: implement a moving-average cross using `BaseStrategy`
+
+## Contributing
+
+Contributions are welcome! Please open an issue or submit a PR.
+
+## License
+
+MIT License – see [LICENSE](LICENSE).

deltafq-0.4.0.dist-info/RECORD

@@ -0,0 +1,42 @@
+deltafq/__init__.py,sha256=aSYOpWiM3MuD_bF61ckgxNGSOFnW7Q1VE_t5eg4sNPA,535
+deltafq/backtest/__init__.py,sha256=RNOK7AwB2wdJrgcYXc3ok5E7pax3-rzI_g73dEv7aYc,771
+deltafq/backtest/engine.py,sha256=D-wbIHcawdgMvZikUvgLB7hpwYVVpaEY2gSH1yu4jtE,6283
+deltafq/backtest/metrics.py,sha256=zxJuxTrVOkZPlSAbrnfS6l61LEPx4Vr8I8nHX588jOI,2331
+deltafq/backtest/performance.py,sha256=Xi6J0GDrt0_0r-4cY8TVNNt6SUzPimaV2RDCXC0J7Xs,14091
+deltafq/charts/__init__.py,sha256=-vKa-dhgt_f3EfBf5-QgUVwTNSnoudxhbUXuJWvARmQ,249
+deltafq/charts/performance.py,sha256=P0povd-9rCqm4IYbREd4-U0xzr96zvFybCuHl2LVAkU,13861
+deltafq/charts/price.py,sha256=8oq0_Z_ZX5hoM2BtKYgHNM6JjYxBqSXLA9pA04UQ3SU,2251
+deltafq/charts/signals.py,sha256=cz7EGE7LBQXM7d1Xf3LMXnl5lH2rZKJKgKzLjfLBRcM,7678
+deltafq/core/__init__.py,sha256=ZIc0Bb9n09Hpqk1Zv2fTKFNIu9NgUCMs3XGbRQGWiJQ,329
+deltafq/core/base.py,sha256=2wgZ5BoN5-tHyQDgEwVBT6AByFsgLIKN9KEUVbOzCG8,510
+deltafq/core/config.py,sha256=9S7APw7zayCxjzcRh71zX7jqJGDlpVMcWoW-lcJnwBY,1840
+deltafq/core/exceptions.py,sha256=58zP4yMgeWj4aLCv3SLbTGmmh6psoxVWWu-QkdtC1bM,655
+deltafq/core/logger.py,sha256=FVVaYjJmWlN2DCpKEUTU_4HuzqCsx7uohLwgHxevOuM,1293
+deltafq/data/__init__.py,sha256=xSrxuhlC3Rvlp2I5_yz3Cp-XqxDG_3j08ecawaoy1Fk,291
+deltafq/data/cleaner.py,sha256=RuqqPgNHizJ16e0TUAtS3pnftphxvRBKKAhfGtXs7aQ,1289
+deltafq/data/fetcher.py,sha256=mGqoEwRAotCPgqlum2OGpjztN1hsNwilkAm4K1MPW_g,2060
+deltafq/data/storage.py,sha256=hKurYcWN0jlBGd6TqYle-BMooZ2q_CwoGjaM7BRWeOs,10889
+deltafq/data/validator.py,sha256=hFCYXaHNGlqEIcc8hv8F1Nc88JaBzI9nzgylePKVRaw,1813
+deltafq/indicators/__init__.py,sha256=3iMKAj6DL3Hu01ZwtCE8ynUkU2o4cdoLSDddOFLceyY,294
+deltafq/indicators/fundamental.py,sha256=tT6OsdfR7114QUBaDG8_4QH_3k68FVitgh5bmhmYS7E,827
+deltafq/indicators/talib_indicators.py,sha256=EpvnUXpOCYNDzAT60X-kLo0iHVmRg59E-MtF7KkHNeg,3424
+deltafq/indicators/technical.py,sha256=dnXUEfru4XedU1jcB6mXthB7ZPIsQyBwC2iHoKOSBUg,10763
+deltafq/live/__init__.py,sha256=nEB4zVk68zAJEaCcP5os6cJ8jc6cm-RlvL0yw3q9z-c,322
+deltafq/live/connection.py,sha256=efjTC6T-37wmELIAJUXDJnzcj0zGislPswLxq54rmOI,8613
+deltafq/live/data_feed.py,sha256=Cl7UTKgwKeNvuQ2HyLHsPgt0V_Kh5PU76XmW4c1V10w,5784
+deltafq/live/monitoring.py,sha256=-akC_mhtlCbdbKExMGhTour9M0R89C84KulpHsM1p40,7067
+deltafq/live/risk_control.py,sha256=rYijF7K_YkV-CaDUEGn6BoV851GT-llBw-p4HRwEHxY,7773
+deltafq/strategy/__init__.py,sha256=VsoXJrtLbKy9z1Mwnp1m7RkB7bewjeBU0HcQyVAycZs,176
+deltafq/strategy/base.py,sha256=R2zCs2oVm68B2MgHYtEBC3_olZG1T82dT4AiLAiZFSA,1235
+deltafq/strategy/signals.py,sha256=a2I0I-FfA5dlMLOVT7FSdxIX0SOhu4jtte8lVwyI0b4,8807
+deltafq/trader/__init__.py,sha256=AoxAD0QHECZUn8xTY_VvpzD4olQ0GTJZTglVSco3yr0,296
+deltafq/trader/broker.py,sha256=e0E2LJO9CXP3w0mcsijkYfhqOxZ2Est0P0iPFS985x8,3644
+deltafq/trader/engine.py,sha256=YA3KQhQ6qmcQzE26ljNkswVFnBHHvdl0sAcbxIhseMU,7423
+deltafq/trader/order_manager.py,sha256=rSo5OrF_7I-zeYZ1FG3R80ucLTAHF6cpXQI1pMM7ETc,4154
+deltafq/trader/position_manager.py,sha256=fJ2MbjTS5TMEDw5kqHqY3_KLKxcGLS2hvAUb1skbsjw,3621
+deltafq-0.4.0.dist-info/licenses/LICENSE,sha256=_NsOVmjUmvFiFNOp8vowVeILNMu9CRuudY6PeVIikSA,1084
+deltafq-0.4.0.dist-info/METADATA,sha256=LUqGqYmMvByViGr3FTVMnVxNqtWYQo2Oit-J86PoKaY,4319
+deltafq-0.4.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+deltafq-0.4.0.dist-info/entry_points.txt,sha256=TVBHZfYgwrYpVZfsBonsJriXHkZm1CvBvnDW7--cxl0,45
+deltafq-0.4.0.dist-info/top_level.txt,sha256=j1Q3ce7BEqdXVZd-mlHiJBDHq3iJGiKRKEXPW8xHLHo,8
+deltafq-0.4.0.dist-info/RECORD,,

deltafq-0.4.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.9.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

deltafq-0.4.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+deltafq = deltafq.cli:main