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

deltafq/trading/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/trading/execution.py

@@ -0,0 +1,176 @@
+"""
+Trade execution engine for DeltaFQ.
+"""
+
+import pandas as pd
+from typing import Dict, List, Optional, Any
+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."""
+    
+    def __init__(self, broker=None, **kwargs):
+        """Initialize execution engine."""
+        super().__init__(**kwargs)
+        self.broker = broker
+        self.order_manager = OrderManager()
+        self.position_manager = PositionManager()
+        self.execution_history = []
+    
+    def initialize(self) -> bool:
+        """Initialize execution engine."""
+        self.logger.info("Initializing execution engine")
+        
+        if self.broker:
+            return self.broker.initialize()
+        
+        return True
+    
+    def execute_order(self, symbol: str, quantity: int, order_type: str = "market", 
+                     price: Optional[float] = None) -> str:
+        """Execute an order through the broker."""
+        try:
+            # 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:
+                # Simulate execution
+                current_price = self._get_simulated_price(symbol)
+                self._simulate_execution(order_id, current_price)
+                self.logger.info(f"Order executed in simulation: {order_id}")
+            
+            return order_id
+            
+        except Exception as e:
+            raise TradingError(f"Failed to execute order: {str(e)}")
+    
+    def _simulate_execution(self, order_id: str, execution_price: float):
+        """Simulate order execution."""
+        order = self.order_manager.get_order(order_id)
+        if not order:
+            return
+        
+        # Mark as executed
+        self.order_manager.mark_executed(order_id, execution_price)
+        
+        # Update position
+        symbol = order['symbol']
+        quantity = order['quantity']
+        
+        if quantity > 0:  # Buy
+            self.position_manager.add_position(symbol, quantity, execution_price)
+        else:  # Sell
+            self.position_manager.reduce_position(symbol, abs(quantity), execution_price)
+        
+        # Record execution
+        self.execution_history.append({
+            'order_id': order_id,
+            'symbol': symbol,
+            'quantity': quantity,
+            'execution_price': execution_price,
+            'timestamp': pd.Timestamp.now()
+        })
+    
+    def _get_simulated_price(self, symbol: str) -> float:
+        """Get simulated price for symbol."""
+        # Simple simulation - in real implementation this would come from market data
+        base_prices = {
+            'AAPL': 150.0,
+            'GOOGL': 2500.0,
+            'MSFT': 300.0,
+            'TSLA': 200.0
+        }
+        return base_prices.get(symbol, 100.0)
+    
+    def get_execution_summary(self) -> Dict[str, Any]:
+        """Get execution summary."""
+        return {
+            'total_orders': len(self.order_manager.get_order_history()),
+            'executed_orders': len(self.order_manager.get_executed_orders()),
+            'pending_orders': len(self.order_manager.get_pending_orders()),
+            'total_positions': len(self.position_manager.get_all_positions()),
+            'execution_history': self.execution_history
+        }
+    
+    def cancel_order(self, order_id: str) -> bool:
+        """Cancel an order."""
+        try:
+            # Cancel in order manager
+            success = self.order_manager.cancel_order(order_id)
+            
+            # Cancel with broker if available
+            if self.broker and success:
+                order = self.order_manager.get_order(order_id)
+                if order and 'broker_order_id' in order:
+                    self.broker.cancel_order(order['broker_order_id'])
+            
+            if success:
+                self.logger.info(f"Order cancelled: {order_id}")
+            
+            return success
+            
+        except Exception as e:
+            self.logger.error(f"Failed to cancel order: {str(e)}")
+            return False
+    
+    def get_order_status(self, order_id: str) -> Dict[str, Any]:
+        """Get order status."""
+        order = self.order_manager.get_order(order_id)
+        if not order:
+            return {}
+        
+        # Get status from broker if available
+        if self.broker and 'broker_order_id' in order:
+            broker_status = self.broker.get_order_status(order['broker_order_id'])
+            order.update(broker_status)
+        
+        return order
+    
+    def sync_with_broker(self) -> bool:
+        """Sync orders and positions with broker."""
+        if not self.broker:
+            return False
+        
+        try:
+            # Sync positions
+            broker_positions = self.broker.get_positions()
+            # Update position manager with broker positions
+            
+            # Sync order statuses
+            for order_id, order in self.order_manager.orders.items():
+                if 'broker_order_id' in order:
+                    broker_status = self.broker.get_order_status(order['broker_order_id'])
+                    order.update(broker_status)
+            
+            self.logger.info("Synced with broker")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to sync with broker: {str(e)}")
+            return False
+
+

deltafq/trading/order_manager.py

@@ -0,0 +1,111 @@
+"""
+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 = "market", 
+                    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/trading/position_manager.py

@@ -0,0 +1,157 @@
+"""
+Position management for DeltaFQ.
+"""
+
+from typing import Dict, Optional, Any
+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 = {}
+        self.position_history = []
+    
+    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."""
+        try:
+            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()
+                }
+            
+            # Record in history
+            self.position_history.append({
+                'symbol': symbol,
+                'quantity': quantity,
+                'price': price,
+                'action': 'add',
+                'timestamp': datetime.now()
+            })
+            
+            self.logger.info(f"Position updated: {symbol} -> {self.positions[symbol]['quantity']}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to add position: {str(e)}")
+            return False
+    
+    def reduce_position(self, symbol: str, quantity: int, price: Optional[float] = None) -> bool:
+        """Reduce existing position."""
+        try:
+            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:
+                # Close position
+                del self.positions[symbol]
+            else:
+                # Update position
+                self.positions[symbol]['quantity'] = new_quantity
+                self.positions[symbol]['updated_at'] = datetime.now()
+            
+            # Record in history
+            self.position_history.append({
+                'symbol': symbol,
+                'quantity': -quantity,
+                'price': price,
+                'action': 'reduce',
+                'timestamp': datetime.now()
+            })
+            
+            self.logger.info(f"Position reduced: {symbol} -> {new_quantity}")
+            return True
+            
+        except Exception as e:
+            self.logger.error(f"Failed to reduce position: {str(e)}")
+            return False
+    
+    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 get_position_details(self, symbol: str) -> Optional[Dict[str, Any]]:
+        """Get detailed position information."""
+        return self.positions.get(symbol)
+    
+    def get_all_position_details(self) -> Dict[str, Dict[str, Any]]:
+        """Get all position details."""
+        return dict(self.positions)
+    
+    def can_sell(self, symbol: str, quantity: int) -> bool:
+        """Check if we can sell the specified quantity."""
+        current_position = self.get_position(symbol)
+        return current_position >= quantity
+    
+    def get_position_value(self, symbol: str, current_price: float) -> float:
+        """Calculate position value at current price."""
+        quantity = self.get_position(symbol)
+        return quantity * current_price
+    
+    def get_total_position_value(self, current_prices: Dict[str, float]) -> float:
+        """Calculate total position value."""
+        total_value = 0.0
+        for symbol, position in self.positions.items():
+            if symbol in current_prices:
+                total_value += position['quantity'] * current_prices[symbol]
+        return total_value
+    
+    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)
+    
+    def close_all_positions(self, current_prices: Dict[str, float]) -> Dict[str, bool]:
+        """Close all positions."""
+        results = {}
+        symbols = list(self.positions.keys())
+        
+        for symbol in symbols:
+            results[symbol] = self.close_position(symbol, current_prices.get(symbol))
+        
+        return results
+
+