forexsmartbot 3.2.0__py3-none-any.whl

forexsmartbot/adapters/data/oanda_provider.py

@@ -0,0 +1,173 @@
+"""OANDA 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 OANDAProvider(IDataProvider):
+    """OANDA data provider for forex data."""
+    
+    def __init__(self, api_key: str = None, account_id: str = None):
+        self.api_key = api_key or "demo"  # Use demo if none provided
+        self.account_id = account_id or "101-001-123456-001"  # Demo account
+        self.base_url = "https://api-fxpractice.oanda.com"  # Demo environment
+        self._available = True
+        
+    def get_data(self, symbol: str, start: str, end: str, 
+                interval: str = "1h") -> pd.DataFrame:
+        """Get historical data from OANDA."""
+        try:
+            # Convert forex symbol to OANDA format
+            if symbol.endswith('=X'):
+                symbol = symbol.replace('=X', '')
+            
+            # OANDA uses different format (e.g., EUR_USD instead of EURUSD)
+            oanda_symbol = f"{symbol[:3]}_{symbol[3:]}"
+            
+            # Map interval to OANDA granularity
+            granularity = self._map_interval(interval)
+            
+            # Convert dates to OANDA format
+            start_date = pd.to_datetime(start).strftime('%Y-%m-%dT%H:%M:%S.000000000Z')
+            end_date = pd.to_datetime(end).strftime('%Y-%m-%dT%H:%M:%S.000000000Z')
+            
+            url = f"{self.base_url}/v3/instruments/{oanda_symbol}/candles"
+            params = {
+                'from': start_date,
+                'to': end_date,
+                'granularity': granularity,
+                'price': 'M'  # Mid prices
+            }
+            
+            headers = {
+                'Authorization': f'Bearer {self.api_key}',
+                'Content-Type': 'application/json'
+            }
+            
+            response = requests.get(url, params=params, headers=headers, timeout=30)
+            data = response.json()
+            
+            if 'candles' not in data:
+                print(f"No candles data for {symbol}: {data.get('errorMessage', 'Unknown error')}")
+                return pd.DataFrame(columns=['Open', 'High', 'Low', 'Close', 'Volume'])
+            
+            candles = data['candles']
+            if not candles:
+                print(f"No candles available for {symbol}")
+                return pd.DataFrame(columns=['Open', 'High', 'Low', 'Close', 'Volume'])
+            
+            # Convert to DataFrame
+            df_data = []
+            for candle in candles:
+                if candle['complete']:  # Only use complete candles
+                    df_data.append({
+                        'Open': float(candle['mid']['o']),
+                        'High': float(candle['mid']['h']),
+                        'Low': float(candle['mid']['l']),
+                        'Close': float(candle['mid']['c']),
+                        'Volume': int(candle['volume'])
+                    })
+            
+            if not df_data:
+                print(f"No complete candles for {symbol}")
+                return pd.DataFrame(columns=['Open', 'High', 'Low', 'Close', 'Volume'])
+            
+            df = pd.DataFrame(df_data)
+            df.index = pd.to_datetime([candle['time'] for candle in candles if candle['complete']])
+            
+            return df.sort_index()
+            
+        except Exception as e:
+            print(f"Error getting OANDA 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 OANDA."""
+        try:
+            # Convert forex symbol to OANDA format
+            if symbol.endswith('=X'):
+                symbol = symbol.replace('=X', '')
+            
+            oanda_symbol = f"{symbol[:3]}_{symbol[3:]}"
+            
+            url = f"{self.base_url}/v3/accounts/{self.account_id}/pricing"
+            params = {
+                'instruments': oanda_symbol
+            }
+            
+            headers = {
+                'Authorization': f'Bearer {self.api_key}',
+                'Content-Type': 'application/json'
+            }
+            
+            response = requests.get(url, params=params, headers=headers, timeout=30)
+            data = response.json()
+            
+            if 'prices' in data and data['prices']:
+                price_data = data['prices'][0]
+                if 'bids' in price_data and 'asks' in price_data:
+                    bid = float(price_data['bids'][0]['price'])
+                    ask = float(price_data['asks'][0]['price'])
+                    return (bid + ask) / 2  # Return mid price
+            
+            return None
+            
+        except Exception as e:
+            print(f"Error getting OANDA 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 OANDA historical data for {symbol}: {e}")
+            return pd.DataFrame(columns=['Open', 'High', 'Low', 'Close', 'Volume'])
+    
+    def _map_interval(self, interval: str) -> str:
+        """Map interval to OANDA granularity."""
+        mapping = {
+            '1m': 'M1',
+            '5m': 'M5',
+            '15m': 'M15',
+            '30m': 'M30',
+            '1h': 'H1',
+            '4h': 'H4',
+            '1d': 'D'
+        }
+        return mapping.get(interval, 'H1')
+    
+    def is_available(self) -> bool:
+        """Check if OANDA is available."""
+        return self._available

