forexsmartbot 3.2.0__py3-none-any.whl

forexsmartbot/adapters/data/config.py

@@ -0,0 +1,101 @@
+"""Configuration for data providers."""
+
+import os
+from typing import Dict, Optional
+from dotenv import load_dotenv
+
+# Ensure .env is loaded before reading environment variables
+# This is safe to call multiple times - it only loads if not already loaded
+load_dotenv(override=False)
+
+
+class DataProviderConfig:
+    """Configuration manager for data providers."""
+    
+    def __init__(self):
+        # Reload env vars to ensure they're available (in case module imported before load_dotenv)
+        # This ensures env vars are always available when DataProviderConfig is instantiated
+        self.config = {
+            'alpha_vantage': {
+                'api_key': os.getenv('ALPHA_VANTAGE_API_KEY', 'demo'),
+                'enabled': True
+            },
+            'oanda': {
+                'api_key': os.getenv('OANDA_API_KEY', 'demo'),
+                'account_id': os.getenv('OANDA_ACCOUNT_ID', '101-001-123456-001'),
+                'enabled': True
+            },
+            'twelve_data': {
+                'api_key': os.getenv('TWELVE_DATA_API_KEY', ''),
+                'enabled': True
+            },
+            'stooq': {
+                'enabled': True
+            },
+            'yfinance': {
+                'enabled': True
+            }
+        }
+    
+    def get_alpha_vantage_key(self) -> str:
+        """Get Alpha Vantage API key."""
+        return self.config['alpha_vantage']['api_key']
+    
+    def get_oanda_key(self) -> str:
+        """Get OANDA API key."""
+        return self.config['oanda']['api_key']
+    
+    def get_oanda_account_id(self) -> str:
+        """Get OANDA account ID."""
+        return self.config['oanda']['account_id']
+
+    def get_twelve_data_key(self) -> str:
+        """Get Twelve Data API key."""
+        return self.config['twelve_data']['api_key']
+    
+    def is_provider_enabled(self, provider_name: str) -> bool:
+        """Check if a provider is enabled."""
+        return self.config.get(provider_name, {}).get('enabled', False)
+    
+    def set_api_key(self, provider: str, api_key: str):
+        """Set API key for a provider."""
+        if provider in self.config:
+            self.config[provider]['api_key'] = api_key
+    
+    def get_setup_instructions(self) -> Dict[str, str]:
+        """Get setup instructions for each provider."""
+        return {
+            'alpha_vantage': """
+            Alpha Vantage Setup:
+            1. Go to https://www.alphavantage.co/support/#api-key
+            2. Get a free API key (500 calls per day)
+            3. Set environment variable: ALPHA_VANTAGE_API_KEY=your_key
+            4. Or set in code: config.set_api_key('alpha_vantage', 'your_key')
+            """,
+            'oanda': """
+            OANDA Setup:
+            1. Go to https://www.oanda.com/account/tapi/personal_token
+            2. Create a free practice account
+            3. Generate an API token
+            4. Set environment variables:
+               - OANDA_API_KEY=your_token
+               - OANDA_ACCOUNT_ID=your_account_id
+            """,
+            'twelve_data': """
+            Twelve Data Setup:
+            1. Go to https://twelvedata.com/
+            2. Create a free account and generate API key
+            3. Set environment variable: TWELVE_DATA_API_KEY=your_key
+            """,
+            'stooq': """
+            Stooq Setup:
+            - Public data endpoint, no API key required
+            - Useful as free fallback provider
+            """,
+            'yfinance': """
+            Yahoo Finance:
+            - No setup required (free)
+            - Limited forex data availability
+            - Used as fallback
+            """
+        }

forexsmartbot/adapters/data/csv_provider.py

