showing trades on realtime chart - chart broken

NN/exchanges/exchange_interface.py

@@ -0,0 +1,191 @@
+import abc
+import logging
+from typing import Dict, Any, List, Tuple, Optional
+
+logger = logging.getLogger(__name__)
+
+class ExchangeInterface(abc.ABC):
+    """Base class for all exchange interfaces.
+    
+    This abstract class defines the required methods that all exchange
+    implementations must provide to ensure compatibility with the trading system.
+    """
+    
+    def __init__(self, api_key: str = None, api_secret: str = None, test_mode: bool = True):
+        """Initialize the exchange interface.
+        
+        Args:
+            api_key: API key for the exchange
+            api_secret: API secret for the exchange
+            test_mode: If True, use test/sandbox environment
+        """
+        self.api_key = api_key
+        self.api_secret = api_secret
+        self.test_mode = test_mode
+        self.client = None
+        self.last_price_cache = {}
+        
+    @abc.abstractmethod
+    def connect(self) -> bool:
+        """Connect to the exchange API.
+        
+        Returns:
+            bool: True if connection successful, False otherwise
+        """
+        pass
+    
+    @abc.abstractmethod
+    def get_balance(self, asset: str) -> float:
+        """Get balance of a specific asset.
+        
+        Args:
+            asset: Asset symbol (e.g., 'BTC', 'USDT')
+            
+        Returns:
+            float: Available balance of the asset
+        """
+        pass
+    
+    @abc.abstractmethod
+    def get_ticker(self, symbol: str) -> Dict[str, Any]:
+        """Get current ticker data for a symbol.
+        
+        Args:
+            symbol: Trading symbol (e.g., 'BTC/USDT')
+            
+        Returns:
+            dict: Ticker data including price information
+        """
+        pass
+    
+    @abc.abstractmethod
+    def place_order(self, symbol: str, side: str, order_type: str, 
+                   quantity: float, price: float = None) -> Dict[str, Any]:
+        """Place an order on the exchange.
+        
+        Args:
+            symbol: Trading symbol (e.g., 'BTC/USDT')
+            side: Order side ('buy' or 'sell')
+            order_type: Order type ('market', 'limit', etc.)
+            quantity: Order quantity
+            price: Order price (for limit orders)
+            
+        Returns:
+            dict: Order information including order ID
+        """
+        pass
+    
+    @abc.abstractmethod
+    def cancel_order(self, symbol: str, order_id: str) -> bool:
+        """Cancel an existing order.
+        
+        Args:
+            symbol: Trading symbol (e.g., 'BTC/USDT')
+            order_id: ID of the order to cancel
+            
+        Returns:
+            bool: True if cancellation successful, False otherwise
+        """
+        pass
+    
+    @abc.abstractmethod
+    def get_order_status(self, symbol: str, order_id: str) -> Dict[str, Any]:
+        """Get status of an existing order.
+        
+        Args:
+            symbol: Trading symbol (e.g., 'BTC/USDT')
+            order_id: ID of the order
+            
+        Returns:
+            dict: Order status information
+        """
+        pass
+    
+    @abc.abstractmethod
+    def get_open_orders(self, symbol: str = None) -> List[Dict[str, Any]]:
+        """Get all open orders, optionally filtered by symbol.
+        
+        Args:
+            symbol: Trading symbol (e.g., 'BTC/USDT'), or None for all symbols
+            
+        Returns:
+            list: List of open orders
+        """
+        pass
+    
+    def get_last_price(self, symbol: str) -> float:
+        """Get last known price for a symbol, may use cached value.
+        
+        Args:
+            symbol: Trading symbol (e.g., 'BTC/USDT')
+            
+        Returns:
+            float: Last price
+        """
+        try:
+            ticker = self.get_ticker(symbol)
+            price = float(ticker['last'])
+            self.last_price_cache[symbol] = price
+            return price
+        except Exception as e:
+            logger.error(f"Error getting price for {symbol}: {str(e)}")
+            # Return cached price if available
+            return self.last_price_cache.get(symbol, 0.0)
+    
+    def execute_trade(self, symbol: str, action: str, quantity: float = None, 
+                     percent_of_balance: float = None) -> Optional[Dict[str, Any]]:
+        """Execute a trade based on a signal.
+        
+        Args:
+            symbol: Trading symbol (e.g., 'BTC/USDT')
+            action: Trade action ('BUY', 'SELL')
+            quantity: Specific quantity to trade
+            percent_of_balance: Alternative to quantity - percentage of available balance to use
+            
+        Returns:
+            dict: Order information or None if order failed
+        """
+        if action not in ['BUY', 'SELL']:
+            logger.error(f"Invalid action: {action}. Must be 'BUY' or 'SELL'")
+            return None
+        
+        side = action.lower()
+        
+        try:
+            # Determine base and quote assets from symbol (e.g., BTC/USDT -> BTC, USDT)
+            base_asset, quote_asset = symbol.split('/')
+            
+            # Calculate quantity if percent_of_balance is provided
+            if quantity is None and percent_of_balance is not None:
+                if percent_of_balance <= 0 or percent_of_balance > 1:
+                    logger.error(f"Invalid percent_of_balance: {percent_of_balance}. Must be between 0 and 1")
+                    return None
+                
+                if side == 'buy':
+                    # For buy, use quote asset (e.g., USDT)
+                    balance = self.get_balance(quote_asset)
+                    price = self.get_last_price(symbol)
+                    quantity = (balance * percent_of_balance) / price
+                else:
+                    # For sell, use base asset (e.g., BTC)
+                    balance = self.get_balance(base_asset)
+                    quantity = balance * percent_of_balance
+            
+            if not quantity or quantity <= 0:
+                logger.error(f"Invalid quantity: {quantity}")
+                return None
+            
+            # Place market order
+            order = self.place_order(
+                symbol=symbol,
+                side=side,
+                order_type='market',
+                quantity=quantity
+            )
+            
+            logger.info(f"Executed {side.upper()} order for {quantity} {base_asset} at market price")
+            return order
+            
+        except Exception as e:
+            logger.error(f"Error executing {action} trade for {symbol}: {str(e)}")
+            return None