forexsmartbot/adapters/data/stooq_provider.py

@@ -0,0 +1,114 @@
+"""Stooq provider implementation (public CSV market data endpoint)."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+from io import StringIO
+from typing import Optional
+
+import pandas as pd
+import requests
+
+from ...core.interfaces import IDataProvider
+
+
+class StooqProvider(IDataProvider):
+    """Stooq provider for free forex data."""
+
+    def __init__(self):
+        self._available = True
+
+    def _to_stooq_symbol(self, symbol: str) -> str:
+        raw = symbol.replace("=X", "").replace("/", "").upper()
+        if len(raw) != 6:
+            raise ValueError(f"Unsupported forex symbol format: {symbol}")
+        return raw.lower()
+
+    def _map_interval(self, interval: str) -> str:
+        mapping = {
+            "1m": "1",
+            "5m": "5",
+            "15m": "15",
+            "30m": "30",
+            "1h": "60",
+            "4h": "240",
+            "1d": "d",
+        }
+        return mapping.get(interval, "d")
+
+    def get_data(self, symbol: str, start: str, end: str, interval: str = "1h") -> pd.DataFrame:
+        try:
+            s = self._to_stooq_symbol(symbol)
+            i = self._map_interval(interval)
+            # Stooq CSV endpoint
+            url = f"https://stooq.com/q/d/l/?s={s}&i={i}"
+            response = requests.get(url, timeout=15)
+            response.raise_for_status()
+            csv_txt = response.text
+            df = pd.read_csv(StringIO(csv_txt))
+            if df.empty or "Date" not in df.columns:
+                return pd.DataFrame(columns=["Open", "High", "Low", "Close", "Volume"])
+
+            if "Time" in df.columns:
+                df["datetime"] = pd.to_datetime(df["Date"] + " " + df["Time"], errors="coerce")
+            else:
+                df["datetime"] = pd.to_datetime(df["Date"], errors="coerce")
+            df = df.set_index("datetime").sort_index()
+            df = df.rename(
+                columns={
+                    "Open": "Open",
+                    "High": "High",
+                    "Low": "Low",
+                    "Close": "Close",
+                    "Volume": "Volume",
+                }
+            )
+            for col in ["Open", "High", "Low", "Close"]:
+                df[col] = pd.to_numeric(df[col], errors="coerce")
+            if "Volume" not in df.columns:
+                df["Volume"] = 0.0
+            else:
+                df["Volume"] = pd.to_numeric(df["Volume"], errors="coerce").fillna(0.0)
+            df = df.dropna(subset=["Open", "High", "Low", "Close"])
+
+            start_dt = pd.to_datetime(start)
+            end_dt = pd.to_datetime(end)
+            df = df[(df.index >= start_dt) & (df.index <= end_dt)]
+            return df[["Open", "High", "Low", "Close", "Volume"]]
+        except Exception:
+            return pd.DataFrame(columns=["Open", "High", "Low", "Close", "Volume"])
+
+    def get_latest_price(self, symbol: str) -> Optional[float]:
+        try:
+            s = self._to_stooq_symbol(symbol)
+            # Current quote endpoint
+            url = f"https://stooq.com/q/l/?s={s}&f=sd2t2ohlcv&h&e=csv"
+            response = requests.get(url, timeout=10)
+            response.raise_for_status()
+            df = pd.read_csv(StringIO(response.text))
+            if df.empty or "Close" not in df.columns:
+                return None
+            price = pd.to_numeric(df["Close"].iloc[0], errors="coerce")
+            if pd.isna(price):
+                return None
+            return float(price)
+        except Exception:
+            return None
+
+    def get_historical_data(self, symbol: str, period: str = "1d", interval: str = "1h") -> pd.DataFrame:
+        now = datetime.now()
+        period_map = {
+            "1d": timedelta(days=1),
+            "5d": timedelta(days=5),
+            "1mo": timedelta(days=30),
+            "3mo": timedelta(days=90),
+            "6mo": timedelta(days=180),
+            "1y": timedelta(days=365),
+        }
+        delta = period_map.get(period, timedelta(days=1))
+        start = (now - delta).strftime("%Y-%m-%d")
+        end = now.strftime("%Y-%m-%d")
+        return self.get_data(symbol, start, end, interval)
+
+    def is_available(self) -> bool:
+        return self._available

forexsmartbot/adapters/data/twelve_data_provider.py

@@ -0,0 +1,117 @@
+"""Twelve Data provider implementation for forex market data."""
+
+from __future__ import annotations
+
+from datetime import datetime, timedelta
+from typing import Optional
+
+import pandas as pd
+import requests
+
+from ...core.interfaces import IDataProvider
+
+
+class TwelveDataProvider(IDataProvider):
+    """Twelve Data provider for historical candles and latest price."""
+
+    def __init__(self, api_key: str = ""):
+        self.api_key = api_key
+        self.base_url = "https://api.twelvedata.com"
+        self._available = bool(api_key)
+
+    def _to_twelve_symbol(self, symbol: str) -> str:
+        raw = symbol.replace("=X", "").replace("/", "").upper()
+        if len(raw) != 6:
+            raise ValueError(f"Unsupported forex symbol format: {symbol}")
+        return f"{raw[:3]}/{raw[3:]}"
+
+    def _map_interval(self, interval: str) -> str:
+        mapping = {
+            "1m": "1min",
+            "5m": "5min",
+            "15m": "15min",
+            "30m": "30min",
+            "1h": "1h",
+            "4h": "4h",
+            "1d": "1day",
+        }
+        return mapping.get(interval, "1h")
+
+    def get_data(self, symbol: str, start: str, end: str, interval: str = "1h") -> pd.DataFrame:
+        if not self._available:
+            return pd.DataFrame(columns=["Open", "High", "Low", "Close", "Volume"])
+
+        try:
+            td_symbol = self._to_twelve_symbol(symbol)
+            params = {
+                "symbol": td_symbol,
+                "interval": self._map_interval(interval),
+                "start_date": pd.to_datetime(start).strftime("%Y-%m-%d %H:%M:%S"),
+                "end_date": pd.to_datetime(end).strftime("%Y-%m-%d %H:%M:%S"),
+                "apikey": self.api_key,
+                "outputsize": 5000,
+            }
+            response = requests.get(f"{self.base_url}/time_series", params=params, timeout=20)
+            data = response.json()
+
+            if "values" not in data:
+                return pd.DataFrame(columns=["Open", "High", "Low", "Close", "Volume"])
+
+            rows = data["values"]
+            if not rows:
+                return pd.DataFrame(columns=["Open", "High", "Low", "Close", "Volume"])
+
+            df = pd.DataFrame(rows)
+            df["datetime"] = pd.to_datetime(df["datetime"])
+            df = df.set_index("datetime").sort_index()
+            df = df.rename(
+                columns={
+                    "open": "Open",
+                    "high": "High",
+                    "low": "Low",
+                    "close": "Close",
+                    "volume": "Volume",
+                }
+            )
+            for col in ["Open", "High", "Low", "Close", "Volume"]:
+                if col not in df.columns:
+                    df[col] = 0.0 if col == "Volume" else pd.NA
+            df[["Open", "High", "Low", "Close", "Volume"]] = df[
+                ["Open", "High", "Low", "Close", "Volume"]
+            ].apply(pd.to_numeric, errors="coerce")
+            df = df.dropna(subset=["Open", "High", "Low", "Close"])
+            return df[["Open", "High", "Low", "Close", "Volume"]]
+        except Exception:
+            return pd.DataFrame(columns=["Open", "High", "Low", "Close", "Volume"])
+
+    def get_latest_price(self, symbol: str) -> Optional[float]:
+        if not self._available:
+            return None
+        try:
+            td_symbol = self._to_twelve_symbol(symbol)
+            params = {"symbol": td_symbol, "apikey": self.api_key}
+            response = requests.get(f"{self.base_url}/price", params=params, timeout=10)
+            data = response.json()
+            if "price" in data:
+                return float(data["price"])
+            return None
+        except Exception:
+            return None
+
+    def get_historical_data(self, symbol: str, period: str = "1d", interval: str = "1h") -> pd.DataFrame:
+        now = datetime.now()
+        period_map = {
+            "1d": timedelta(days=1),
+            "5d": timedelta(days=5),
+            "1mo": timedelta(days=30),
+            "3mo": timedelta(days=90),
+            "6mo": timedelta(days=180),
+            "1y": timedelta(days=365),
+        }
+        delta = period_map.get(period, timedelta(days=1))
+        start = (now - delta).strftime("%Y-%m-%d")
+        end = now.strftime("%Y-%m-%d")
+        return self.get_data(symbol, start, end, interval)
+
+    def is_available(self) -> bool:
+        return self._available

forexsmartbot/adapters/data/yfinance_provider.py

@@ -0,0 +1,246 @@
+"""Yahoo Finance data provider implementation."""
+
+import yfinance as yf
+import pandas as pd
+from typing import Optional
+from ...core.interfaces import IDataProvider
+
+
+class YFinanceProvider(IDataProvider):
+    """Yahoo Finance data provider."""
+    
+    def __init__(self):
+        self._available = True
+        
+    def get_data(self, symbol: str, start: str, end: str, 
+                interval: str = "1h") -> pd.DataFrame:
+        """Get historical data from Yahoo Finance."""
+        try:
+            # Convert dates to timezone-naive datetime objects
+            start_date = pd.to_datetime(start).tz_localize(None) if pd.to_datetime(start).tz is not None else pd.to_datetime(start)
+            end_date = pd.to_datetime(end).tz_localize(None) if pd.to_datetime(end).tz is not None else pd.to_datetime(end)
+            
+            # Convert forex symbol to yfinance format if needed
+            if not symbol.endswith('=X'):
+                symbol = symbol.upper() + "=X"
+                
+            ticker = yf.Ticker(symbol)
+            date_range_days = (end_date - start_date).days
+            
+            # Try different approaches to get data
+            df = pd.DataFrame()
+            
+            # First try: Get data with the requested interval
+            try:
+                if date_range_days > 365:
+                    # For long ranges, use daily data and resample
+                    df = ticker.history(start=start_date, end=end_date, interval="1d", auto_adjust=True, progress=False)
+                else:
+                    # For shorter ranges, use the requested interval
+                    df = ticker.history(start=start_date, end=end_date, interval=interval, auto_adjust=True, progress=False)
+                
+                # Convert index to timezone-naive if needed
+                if not df.empty and df.index.tz is not None:
+                    df.index = df.index.tz_localize(None)
+            except Exception:
+                pass
+            
+            # Second try: Get maximum available data if first attempt failed
+            if df.empty:
+                try:
+                    df = ticker.history(period="max", interval="1d", auto_adjust=True, progress=False)
+                    if not df.empty:
+                        # Convert index to timezone-naive for comparison
+                        df.index = df.index.tz_localize(None) if df.index.tz is not None else df.index
+                        # Filter to requested date range
+                        df = df[(df.index >= start_date) & (df.index <= end_date)]
+                except Exception:
+                    pass
+            
+            # Third try: Get recent data if all else fails
+            if df.empty:
+                try:
+                    df = ticker.history(period="5d", interval="1d", auto_adjust=True, progress=False)
+                    # Convert index to timezone-naive if needed
+                    if not df.empty and df.index.tz is not None:
+                        df.index = df.index.tz_localize(None)
+                except Exception:
+                    pass
+            
+            if df.empty:
+                print(f"Warning: No data available for {symbol}")
+                return pd.DataFrame(columns=['Open', 'High', 'Low', 'Close', 'Volume'])
+                
+            # Resample if needed and interval is not daily
+            if not df.empty and interval != "1d" and len(df) > 1:
+                try:
+                    # Convert interval to pandas frequency format
+                    freq_map = {'1h': '1h', '4h': '4h', '1m': '1T'}
+                    freq = freq_map.get(interval, interval)
+                    df = df.resample(freq).interpolate(method='linear')
+                except Exception:
+                    pass
+                
+            # Ensure proper column names
+            df = df.rename(columns={
+                'Open': 'Open',
+                'High': 'High', 
+                'Low': 'Low',
+                'Close': 'Close',
+                'Volume': 'Volume'
+            })
+            
+            # Fill missing volume data
+            if 'Volume' not in df.columns or df['Volume'].isna().all():
+                df['Volume'] = 1000000  # Default volume for forex
+            
+            # Ensure all required columns exist
+            required_columns = ['Open', 'High', 'Low', 'Close', 'Volume']
+            for col in required_columns:
+                if col not in df.columns:
+                    if col == 'Volume':
+                        df[col] = 1000000
+                    else:
+                        df[col] = df['Close']  # Use Close price as fallback
+            
+            return df.dropna()
+            
+        except Exception as e:
+            print(f"Error getting data for {symbol}: {e}")
+            return pd.DataFrame(columns=['Open', 'High', 'Low', 'Close', 'Volume'])
+    
+    def _generate_synthetic_data(self, start_date, end_date, interval):
+        """Generate synthetic forex data for testing purposes."""
+        import numpy as np
+        
+        # Create date range
+        if interval == "1h":
+            freq = '1h'
+        elif interval == "4h":
+            freq = '4h'
+        elif interval == "1m":
+            freq = '1T'
+        else:
+            freq = '1d'
+            
+        date_range = pd.date_range(start=start_date, end=end_date, freq=freq)
+        
+        if len(date_range) == 0:
+            # Fallback to daily if no data points
+            date_range = pd.date_range(start=start_date, end=end_date, freq='1d')
+        
+        # Generate synthetic price data (starting around 1.1000 for EURUSD-like pair)
+        base_price = 1.1000
+        n_points = len(date_range)
+        
+        # Generate random walk
+        returns = np.random.normal(0, 0.001, n_points)  # 0.1% daily volatility
+        prices = [base_price]
+        
+        for i in range(1, n_points):
+            new_price = prices[-1] * (1 + returns[i])
+            prices.append(new_price)
+        
+        # Create OHLC data
+        data = []
+        for i, (date, price) in enumerate(zip(date_range, prices)):
+            # Add some intraday variation
+            high = price * (1 + abs(np.random.normal(0, 0.0005)))
+            low = price * (1 - abs(np.random.normal(0, 0.0005)))
+            open_price = price * (1 + np.random.normal(0, 0.0002))
+            close_price = price
+            
+            data.append({
+                'Open': open_price,
+                'High': max(open_price, high, close_price),
+                'Low': min(open_price, low, close_price),
+                'Close': close_price,
+                'Volume': 1000000
+            })
+        
+        df = pd.DataFrame(data, index=date_range)
+        return df
+            
+    def get_latest_price(self, symbol: str) -> Optional[float]:
+        """Get latest price from Yahoo Finance."""
+        try:
+            # Convert forex symbol to yfinance format if needed
+            if not symbol.endswith('=X'):
+                symbol = symbol.upper() + "=X"
+                
+            ticker = yf.Ticker(symbol)
+            
+            # Try to get price from info first
+            try:
+                info = ticker.info
+                if 'regularMarketPrice' in info and info['regularMarketPrice'] is not None:
+                    return float(info['regularMarketPrice'])
+                elif 'currentPrice' in info and info['currentPrice'] is not None:
+                    return float(info['currentPrice'])
+            except Exception:
+                pass
+            
+            # Fallback to recent data
+            try:
+                df = ticker.history(period="1d", interval="1m", progress=False)
+                if not df.empty and 'Close' in df.columns:
+                    return float(df['Close'].iloc[-1])
+            except Exception:
+                pass
+            
+            # Second fallback: try daily data
+            try:
+                df = ticker.history(period="5d", interval="1d", progress=False)
+                if not df.empty and 'Close' in df.columns:
+                    return float(df['Close'].iloc[-1])
+            except Exception:
+                pass
+                
+        except Exception as e:
+            print(f"Error getting latest price for {symbol}: {e}")
+            
+        # Return None if all attempts fail
+        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
+            from datetime import datetime, timedelta
+            
+            # Use timezone-naive datetime objects
+            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)
+            
+            # 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'])
+        
+    def is_available(self) -> bool:
+        """Check if Yahoo Finance is available."""
+        return self._available

forexsmartbot/analytics/__init__.py

@@ -0,0 +1,28 @@
+"""
+Analytics module for ForexSmartBot v3.2.0
+Provides portfolio analytics, risk analytics, and advanced charting features.
+"""
+
+from .portfolio_analytics import PortfolioAnalytics
+from .risk_analytics import RiskAnalytics
+from .chart_patterns import ChartPatternRecognizer
+from .performance_attribution import PerformanceAttribution
+from .market_depth import MarketDepthWidget, MarketDepthProvider
+from .correlation_matrix import CorrelationMatrixWidget, CorrelationAnalyzer
+from .economic_calendar import EconomicCalendarWidget, EconomicCalendarProvider
+from .trade_journal import TradeJournalWidget, TradeJournalManager
+
+__all__ = [
+    'PortfolioAnalytics',
+    'RiskAnalytics',
+    'ChartPatternRecognizer',
+    'PerformanceAttribution',
+    'MarketDepthWidget',
+    'MarketDepthProvider',
+    'CorrelationMatrixWidget',
+    'CorrelationAnalyzer',
+    'EconomicCalendarWidget',
+    'EconomicCalendarProvider',
+    'TradeJournalWidget',
+    'TradeJournalManager',
+]