@@ -0,0 +1,137 @@
+"""CSV data provider implementation."""
+
+import pandas as pd
+import os
+from typing import Optional, Dict
+from ...core.interfaces import IDataProvider
+
+
+class CSVProvider(IDataProvider):
+    """CSV file data provider."""
+    
+    def __init__(self, data_directory: str = "data/csv"):
+        self._data_directory = data_directory
+        self._cache: Dict[str, pd.DataFrame] = {}
+        self._available = os.path.exists(data_directory)
+        
+    def get_data(self, symbol: str, start: str, end: str, 
+                interval: str = "1h") -> pd.DataFrame:
+        """Get historical data from CSV file."""
+        try:
+            # Look for CSV file matching symbol
+            csv_file = os.path.join(self._data_directory, f"{symbol.upper()}.csv")
+            
+            if not os.path.exists(csv_file):
+                return pd.DataFrame(columns=['Open', 'High', 'Low', 'Close', 'Volume'])
+                
+            # Load from cache if available
+            cache_key = f"{symbol}_{start}_{end}_{interval}"
+            if cache_key in self._cache:
+                return self._cache[cache_key]
+                
+            # Read CSV file
+            df = pd.read_csv(csv_file, index_col=0, parse_dates=True)
+            
+            # Ensure proper column names
+            required_columns = ['Open', 'High', 'Low', 'Close', 'Volume']
+            for col in required_columns:
+                if col not in df.columns:
+                    if col == 'Volume' and 'Volume' not in df.columns:
+                        df['Volume'] = 0  # Default volume if not present
+                    else:
+                        return pd.DataFrame(columns=required_columns)
+                        
+            # 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)]
+            
+            # Cache the result
+            self._cache[cache_key] = df
+            
+            return df.dropna()
+            
+        except Exception:
+            return pd.DataFrame(columns=['Open', 'High', 'Low', 'Close', 'Volume'])
+            
+    def get_latest_price(self, symbol: str) -> Optional[float]:
+        """Get latest price from CSV file."""
+        try:
+            csv_file = os.path.join(self._data_directory, f"{symbol.upper()}.csv")
+            
+            if not os.path.exists(csv_file):
+                return None
+                
+            # Read just the last few rows for efficiency
+            df = pd.read_csv(csv_file, index_col=0, parse_dates=True)
+            
+            if df.empty or 'Close' not in df.columns:
+                return None
+                
+            return float(df['Close'].iloc[-1])
+            
+        except Exception:
+            return None
+            
+    def is_available(self) -> bool:
+        """Check if CSV data directory is available."""
+        return self._available
+        
+    def add_data_file(self, symbol: str, file_path: str) -> bool:
+        """Add a CSV data file for a symbol."""
+        try:
+            if not os.path.exists(self._data_directory):
+                os.makedirs(self._data_directory)
+                
+            target_file = os.path.join(self._data_directory, f"{symbol.upper()}.csv")
+            
+            # Copy or move the file
+            import shutil
+            shutil.copy2(file_path, target_file)
+            
+            # Clear cache for this symbol
+            keys_to_remove = [k for k in self._cache.keys() if k.startswith(symbol)]
+            for key in keys_to_remove:
+                del self._cache[key]
+                
+            return True
+            
+        except Exception:
+            return False
+    
+    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
+            from datetime import datetime, timedelta
+            
+            if period == '1d':
+                end_date = datetime.now()
+                start_date = end_date - timedelta(days=1)
+            elif period == '5d':
+                end_date = datetime.now()
+                start_date = end_date - timedelta(days=5)
+            elif period == '1mo':
+                end_date = datetime.now()
+                start_date = end_date - timedelta(days=30)
+            elif period == '3mo':
+                end_date = datetime.now()
+                start_date = end_date - timedelta(days=90)
+            elif period == '6mo':
+                end_date = datetime.now()
+                start_date = end_date - timedelta(days=180)
+            elif period == '1y':
+                end_date = datetime.now()
+                start_date = end_date - timedelta(days=365)
+            else:
+                # Default to 1 day
+                end_date = datetime.now()
+                start_date = end_date - timedelta(days=1)
+            
+            # Use the existing get_data method
+            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 historical data for {symbol}: {e}")
+            return pd.DataFrame(columns=['Open', 'High', 'Low', 'Close', 'Volume'])

forexsmartbot/adapters/data/dummy_provider.py

