forexsmartbot 3.2.0__py3-none-any.whl

forexsmartbot/adapters/brokers/rest_broker.py

@@ -0,0 +1,304 @@
+"""REST API broker implementation for live trading."""
+
+import requests
+import hashlib
+import hmac
+import time
+import json
+from typing import Dict, Optional, List
+from datetime import datetime
+from ...core.interfaces import IBroker, Position, Order
+
+
+class RestBroker(IBroker):
+    """REST API broker for live trading with real brokers."""
+    
+    def __init__(self, api_key: str = "", api_secret: str = "", 
+                 base_url: str = "https://api.example.com", account_id: str = None, 
+                 sandbox: bool = True):
+        self._api_key = api_key
+        self._api_secret = api_secret
+        self._base_url = base_url.rstrip('/')
+        self._account_id = account_id
+        self._sandbox = sandbox
+        self._connected = False
+        self._session = requests.Session()
+        self._session.headers.update({
+            'Content-Type': 'application/json',
+            'User-Agent': 'ForexSmartBot/2.0'
+        })
+        
+    def connect(self) -> bool:
+        """Connect to the REST API broker."""
+        try:
+            if not self._api_key or not self._api_secret:
+                print("REST broker: API key or secret not provided")
+                return False
+                
+            # Test connection with account info
+            response = self._make_request('GET', '/v1/accounts')
+            if response and response.get('status') == 'success':
+                self._connected = True
+                print("REST broker: Connected successfully")
+                return True
+            else:
+                # Fallback: try to get balance as connection test
+                balance = self.get_balance()
+                if balance is not None:
+                    self._connected = True
+                    print("REST broker: Connected successfully (fallback)")
+                    return True
+        except Exception as e:
+            print(f"REST broker connection failed: {e}")
+            
+        return False
+        
+    def disconnect(self) -> None:
+        """Disconnect from the REST API broker."""
+        self._connected = False
+        if hasattr(self, '_session'):
+            self._session.close()
+        print("REST broker: Disconnected")
+        
+    def is_connected(self) -> bool:
+        """Check if connected to the broker."""
+        return self._connected
+        
+    def get_price(self, symbol: str) -> Optional[float]:
+        """Get current price for a symbol."""
+        try:
+            response = self._make_request('GET', f'/v1/prices/{symbol}')
+            if response and 'price' in response:
+                return float(response['price'])
+        except Exception as e:
+            print(f"Error getting price for {symbol}: {e}")
+        return None
+        
+    def submit_order(self, symbol: str, side: int, quantity: float, 
+                    stop_loss: Optional[float] = None, 
+                    take_profit: Optional[float] = None) -> Optional[str]:
+        """Submit an order to the broker."""
+        try:
+            order_data = {
+                'symbol': symbol,
+                'side': 'buy' if side > 0 else 'sell',
+                'quantity': quantity,
+                'type': 'market'
+            }
+            
+            if stop_loss:
+                order_data['stop_loss'] = stop_loss
+            if take_profit:
+                order_data['take_profit'] = take_profit
+                
+            response = self._make_request('POST', '/v1/orders', data=order_data)
+            if response and 'order_id' in response:
+                print(f"REST broker: Order submitted for {symbol}")
+                return response['order_id']
+        except Exception as e:
+            print(f"Error submitting order: {e}")
+        return None
+        
+    def close_all(self, symbol: str) -> bool:
+        """Close all positions for a symbol."""
+        try:
+            response = self._make_request('DELETE', f'/v1/positions/{symbol}')
+            success = response and response.get('status') == 'success'
+            if success:
+                print(f"REST broker: Closed all positions for {symbol}")
+            return success
+        except Exception as e:
+            print(f"Error closing positions for {symbol}: {e}")
+        return False
+        
+    def get_positions(self) -> Dict[str, Position]:
+        """Get all open positions."""
+        try:
+            response = self._make_request('GET', '/v1/positions')
+            positions = {}
+            
+            if response and 'positions' in response:
+                for pos_data in response['positions']:
+                    position = Position(
+                        symbol=pos_data['symbol'],
+                        side=1 if pos_data['side'] == 'long' else -1,
+                        quantity=pos_data['quantity'],
+                        entry_price=pos_data['entry_price'],
+                        current_price=pos_data['current_price'],
+                        unrealized_pnl=pos_data.get('unrealized_pnl', 0.0)
+                    )
+                    positions[position.symbol] = position
+                    
+            return positions
+        except Exception as e:
+            print(f"Error getting positions: {e}")
+        return {}
+        
+    def get_balance(self) -> float:
+        """Get account balance."""
+        try:
+            response = self._make_request('GET', '/v1/accounts/balance')
+            if response and 'balance' in response:
+                return float(response['balance'])
+        except Exception as e:
+            print(f"Error getting balance: {e}")
+        return 0.0
+        
+    def get_equity(self) -> float:
+        """Get account equity."""
+        try:
+            response = self._make_request('GET', '/v1/accounts/equity')
+            if response and 'equity' in response:
+                return float(response['equity'])
+        except Exception as e:
+            print(f"Error getting equity: {e}")
+        return 0.0
+        
+    def get_orders(self) -> List[Dict]:
+        """Get all orders."""
+        try:
+            response = self._make_request('GET', '/v1/orders')
+            if response and 'orders' in response:
+                return response['orders']
+        except Exception as e:
+            print(f"Error getting orders: {e}")
+        return []
+        
+    def cancel_order(self, order_id: str) -> bool:
+        """Cancel an order."""
+        try:
+            response = self._make_request('DELETE', f'/v1/orders/{order_id}')
+            success = response and response.get('status') == 'success'
+            if success:
+                print(f"REST broker: Canceled order {order_id}")
+            return success
+        except Exception as e:
+            print(f"Error canceling order {order_id}: {e}")
+        return False
+        
+    def get_account_info(self) -> Dict:
+        """Get account information."""
+        try:
+            response = self._make_request('GET', '/v1/accounts/info')
+            return response or {}
+        except Exception as e:
+            print(f"Error getting account info: {e}")
+        return {}
+        
+    def _make_request(self, method: str, endpoint: str, data: Dict = None) -> Optional[Dict]:
+        """Make an authenticated HTTP request to the broker API."""
+        try:
+            url = f"{self._base_url}{endpoint}"
+            
+            # Add authentication headers
+            timestamp = str(int(time.time() * 1000))
+            signature = self._create_signature(method, endpoint, data, timestamp)
+            
+            headers = {
+                'X-API-Key': self._api_key,
+                'X-Timestamp': timestamp,
+                'X-Signature': signature
+            }
+            
+            if method == 'GET':
+                response = self._session.get(url, headers=headers, timeout=10)
+            elif method == 'POST':
+                response = self._session.post(url, headers=headers, json=data, timeout=10)
+            elif method == 'PUT':
+                response = self._session.put(url, headers=headers, json=data, timeout=10)
+            elif method == 'DELETE':
+                response = self._session.delete(url, headers=headers, timeout=10)
+            else:
+                raise ValueError(f"Unsupported HTTP method: {method}")
+                
+            response.raise_for_status()
+            return response.json()
+            
+        except requests.exceptions.RequestException as e:
+            print(f"HTTP request failed: {e}")
+        except json.JSONDecodeError as e:
+            print(f"JSON decode error: {e}")
+        except Exception as e:
+            print(f"Request error: {e}")
+            
+        return None
+        
+    def _create_signature(self, method: str, endpoint: str, data: Dict, timestamp: str) -> str:
+        """Create HMAC signature for API authentication."""
+        try:
+            # Create message to sign
+            message = f"{method}{endpoint}{timestamp}"
+            if data:
+                message += json.dumps(data, sort_keys=True)
+                
+            # Create HMAC signature
+            signature = hmac.new(
+                self._api_secret.encode('utf-8'),
+                message.encode('utf-8'),
+                hashlib.sha256
+            ).hexdigest()
+            
+            return signature
+        except Exception as e:
+            print(f"Error creating signature: {e}")
+            return ""
+            
+    def get_market_data(self, symbol: str, timeframe: str = '1h', limit: int = 100) -> List[Dict]:
+        """Get historical market data."""
+        try:
+            params = {
+                'symbol': symbol,
+                'timeframe': timeframe,
+                'limit': limit
+            }
+            response = self._make_request('GET', '/v1/market_data', params)
+            if response and 'data' in response:
+                return response['data']
+        except Exception as e:
+            print(f"Error getting market data: {e}")
+        return []
+        
+    def get_trading_hours(self, symbol: str) -> Dict:
+        """Get trading hours for a symbol."""
+        try:
+            response = self._make_request('GET', f'/v1/trading_hours/{symbol}')
+            return response or {}
+        except Exception as e:
+            print(f"Error getting trading hours: {e}")
+        return {}
+        
+    def get_margin_requirements(self, symbol: str) -> Dict:
+        """Get margin requirements for a symbol."""
+        try:
+            response = self._make_request('GET', f'/v1/margin/{symbol}')
+            return response or {}
+        except Exception as e:
+            print(f"Error getting margin requirements: {e}")
+        return {}
+        
+    def get_instruments(self) -> List[Dict]:
+        """Get available trading instruments."""
+        try:
+            response = self._make_request('GET', '/v1/instruments')
+            if response and 'instruments' in response:
+                return response['instruments']
+        except Exception as e:
+            print(f"Error getting instruments: {e}")
+        return []
+        
+    def get_historical_prices(self, symbol: str, start_date: str, end_date: str, 
+                             timeframe: str = '1h') -> List[Dict]:
+        """Get historical price data."""
+        try:
+            params = {
+                'symbol': symbol,
+                'start_date': start_date,
+                'end_date': end_date,
+                'timeframe': timeframe
+            }
+            response = self._make_request('GET', '/v1/historical_prices', params)
+            if response and 'prices' in response:
+                return response['prices']
+        except Exception as e:
+            print(f"Error getting historical prices: {e}")
+        return []

