forexsmartbot 3.2.0__py3-none-any.whl

forexsmartbot/__init__.py

@@ -0,0 +1 @@
+# ForexSmartBot Package

forexsmartbot/adapters/__init__.py

@@ -0,0 +1,4 @@
+"""Adapters for external systems."""
+
+from .brokers import *
+from .data import *

forexsmartbot/adapters/brokers/__init__.py

@@ -0,0 +1,8 @@
+"""Broker adapters."""
+
+from .paper_broker import PaperBroker
+from .mt4_broker import MT4Broker
+from .rest_broker import RestBroker
+from .ib_tws_broker import IBTWSBroker
+
+__all__ = ['PaperBroker', 'MT4Broker', 'RestBroker', 'IBTWSBroker']

forexsmartbot/adapters/brokers/ib_tws_broker.py

@@ -0,0 +1,244 @@
+"""Interactive Brokers TWS broker adapter."""
+
+from __future__ import annotations
+
+from typing import Dict, Optional, Tuple
+
+from ...core.interfaces import IBroker, Position
+
+
+class IBTWSBroker(IBroker):
+    """Interactive Brokers broker via TWS / IB Gateway using ib_insync."""
+
+    def __init__(
+        self,
+        host: str = "127.0.0.1",
+        port: int = 7497,
+        client_id: int = 1,
+        account_id: str = "",
+    ):
+        self._host = host
+        self._port = int(port)
+        self._client_id = int(client_id)
+        self._account_id = account_id
+        self._connected = False
+        self._contracts: Dict[str, object] = {}
+        self._orders: Dict[str, Tuple[str, float]] = {}
+        self._ib = None
+
+        try:
+            from ib_insync import IB
+
+            self._ib = IB()
+        except Exception:
+            self._ib = None
+
+    def connect(self) -> bool:
+        if self._ib is None:
+            print("IBTWSBroker: ib_insync is not installed. Install with: pip install ib_insync")
+            return False
+        try:
+            self._ib.connect(self._host, self._port, clientId=self._client_id, timeout=10)
+            self._connected = bool(self._ib.isConnected())
+            return self._connected
+        except Exception as e:
+            print(f"IBTWSBroker: Connection failed: {e}")
+            self._connected = False
+            return False
+
+    def disconnect(self) -> None:
+        try:
+            if self._ib is not None and self._ib.isConnected():
+                self._ib.disconnect()
+        finally:
+            self._connected = False
+
+    def is_connected(self) -> bool:
+        return self._connected and self._ib is not None and self._ib.isConnected()
+
+    def _get_contract(self, symbol: str):
+        if symbol in self._contracts:
+            return self._contracts[symbol]
+
+        from ib_insync import Forex
+
+        normalized = symbol.replace("=", "").replace("/", "").upper()
+        if normalized.endswith("X"):
+            normalized = normalized[:-1]
+        if len(normalized) != 6:
+            raise ValueError(f"Unsupported symbol format for IB Forex: {symbol}")
+
+        contract = Forex(normalized)
+        self._ib.qualifyContracts(contract)
+        self._contracts[symbol] = contract
+        return contract
+
+    def get_price(self, symbol: str) -> Optional[float]:
+        if not self.is_connected():
+            return None
+        try:
+            contract = self._get_contract(symbol)
+            ticker = self._ib.reqMktData(contract, "", False, False)
+            self._ib.sleep(0.5)
+
+            if ticker and ticker.last and ticker.last > 0:
+                return float(ticker.last)
+            if ticker and ticker.bid and ticker.ask and ticker.bid > 0 and ticker.ask > 0:
+                return float((ticker.bid + ticker.ask) / 2.0)
+            if ticker and ticker.close and ticker.close > 0:
+                return float(ticker.close)
+            return None
+        except Exception as e:
+            print(f"IBTWSBroker: get_price failed 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]:
+        if not self.is_connected():
+            return None
+        try:
+            from ib_insync import LimitOrder, MarketOrder, StopOrder
+
+            contract = self._get_contract(symbol)
+            action = "BUY" if side > 0 else "SELL"
+            exit_action = "SELL" if action == "BUY" else "BUY"
+            order_qty = float(abs(quantity))
+            if order_qty <= 0:
+                return None
+
+            order = MarketOrder(action, order_qty, transmit=True)
+            if self._account_id:
+                order.account = self._account_id
+
+            # If SL/TP are provided, place as linked child orders for risk control.
+            if stop_loss is not None or take_profit is not None:
+                order.transmit = False
+
+            trade = self._ib.placeOrder(contract, order)
+            self._ib.sleep(0.5)
+
+            order_id = str(trade.order.orderId)
+            self._orders[order_id] = (symbol, order_qty)
+
+            if stop_loss is not None:
+                sl_order = StopOrder(
+                    action=exit_action,
+                    totalQuantity=order_qty,
+                    stopPrice=float(stop_loss),
+                    parentId=trade.order.orderId,
+                    transmit=(take_profit is None),
+                )
+                if self._account_id:
+                    sl_order.account = self._account_id
+                self._ib.placeOrder(contract, sl_order)
+
+            if take_profit is not None:
+                tp_order = LimitOrder(
+                    action=exit_action,
+                    totalQuantity=order_qty,
+                    lmtPrice=float(take_profit),
+                    parentId=trade.order.orderId,
+                    transmit=True,
+                )
+                if self._account_id:
+                    tp_order.account = self._account_id
+                self._ib.placeOrder(contract, tp_order)
+
+            self._ib.sleep(0.3)
+            return order_id
+        except Exception as e:
+            print(f"IBTWSBroker: submit_order failed for {symbol}: {e}")
+            return None
+
+    def close_all(self, symbol: str) -> bool:
+        if not self.is_connected():
+            return False
+        try:
+            from ib_insync import MarketOrder
+
+            closed_any = False
+            target = symbol.replace("=", "").replace("/", "").upper()
+            if target.endswith("X"):
+                target = target[:-1]
+
+            for pos in self._ib.positions():
+                local_symbol = (pos.contract.localSymbol or "").replace(".", "").upper()
+                con_symbol = f"{pos.contract.symbol}{getattr(pos.contract, 'currency', '')}".upper()
+                if target not in (local_symbol, con_symbol):
+                    continue
+
+                qty = float(pos.position)
+                if qty == 0:
+                    continue
+                action = "SELL" if qty > 0 else "BUY"
+                order = MarketOrder(action, abs(qty))
+                if self._account_id:
+                    order.account = self._account_id
+                self._ib.placeOrder(pos.contract, order)
+                closed_any = True
+
+            if closed_any:
+                self._ib.sleep(0.5)
+            return closed_any
+        except Exception as e:
+            print(f"IBTWSBroker: close_all failed for {symbol}: {e}")
+            return False
+
+    def get_positions(self) -> Dict[str, Position]:
+        positions: Dict[str, Position] = {}
+        if not self.is_connected():
+            return positions
+
+        try:
+            for pos in self._ib.positions():
+                qty = float(pos.position)
+                if qty == 0:
+                    continue
+
+                symbol = f"{pos.contract.symbol}{getattr(pos.contract, 'currency', '')}"
+                market_price = self.get_price(symbol) or float(pos.avgCost)
+                side = 1 if qty > 0 else -1
+                unrealized = side * abs(qty) * (market_price - float(pos.avgCost))
+
+                positions[symbol] = Position(
+                    symbol=symbol,
+                    side=side,
+                    quantity=abs(qty),
+                    entry_price=float(pos.avgCost),
+                    current_price=float(market_price),
+                    unrealized_pnl=float(unrealized),
+                )
+        except Exception as e:
+            print(f"IBTWSBroker: get_positions failed: {e}")
+
+        return positions
+
+    def get_balance(self) -> float:
+        if not self.is_connected():
+            return 0.0
+        try:
+            values = self._ib.accountSummary()
+            for row in values:
+                if row.tag == "TotalCashValue" and (not self._account_id or row.account == self._account_id):
+                    return float(row.value)
+        except Exception as e:
+            print(f"IBTWSBroker: get_balance failed: {e}")
+        return 0.0
+
+    def get_equity(self) -> float:
+        if not self.is_connected():
+            return 0.0
+        try:
+            values = self._ib.accountSummary()
+            for row in values:
+                if row.tag == "NetLiquidation" and (not self._account_id or row.account == self._account_id):
+                    return float(row.value)
+        except Exception as e:
+            print(f"IBTWSBroker: get_equity failed: {e}")
+        return 0.0

forexsmartbot/adapters/brokers/mt4_broker.py

@@ -0,0 +1,266 @@
+"""MetaTrader 4 broker implementation via file communication."""
+
+import json
+import time
+import os
+import subprocess
+from typing import Dict, Optional
+from datetime import datetime
+from ...core.interfaces import IBroker, Position, Order
+
+
+class MT4Broker(IBroker):
+    """MT4 broker implementation using file communication."""
+    
+    def __init__(self, host: str = "127.0.0.1", port: int = 5555):
+        self._host = host
+        self._port = port
+        self._connected = False
+        self._files_dir = self._find_mt4_files_dir()
+        
+    def _find_mt4_files_dir(self) -> str:
+        """Find MT4 Files directory."""
+        # First try to find the terminal-specific directory
+        terminal_dirs = []
+        base_path = os.path.join(os.getenv('APPDATA'), 'MetaQuotes', 'Terminal')
+        if os.path.exists(base_path):
+            for item in os.listdir(base_path):
+                if os.path.isdir(os.path.join(base_path, item)) and item != 'MQL4':
+                    mql4_path = os.path.join(base_path, item, 'MQL4', 'Files')
+                    if os.path.exists(mql4_path):
+                        terminal_dirs.append(mql4_path)
+        
+        # Use the exact terminal-specific directory that MT4 EA is looking in
+        terminal_specific_path = os.path.join(os.getenv('APPDATA'), 'MetaQuotes', 'Terminal', '0727F3F88B5F0FE006962B330B91FF37', 'MQL4', 'Files')
+        
+        # Add other possible paths
+        possible_paths = [
+            terminal_specific_path,
+            os.path.join(os.getenv('APPDATA'), 'MetaQuotes', 'Terminal', 'MQL4', 'Files'),
+        ] + terminal_dirs + [
+            os.path.join(os.getenv('APPDATA'), 'MetaQuotes', 'Terminal', 'Files'),
+            os.path.join(os.getenv('USERPROFILE'), 'AppData', 'Roaming', 'MetaQuotes', 'Terminal', 'MQL4', 'Files')
+        ]
+        
+        for path in possible_paths:
+            if os.path.exists(path):
+                print(f"MT4Broker: Found MT4 Files directory: {path}")
+                return path
+        
+        # Create default directory if none exists
+        default_path = os.path.join(os.getenv('APPDATA'), 'MetaQuotes', 'Terminal', 'MQL4', 'Files')
+        os.makedirs(default_path, exist_ok=True)
+        print(f"MT4Broker: Created default MT4 Files directory: {default_path}")
+        return default_path
+        
+    def connect(self) -> bool:
+        """Connect to MT4."""
+        try:
+            # Check if MT4 is running (check both terminal.exe and terminal64.exe)
+            # Use errors='ignore' to handle any encoding issues with subprocess output
+            result = subprocess.run(['tasklist', '/FI', 'IMAGENAME eq terminal.exe'], 
+                                  capture_output=True, text=True, encoding='utf-8', errors='ignore')
+            result64 = subprocess.run(['tasklist', '/FI', 'IMAGENAME eq terminal64.exe'], 
+                                   capture_output=True, text=True, encoding='utf-8', errors='ignore')
+            
+            if 'terminal.exe' in result.stdout or 'terminal64.exe' in result64.stdout:
+                self._connected = True
+                print(f"MT4Broker: Connected to running MT4 instance")
+                print(f"MT4Broker: Using files directory: {self._files_dir}")
+                return True
+            else:
+                print("MT4Broker: MT4 not running - please start MT4 first")
+                self._connected = False
+                return False
+        except Exception as e:
+            print(f"MT4Broker: Connection error: {e}")
+            self._connected = False
+            return False
+            
+    def disconnect(self) -> None:
+        """Disconnect from MT4."""
+        self._connected = False
+        
+    def is_connected(self) -> bool:
+        """Check if connected to MT4."""
+        return self._connected
+        
+    def _execute_command(self, command: str) -> bool:
+        """Execute command via file communication with MT4 EA."""
+        try:
+            command_file = os.path.join(self._files_dir, 'ForexSmartBot_Command.txt')
+            
+            # Wait for EA to finish processing any previous command
+            max_wait = 10  # Wait up to 10 seconds
+            wait_count = 0
+            while os.path.exists(command_file) and wait_count < max_wait:
+                time.sleep(0.5)
+                wait_count += 1
+            
+            with open(command_file, 'w') as f:
+                f.write(command)
+            
+            # Wait for EA to process the command
+            time.sleep(2.0)  # Give EA time to process
+            
+            print(f"MT4Broker: Command written to file: {command}")
+            return True
+            
+        except Exception as e:
+            print(f"MT4Broker: Error writing command file: {e}")
+            return False
+            
+    def get_price(self, symbol: str) -> Optional[float]:
+        """Get current price from MT4."""
+        if not self._connected:
+            print("MT4Broker: Not connected to MT4")
+            return None
+            
+        try:
+            # Request price from MT4
+            self._execute_command(f"GetPrice({symbol})")
+            
+            # Wait for EA to process
+            time.sleep(1.0)
+            
+            # Read price from response file
+            response_file = os.path.join(self._files_dir, 'ForexSmartBot_Price.txt')
+            if os.path.exists(response_file):
+                with open(response_file, 'r') as f:
+                    content = f.read().strip()
+                    if content:
+                        price = float(content)
+                        print(f"MT4Broker: Got real price from MT4 for {symbol}: {price}")
+                        return price
+        except Exception as e:
+            print(f"MT4Broker: Error reading price: {e}")
+        
+        print(f"MT4Broker: Using fallback price for {symbol}")
+        return 1.0700 if symbol == "EURUSD" else 1.2500
+        
+    def submit_order(self, symbol: str, side: int, quantity: float, 
+                    stop_loss: Optional[float] = None, 
+                    take_profit: Optional[float] = None) -> Optional[str]:
+        """Submit order to MT4."""
+        if not self._connected:
+            print("MT4Broker: Not connected to MT4")
+            return None
+            
+        try:
+            # Create order command for MT4
+            order_type = "BUY" if side > 0 else "SELL"
+            sl_str = f" SL={stop_loss}" if stop_loss else ""
+            tp_str = f" TP={take_profit}" if take_profit else ""
+            
+            # Use a simpler command format that the EA can detect
+            command = f"OrderSend({symbol},{order_type},{quantity}{sl_str}{tp_str})"
+            print(f"MT4Broker: Command format: {command}")
+            print(f"MT4Broker: Command length: {len(command)}")
+            
+            print(f"MT4Broker: Executing real MT4 order: {command}")
+            
+            # Execute the order in MT4
+            if self._execute_command(command):
+                order_id = f"MT4_{int(time.time() * 1000)}"
+                print(f"MT4Broker: Order submitted successfully: {order_id}")
+                return order_id
+            else:
+                print("MT4Broker: Failed to submit order")
+                return None
+                
+        except Exception as e:
+            print(f"MT4Broker: Error submitting order: {e}")
+            return None
+        
+    def close_all(self, symbol: str) -> bool:
+        """Close all positions for symbol."""
+        if not self._connected:
+            print("MT4Broker: Not connected to MT4")
+            return False
+            
+        try:
+            command = f"CloseAll({symbol})"
+            print(f"MT4Broker: Closing all positions for {symbol}")
+            
+            if self._execute_command(command):
+                print(f"MT4Broker: Successfully closed all positions for {symbol}")
+                return True
+            else:
+                print(f"MT4Broker: Failed to close positions for {symbol}")
+                return False
+                
+        except Exception as e:
+            print(f"MT4Broker: Error closing positions: {e}")
+            return False
+        
+    def get_positions(self) -> Dict[str, Position]:
+        """Get positions from MT4."""
+        positions = {}
+        
+        if not self._connected:
+            print("MT4Broker: Not connected to MT4")
+            return positions
+        
+        try:
+            # Request positions from MT4
+            self._execute_command("GetPositions()")
+            
+            # Wait for EA to process
+            time.sleep(1.0)
+            
+            # Read positions from MT4 response file
+            response_file = os.path.join(self._files_dir, 'ForexSmartBot_Positions.txt')
+            if os.path.exists(response_file):
+                with open(response_file, 'r') as f:
+                    content = f.read().strip()
+                    if content:
+                        import json
+                        positions_data = json.loads(content)
+                        for pos_data in positions_data:
+                            symbol = pos_data['symbol']
+                            positions[symbol] = Position(
+                                symbol=symbol,
+                                side=pos_data['side'],
+                                quantity=pos_data['volume'],
+                                entry_price=pos_data['entry_price'],
+                                current_price=pos_data['current_price'],
+                                stop_loss=pos_data.get('sl', 0),
+                                take_profit=pos_data.get('tp', 0),
+                                pnl=pos_data.get('profit', 0)
+                            )
+                        print(f"MT4Broker: Retrieved {len(positions)} positions from MT4")
+        except Exception as e:
+            print(f"MT4Broker: Error reading positions: {e}")
+        
+        return positions
+        
+    def get_balance(self) -> float:
+        """Get account balance from MT4."""
+        try:
+            # Request balance from MT4
+            self._execute_command("GetBalance()")
+            
+            # Wait a moment for the EA to process
+            import time
+            time.sleep(0.5)
+            
+            # Read balance from response file
+            response_file = os.path.join(self._files_dir, 'ForexSmartBot_Balance.txt')
+            if os.path.exists(response_file):
+                with open(response_file, 'r') as f:
+                    content = f.read().strip()
+                    if content:
+                        balance = float(content)
+                        print(f"MT4Broker: Got real balance from MT4: ${balance}")
+                        return balance
+        except Exception as e:
+            print(f"MT4Broker: Error reading balance: {e}")
+        
+        print("MT4Broker: Using fallback balance - EA not responding")
+        return 10000.0  # Fallback
+        
+    def get_equity(self) -> float:
+        """Get account equity from MT4."""
+        # For now, return a simulated equity
+        # In production, this would read from MT4's account data
+        return 10000.0

forexsmartbot/adapters/brokers/paper_broker.py

@@ -0,0 +1,131 @@
+"""Paper trading broker implementation."""
+
+from typing import Dict, Optional
+from datetime import datetime
+from ...core.interfaces import IBroker, Position, Order
+
+
+class PaperBroker(IBroker):
+    """Paper trading broker for backtesting and simulation."""
+    
+    def __init__(self, initial_balance: float = 10000.0):
+        self._balance = initial_balance
+        self._positions: Dict[str, Position] = {}
+        self._orders: Dict[str, Order] = {}
+        self._connected = False
+        self._order_counter = 0
+        
+    def connect(self) -> bool:
+        """Connect to paper broker (always successful)."""
+        self._connected = True
+        return True
+        
+    def disconnect(self) -> None:
+        """Disconnect from paper broker."""
+        self._connected = False
+        
+    def is_connected(self) -> bool:
+        """Check if connected."""
+        return self._connected
+        
+    def get_price(self, symbol: str) -> Optional[float]:
+        """Get current price with realistic simulation."""
+        # Get base price for symbol
+        base_prices = {
+            'EURUSD': 1.1800,
+            'GBPUSD': 1.2500,
+            'USDJPY': 150.0,
+            'AUDUSD': 0.7500,
+            'USDCAD': 1.3500
+        }
+        
+        base_price = base_prices.get(symbol, 1.0000)
+        
+        # Add realistic price movement
+        import random
+        import time
+        
+        # Use time-based seed for consistent but changing prices
+        random.seed(int(time.time() / 60))  # Change every minute
+        price_change = random.uniform(-0.001, 0.001)  # Small random change
+        
+        return base_price + price_change
+        
+    def submit_order(self, symbol: str, side: int, quantity: float, 
+                    stop_loss: Optional[float] = None, 
+                    take_profit: Optional[float] = None) -> Optional[str]:
+        """Submit a paper order."""
+        if not self._connected:
+            return None
+            
+        order_id = f"PAPER_{self._order_counter}"
+        self._order_counter += 1
+        
+        # Create order
+        order = Order(
+            symbol=symbol,
+            side=side,
+            quantity=quantity,
+            entry_price=0.0,  # Will be filled with current price
+            stop_loss=stop_loss,
+            take_profit=take_profit
+        )
+        
+        self._orders[order_id] = order
+        return order_id
+        
+    def close_all(self, symbol: str) -> bool:
+        """Close all positions for symbol."""
+        if symbol in self._positions:
+            del self._positions[symbol]
+            return True
+        return False
+        
+    def get_positions(self) -> Dict[str, Position]:
+        """Get all open positions."""
+        return self._positions.copy()
+        
+    def get_balance(self) -> float:
+        """Get account balance."""
+        return self._balance
+        
+    def get_equity(self) -> float:
+        """Get account equity."""
+        unrealized_pnl = sum(pos.unrealized_pnl for pos in self._positions.values())
+        return self._balance + unrealized_pnl
+        
+    def update_position(self, symbol: str, side: int, quantity: float, 
+                       entry_price: float, current_price: float) -> None:
+        """Update or create a position."""
+        unrealized_pnl = side * quantity * (current_price - entry_price)
+        
+        position = Position(
+            symbol=symbol,
+            side=side,
+            quantity=quantity,
+            entry_price=entry_price,
+            current_price=current_price,
+            unrealized_pnl=unrealized_pnl
+        )
+        
+        self._positions[symbol] = position
+        
+    def close_position(self, symbol: str, exit_price: float) -> Optional[float]:
+        """Close a position and return realized PnL."""
+        if symbol not in self._positions:
+            return None
+            
+        position = self._positions.pop(symbol)
+        realized_pnl = position.side * position.quantity * (exit_price - position.entry_price)
+        self._balance += realized_pnl
+        
+        return realized_pnl
+        
+    def update_prices(self, prices: Dict[str, float]) -> None:
+        """Update position prices and calculate unrealized PnL."""
+        for symbol, position in self._positions.items():
+            if symbol in prices:
+                position.current_price = prices[symbol]
+                position.unrealized_pnl = position.side * position.quantity * (
+                    position.current_price - position.entry_price
+                )