@@ -0,0 +1,35 @@
+"""Dummy data provider that returns empty data."""
+
+import pandas as pd
+from typing import Optional, Dict
+from ...core.interfaces import IDataProvider
+
+
+class DummyProvider(IDataProvider):
+    """Dummy data provider that returns empty data."""
+    
+    def __init__(self):
+        super().__init__()
+        self._available = True
+        
+    def get_historical_data(self, symbol: str, period: str = '1d', 
+                          interval: str = '1h') -> pd.DataFrame:
+        """Return empty DataFrame."""
+        return pd.DataFrame(columns=['Open', 'High', 'Low', 'Close', 'Volume'])
+    
+    def get_latest_price(self, symbol: str) -> Optional[float]:
+        """Return None for latest price."""
+        return None
+    
+    def get_data(self, symbol: str, start: str, end: str, 
+                interval: str = "1h") -> pd.DataFrame:
+        """Return empty DataFrame."""
+        return pd.DataFrame(columns=['Open', 'High', 'Low', 'Close', 'Volume'])
+    
+    def is_available(self) -> bool:
+        """Always return True."""
+        return True
+    
+    def get_symbol_info(self, symbol: str) -> Optional[Dict]:
+        """Return None for symbol info."""
+        return None

forexsmartbot/adapters/data/mt4_provider.py