forexsmartbot/adapters/data/__init__.py

@@ -0,0 +1,27 @@
+"""Data provider adapters."""
+
+from .yfinance_provider import YFinanceProvider
+from .csv_provider import CSVProvider
+from .alpha_vantage_provider import AlphaVantageProvider
+from .oanda_provider import OANDAProvider
+from .mt4_provider import MT4Provider
+from .multi_provider import MultiProvider
+from .dummy_provider import DummyProvider
+from .twelve_data_provider import TwelveDataProvider
+from .stooq_provider import StooqProvider
+from .config import DataProviderConfig
+from ...core.interfaces import IDataProvider
+
+__all__ = [
+    'YFinanceProvider', 
+    'CSVProvider', 
+    'AlphaVantageProvider', 
+    'OANDAProvider', 
+    'MT4Provider', 
+    'MultiProvider',
+    'DummyProvider',
+    'TwelveDataProvider',
+    'StooqProvider',
+    'DataProviderConfig',
+    'IDataProvider',
+]

forexsmartbot/adapters/data/alpha_vantage_provider.py

@@ -0,0 +1,261 @@
+"""Alpha Vantage data provider implementation."""
+
+import requests
+import pandas as pd
+from typing import Optional
+from datetime import datetime, timedelta
+import time
+from ...core.interfaces import IDataProvider
+
+
+class AlphaVantageProvider(IDataProvider):
+    """Alpha Vantage data provider for forex data."""
+    
+    def __init__(self, api_key: str = None):
+        self.api_key = api_key or "demo"  # Use demo key if none provided
+        self.base_url = "https://www.alphavantage.co/query"
+        self._available = True
+        self._rate_limit_delay = 12  # Alpha Vantage free tier: 5 calls per minute
+        
+    def get_data(self, symbol: str, start: str, end: str, 
+                interval: str = "1h") -> pd.DataFrame:
+        """Get historical data from Alpha Vantage."""
+        try:
+            # Convert forex symbol to Alpha Vantage format
+            if not symbol.endswith('=X'):
+                symbol = symbol.upper() + "=X"
+            
+            # Remove =X suffix for Alpha Vantage
+            av_symbol = symbol.replace('=X', '')
+            
+            # Map interval to Alpha Vantage format
+            av_interval = self._map_interval(interval)
+            
+            params = {
+                'function': 'FX_INTRADAY' if av_interval == '1min' else 'FX_DAILY',
+                'from_symbol': av_symbol[:3],
+                'to_symbol': av_symbol[3:],
+                'apikey': self.api_key,
+                'outputsize': 'full'
+            }
+            
+            if av_interval == '1min':
+                params['interval'] = '1min'
+            
+            response = requests.get(self.base_url, params=params, timeout=5)
+            data = response.json()
+            
+            # Debug: Print the response structure
+            print(f"Alpha Vantage response for {symbol}: {list(data.keys())}")
+            
+            if 'Error Message' in data:
+                print(f"Alpha Vantage error for {symbol}: {data['Error Message']}")
+                return pd.DataFrame(columns=['Open', 'High', 'Low', 'Close', 'Volume'])
+            
+            if 'Note' in data:
+                print(f"Alpha Vantage rate limit for {symbol}: {data['Note']}")
+                time.sleep(self._rate_limit_delay)
+                return pd.DataFrame(columns=['Open', 'High', 'Low', 'Close', 'Volume'])
+            
+            if 'Information' in data:
+                print(f"Alpha Vantage information for {symbol}: {data['Information']}")
+                # Alpha Vantage free tier doesn't support forex - generate sample data
+                print(f"Generating sample forex data for {symbol} (Alpha Vantage free tier doesn't support forex)")
+                return self._generate_sample_forex_data(symbol, start, end, interval)
+            
+            # Extract time series data - check for different possible keys
+            time_series_key = None
+            possible_keys = ['Time Series (FX)', 'Time Series (1min)', 'Time Series (5min)', 'Time Series (15min)', 'Time Series (30min)', 'Time Series (60min)']
+            
+            for key in possible_keys:
+                if key in data:
+                    time_series_key = key
+                    break
+            
+            if time_series_key is None:
+                print(f"No time series data for {symbol}. Available keys: {list(data.keys())}")
+                return pd.DataFrame(columns=['Open', 'High', 'Low', 'Close', 'Volume'])
+            
+            time_series = data[time_series_key]
+            
+            # Convert to DataFrame
+            df = pd.DataFrame.from_dict(time_series, orient='index')
+            df.index = pd.to_datetime(df.index)
+            df.columns = ['Open', 'High', 'Low', 'Close']
+            
+            # Add volume (synthetic for forex)
+            df['Volume'] = 1000000
+            
+            # Filter by date range
+            start_date = pd.to_datetime(start)
+            end_date = pd.to_datetime(end)
+            df = df[(df.index >= start_date) & (df.index <= end_date)]
+            
+            # Resample if needed
+            if interval != '1min' and interval != '1d':
+                df = self._resample_data(df, interval)
+            
+            return df.sort_index()
+            
+        except Exception as e:
+            print(f"Error getting Alpha Vantage data for {symbol}: {e}")
+            return pd.DataFrame(columns=['Open', 'High', 'Low', 'Close', 'Volume'])
+    
+    def get_latest_price(self, symbol: str) -> Optional[float]:
+        """Get latest price from Alpha Vantage."""
+        try:
+            # Convert forex symbol to Alpha Vantage format
+            if not symbol.endswith('=X'):
+                symbol = symbol.upper() + "=X"
+            
+            av_symbol = symbol.replace('=X', '')
+            
+            params = {
+                'function': 'CURRENCY_EXCHANGE_RATE',
+                'from_currency': av_symbol[:3],
+                'to_currency': av_symbol[3:],
+                'apikey': self.api_key
+            }
+            
+            response = requests.get(self.base_url, params=params, timeout=5)
+            data = response.json()
+            
+            if 'Realtime Currency Exchange Rate' in data:
+                rate = data['Realtime Currency Exchange Rate']
+                return float(rate['5. Exchange Rate'])
+            
+            return None
+            
+        except Exception as e:
+            print(f"Error getting Alpha Vantage latest price for {symbol}: {e}")
+            return None
+    
+    def get_historical_data(self, symbol: str, period: str = '1d', interval: str = '1h') -> pd.DataFrame:
+        """Get historical data for a symbol with specified period and interval."""
+        try:
+            # Convert period to start/end dates
+            now = datetime.now()
+            
+            if period == '1d':
+                end_date = now
+                start_date = now - timedelta(days=1)
+            elif period == '5d':
+                end_date = now
+                start_date = now - timedelta(days=5)
+            elif period == '1mo':
+                end_date = now
+                start_date = now - timedelta(days=30)
+            elif period == '3mo':
+                end_date = now
+                start_date = now - timedelta(days=90)
+            elif period == '6mo':
+                end_date = now
+                start_date = now - timedelta(days=180)
+            elif period == '1y':
+                end_date = now
+                start_date = now - timedelta(days=365)
+            else:
+                # Default to 1 day
+                end_date = now
+                start_date = now - timedelta(days=1)
+            
+            return self.get_data(symbol, start_date.strftime('%Y-%m-%d'), end_date.strftime('%Y-%m-%d'), interval)
+            
+        except Exception as e:
+            print(f"Error getting Alpha Vantage historical data for {symbol}: {e}")
+            return pd.DataFrame(columns=['Open', 'High', 'Low', 'Close', 'Volume'])
+    
+    def _map_interval(self, interval: str) -> str:
+        """Map interval to Alpha Vantage format."""
+        mapping = {
+            '1m': '1min',
+            '5m': '5min',
+            '15m': '15min',
+            '30m': '30min',
+            '1h': '1min',  # Alpha Vantage doesn't have 1h, use 1min
+            '4h': '1min',  # Alpha Vantage doesn't have 4h, use 1min
+            '1d': '1d'
+        }
+        return mapping.get(interval, '1min')
+    
+    def _resample_data(self, df: pd.DataFrame, interval: str) -> pd.DataFrame:
+        """Resample data to desired interval."""
+        try:
+            if interval == '1h':
+                return df.resample('1H').agg({
+                    'Open': 'first',
+                    'High': 'max',
+                    'Low': 'min',
+                    'Close': 'last',
+                    'Volume': 'sum'
+                }).dropna()
+            elif interval == '4h':
+                return df.resample('4H').agg({
+                    'Open': 'first',
+                    'High': 'max',
+                    'Low': 'min',
+                    'Close': 'last',
+                    'Volume': 'sum'
+                }).dropna()
+            else:
+                return df
+        except Exception:
+            return df
+    
+    def _generate_sample_forex_data(self, symbol: str, start: str, end: str, interval: str) -> pd.DataFrame:
+        """Generate sample forex data when real data is not available."""
+        import numpy as np
+        
+        # Parse dates
+        start_date = pd.to_datetime(start)
+        end_date = pd.to_datetime(end)
+        
+        # Generate date range based on interval
+        if interval == '1h':
+            freq = '1H'
+        elif interval == '4h':
+            freq = '4H'
+        elif interval == '1d':
+            freq = '1D'
+        else:
+            freq = '1H'
+        
+        dates = pd.date_range(start=start_date, end=end_date, freq=freq)
+        
+        # Set base price based on symbol
+        if 'EUR' in symbol:
+            base_price = 1.1800
+        elif 'GBP' in symbol:
+            base_price = 1.2500
+        elif 'JPY' in symbol:
+            base_price = 150.0
+        elif 'AUD' in symbol:
+            base_price = 0.7500
+        elif 'CAD' in symbol:
+            base_price = 1.3500
+        elif 'CHF' in symbol:
+            base_price = 0.9200
+        elif 'NZD' in symbol:
+            base_price = 0.7000
+        else:
+            base_price = 1.0000
+        
+        # Create realistic price movements
+        np.random.seed(42)  # For consistent results
+        price_changes = np.random.randn(len(dates)) * 0.0005  # Smaller changes for more realistic data
+        prices = base_price + np.cumsum(price_changes)
+        
+        # Ensure prices stay within reasonable bounds
+        prices = np.clip(prices, base_price * 0.5, base_price * 2.0)
+        
+        return pd.DataFrame({
+            'Open': prices,
+            'High': prices + np.abs(np.random.randn(len(dates))) * 0.0002,
+            'Low': prices - np.abs(np.random.randn(len(dates))) * 0.0002,
+            'Close': prices + np.random.randn(len(dates)) * 0.0001,
+            'Volume': np.random.randint(1000000, 10000000, len(dates))
+        }, index=dates)
+    
+    def is_available(self) -> bool:
+        """Check if Alpha Vantage is available."""
+        return self._available and self.api_key and self.api_key != "demo"