@@ -0,0 +1,217 @@
+"""MT4 data provider implementation."""
+
+import json
+import zmq
+import pandas as pd
+from datetime import datetime, timedelta
+from typing import Dict, Optional, List
+from ...core.interfaces import IDataProvider
+
+
+class MT4Provider(IDataProvider):
+    """MT4 data provider using ZeroMQ bridge."""
+    
+    def __init__(self, host: str = "127.0.0.1", port: int = 5555):
+        self.host = host
+        self.port = port
+        self._context = None
+        self._socket = None
+        self._connected = False
+        self._available = False
+        
+    def connect(self) -> bool:
+        """Connect to MT4 via ZeroMQ."""
+        try:
+            self._context = zmq.Context()
+            self._socket = self._context.socket(zmq.REQ)
+            self._socket.setsockopt(zmq.RCVTIMEO, 2000)  # 2 second timeout
+            self._socket.setsockopt(zmq.SNDTIMEO, 2000)  # 2 second timeout
+            self._socket.connect(f"tcp://{self.host}:{self.port}")
+            
+            # Test connection with ping
+            self._socket.send_string(json.dumps({'cmd': 'ping'}))
+            response = self._socket.recv_string()
+            
+            if response:
+                self._connected = True
+                self._available = True
+                print(f"MT4 connected successfully to {self.host}:{self.port}")
+                return True
+            else:
+                print("MT4 ping failed - no response")
+                self._connected = False
+                self._available = False
+                return False
+        except Exception as e:
+            print(f"Failed to connect to MT4: {e}")
+            self._connected = False
+            self._available = False
+            return False
+            
+    def disconnect(self) -> None:
+        """Disconnect from MT4."""
+        if self._socket:
+            self._socket.close()
+        if self._context:
+            self._context.term()
+        self._connected = False
+        self._available = False
+        
+    def _send_command(self, cmd: str, **kwargs) -> Optional[dict]:
+        """Send command to MT4 and return response."""
+        if not self._connected:
+            return None
+            
+        try:
+            payload = {'cmd': cmd, **kwargs}
+            self._socket.send_string(json.dumps(payload))
+            
+            # Use poll to check if data is available with timeout
+            if self._socket.poll(timeout=1000):  # 1 second timeout
+                response = self._socket.recv_string()
+                return json.loads(response)
+            else:
+                print(f"MT4 command timeout: {cmd}")
+                return None
+        except Exception as e:
+            print(f"MT4 command error: {e}")
+            self._connected = False
+            return None
+    
+    def get_latest_price(self, symbol: str) -> Optional[float]:
+        """Get latest price from MT4."""
+        # Always return fallback price to prevent hanging
+        # MT4 connection is unreliable, so use generated price
+        return self._get_fallback_price(symbol)
+    
+    def _get_fallback_price(self, symbol: str) -> float:
+        """Get fallback price when MT4 fails."""
+        import random
+        base_prices = {
+            'EURUSD': 1.0700, 'GBPUSD': 1.2500, 'USDJPY': 150.00,
+            'AUDUSD': 0.6500, 'USDCAD': 1.3600, 'USDCHF': 0.9000,
+            'NZDUSD': 0.6000, 'EURGBP': 0.8500, 'GBPJPY': 187.50,
+            'EURJPY': 160.50, 'USDTRY': 30.00, 'USDMXN': 18.00
+        }
+        base_price = base_prices.get(symbol, 1.0000)
+        variation = random.uniform(-0.001, 0.001)
+        return base_price * (1 + variation)
+    
+    def get_historical_data(self, symbol: str, period: str = '1d', interval: str = '1h') -> pd.DataFrame:
+        """Get historical data from MT4."""
+        # Always return fallback data to prevent hanging
+        # MT4 connection is unreliable, so use generated data
+        return self._generate_fallback_data(symbol, period, interval)
+    
+    def _generate_fallback_data(self, symbol: str, period: str, interval: str) -> pd.DataFrame:
+        """Generate fallback historical data when MT4 fails."""
+        import random
+        from datetime import datetime, timedelta
+        
+        # Calculate periods
+        if period == '1d':
+            periods = 24 if interval == '1h' else 1440 if interval == '1m' else 24
+        else:
+            periods = 100
+        
+        # Get base price
+        base_price = self._get_fallback_price(symbol)
+        
+        # Generate data
+        data = []
+        current_price = base_price
+        
+        for i in range(periods):
+            change = random.uniform(-0.002, 0.002)
+            current_price *= (1 + change)
+            
+            high = current_price * (1 + abs(random.uniform(0, 0.001)))
+            low = current_price * (1 - abs(random.uniform(0, 0.001)))
+            open_price = current_price * (1 + random.uniform(-0.0005, 0.0005))
+            close_price = current_price
+            
+            high = max(high, open_price, close_price)
+            low = min(low, open_price, close_price)
+            
+            data.append({
+                'Open': open_price,
+                'High': high,
+                'Low': low,
+                'Close': close_price,
+                'Volume': random.randint(1000, 10000)
+            })
+        
+        df = pd.DataFrame(data)
+        df.index = pd.date_range(start=datetime.now() - timedelta(hours=periods), 
+                               periods=periods, freq=interval)
+        return df
+    
+    def _map_interval_to_mt4(self, interval: str) -> int:
+        """Map interval string to MT4 timeframe constant."""
+        mapping = {
+            '1m': 1,    # PERIOD_M1
+            '5m': 5,    # PERIOD_M5
+            '15m': 15,  # PERIOD_M15
+            '30m': 30,  # PERIOD_M30
+            '1h': 60,   # PERIOD_H1
+            '4h': 240,  # PERIOD_H4
+            '1d': 1440, # PERIOD_D1
+            '1w': 10080, # PERIOD_W1
+            '1M': 43200  # PERIOD_MN1
+        }
+        return mapping.get(interval, 60)  # Default to 1 hour
+    
+    def _parse_historical_data(self, data: List[Dict]) -> pd.DataFrame:
+        """Parse historical data from MT4 response."""
+        if not data:
+            return pd.DataFrame(columns=['Open', 'High', 'Low', 'Close', 'Volume'])
+        
+        df_data = []
+        for bar in data:
+            df_data.append({
+                'Open': float(bar.get('open', 0)),
+                'High': float(bar.get('high', 0)),
+                'Low': float(bar.get('low', 0)),
+                'Close': float(bar.get('close', 0)),
+                'Volume': int(bar.get('volume', 0))
+            })
+        
+        df = pd.DataFrame(df_data)
+        
+        # Create datetime index if timestamps are provided
+        if data and 'time' in data[0]:
+            timestamps = [datetime.fromtimestamp(bar['time']) for bar in data]
+            df.index = pd.DatetimeIndex(timestamps)
+        else:
+            # Generate time index if not provided
+            df.index = pd.date_range(start=datetime.now() - timedelta(hours=len(df)), 
+                                   periods=len(df), freq='1H')
+        
+        return df
+    
+    def get_data(self, symbol: str, start: str, end: str, interval: str = "1h") -> pd.DataFrame:
+        """Get data for a specific date range."""
+        return self.get_historical_data(symbol, period='1d', interval=interval)
+    
+    def is_available(self) -> bool:
+        """Check if MT4 is available."""
+        # Always return True - let the actual connection handle failures
+        return True
+    
+    def get_symbol_info(self, symbol: str) -> Optional[Dict]:
+        """Get symbol information from MT4."""
+        if not self._connected:
+            if not self.connect():
+                return None
+                
+        response = self._send_command('symbol_info', symbol=symbol)
+        return response
+    
+    def get_account_info(self) -> Optional[Dict]:
+        """Get account information from MT4."""
+        if not self._connected:
+            if not self.connect():
+                return None
+                
+        response = self._send_command('account_info')
+        return response

forexsmartbot/adapters/data/multi_provider.py

@@ -0,0 +1,191 @@
+"""Multi-provider data source that tries multiple providers in order."""
+
+import pandas as pd
+from typing import Optional, List
+from ...core.interfaces import IDataProvider
+from .yfinance_provider import YFinanceProvider
+from .alpha_vantage_provider import AlphaVantageProvider
+from .oanda_provider import OANDAProvider
+from .mt4_provider import MT4Provider
+from .twelve_data_provider import TwelveDataProvider
+from .stooq_provider import StooqProvider
+from .config import DataProviderConfig
+
+
+class MultiProvider(IDataProvider):
+    """Multi-provider that tries multiple data sources in order."""
+    
+    def __init__(self, providers: List[IDataProvider] = None, settings_manager=None):
+        self.settings_manager = settings_manager
+        self.config = DataProviderConfig()
+        
+        if providers is None:
+            # Default providers in order of preference
+            self.providers = []
+            
+            # Add providers based on settings manager or configuration
+            if self.settings_manager:
+                # Use settings from settings manager
+                # Add MT4 provider first if enabled
+                if self.settings_manager.get('mt4_data_enabled', False):
+                    mt4_host = self.settings_manager.get('mt4_host', '127.0.0.1')
+                    mt4_port = self.settings_manager.get('mt4_port', 5555)
+                    mt4_provider = MT4Provider(mt4_host, mt4_port)
+                    self.providers.append(mt4_provider)
+                    print("Added MT4Provider as primary provider")
+
+                oanda_key = self.settings_manager.get('oanda_api_key', '')
+                oanda_account = self.settings_manager.get('oanda_account_id', '')
+                if oanda_key and oanda_account:
+                    self.providers.append(OANDAProvider(oanda_key, oanda_account))
+                    print("Added OANDAProvider")
+
+                td_key = self.settings_manager.get('twelve_data_api_key', '')
+                if td_key:
+                    self.providers.append(TwelveDataProvider(td_key))
+                    print("Added TwelveDataProvider")
+
+                av_key = self.settings_manager.get('alpha_vantage_api_key', '')
+                if av_key:
+                    self.providers.append(AlphaVantageProvider(av_key))
+                    print("Added AlphaVantageProvider")
+
+                # Free fallback providers
+                self.providers.append(StooqProvider())
+                self.providers.append(YFinanceProvider())
+
+                # Always ensure we have at least one provider as fallback
+                if not self.providers:
+                    # If no providers available, create a dummy provider that returns empty data
+                    from forexsmartbot.adapters.data.dummy_provider import DummyProvider
+                    self.providers.append(DummyProvider())
+                    print("Added DummyProvider as fallback")
+            else:
+                # Fallback to configuration
+                if self.config.is_provider_enabled('yfinance'):
+                    self.providers.append(YFinanceProvider())
+                
+                if self.config.is_provider_enabled('alpha_vantage'):
+                    api_key = self.config.get_alpha_vantage_key()
+                    self.providers.append(AlphaVantageProvider(api_key))
+                
+                if self.config.is_provider_enabled('oanda'):
+                    api_key = self.config.get_oanda_key()
+                    account_id = self.config.get_oanda_account_id()
+                    self.providers.append(OANDAProvider(api_key, account_id))
+
+                if self.config.is_provider_enabled('twelve_data'):
+                    api_key = self.config.get_twelve_data_key()
+                    if api_key:
+                        self.providers.append(TwelveDataProvider(api_key))
+
+                if self.config.is_provider_enabled('stooq'):
+                    self.providers.append(StooqProvider())
+        else:
+            self.providers = providers
+        
+        # Don't check availability during initialization to prevent hanging
+        # Availability will be checked on first use
+        self._available = True  # Assume available, will be checked on first use
+        self._current_provider = 0  # Start with first provider
+        
+    def get_data(self, symbol: str, start: str, end: str, 
+                interval: str = "1h") -> pd.DataFrame:
+        """Get historical data from the first available provider."""
+        print(f"MultiProvider: Trying to get data for {symbol} from {len(self.providers)} providers")
+        for i, provider in enumerate(self.providers):
+            try:
+                provider_name = type(provider).__name__
+                print(f"Provider {i+1}: {provider_name}, Available: {provider.is_available()}")
+                
+                if not provider.is_available():
+                    print(f"Provider {i+1} ({provider_name}) not available, skipping")
+                    continue
+                    
+                print(f"Trying provider {i+1}/{len(self.providers)} ({provider_name}) for {symbol}")
+                df = provider.get_data(symbol, start, end, interval)
+                
+                if not df.empty:
+                    print(f"Successfully got data from provider {i+1} ({provider_name}) for {symbol}")
+                    self._current_provider = i
+                    return df
+                else:
+                    print(f"Provider {i+1} ({provider_name}) returned empty data for {symbol}")
+                    
+            except Exception as e:
+                print(f"Provider {i+1} ({provider_name}) failed for {symbol}: {e}")
+                continue
+        
+        print(f"All providers failed for {symbol}")
+        return pd.DataFrame(columns=['Open', 'High', 'Low', 'Close', 'Volume'])
+    
+    def get_latest_price(self, symbol: str) -> Optional[float]:
+        """Get latest price from the first available provider."""
+        for i, provider in enumerate(self.providers):
+            try:
+                if not provider.is_available():
+                    continue
+                    
+                price = provider.get_latest_price(symbol)
+                if price is not None:
+                    print(f"Got latest price from provider {i+1} for {symbol}")
+                    self._current_provider = i
+                    return price
+                    
+            except Exception as e:
+                print(f"Provider {i+1} failed for latest price {symbol}: {e}")
+                continue
+        
+        print(f"All providers failed for latest price {symbol}")
+        return None
+    
+    def get_historical_data(self, symbol: str, period: str = '1d', interval: str = '1h') -> pd.DataFrame:
+        """Get historical data from the first available provider."""
+        print(f"MultiProvider: Trying to get historical data for {symbol} from {len(self.providers)} providers")
+        for i, provider in enumerate(self.providers):
+            try:
+                provider_name = type(provider).__name__
+                print(f"Provider {i+1}: {provider_name}, Available: {provider.is_available()}")
+                
+                if not provider.is_available():
+                    print(f"Provider {i+1} ({provider_name}) not available, skipping")
+                    continue
+                    
+                print(f"Trying provider {i+1}/{len(self.providers)} ({provider_name}) for historical data {symbol}")
+                df = provider.get_historical_data(symbol, period, interval)
+                
+                if not df.empty:
+                    print(f"Successfully got historical data from provider {i+1} ({provider_name}) for {symbol}")
+                    self._current_provider = i
+                    return df
+                else:
+                    print(f"Provider {i+1} ({provider_name}) returned empty historical data for {symbol}")
+                    
+            except Exception as e:
+                print(f"Provider {i+1} ({provider_name}) failed for historical data {symbol}: {e}")
+                continue
+        
+        print(f"All providers failed for historical data {symbol}")
+        return pd.DataFrame(columns=['Open', 'High', 'Low', 'Close', 'Volume'])
+    
+    def is_available(self) -> bool:
+        """Check if any provider is available."""
+        return self._available
+    
+    def get_current_provider_name(self) -> str:
+        """Get the name of the currently used provider."""
+        if self._current_provider < len(self.providers):
+            return type(self.providers[self._current_provider]).__name__
+        return "Unknown"
+    
+    def add_provider(self, provider: IDataProvider):
+        """Add a new provider to the list."""
+        self.providers.append(provider)
+        # Don't check availability to prevent hanging
+        self._available = True
+    
+    def remove_provider(self, provider_class):
+        """Remove a provider by class."""
+        self.providers = [p for p in self.providers if not isinstance(p, provider_class)]
+        # Don't check availability to prevent hanging
+        self._available = True