bbstrader 0.3.1__py3-none-any.whl → 0.3.3__py3-none-any.whl

bbstrader/trading/execution.py

@@ -1,7 +1,10 @@
+import concurrent.futures
+import functools
 import multiprocessing as mp
 import sys
 import time
 from datetime import date, datetime
+from multiprocessing.synchronize import Event
 from typing import Callable, Dict, List, Literal, Optional
 
 import pandas as pd
@@ -9,7 +12,7 @@ from loguru import logger as log
 
 from bbstrader.btengine.strategy import MT5Strategy, Strategy
 from bbstrader.config import BBSTRADER_DIR
-from bbstrader.metatrader.account import Account, check_mt5_connection
+from bbstrader.metatrader.account import check_mt5_connection
 from bbstrader.metatrader.trade import Trade, TradeAction, TradingMode
 from bbstrader.trading.utils import send_message
 
@@ -37,6 +40,8 @@ _TF_MAPPING = {
     "D1": 1440,
 }
 
+MT5_ENGINE_TIMEFRAMES = list(_TF_MAPPING.keys())
+
 TradingDays = ["monday", "tuesday", "wednesday", "thursday", "friday"]
 WEEK_DAYS = TradingDays + ["saturday", "sunday"]
 FRIDAY = "friday"
@@ -177,6 +182,8 @@ class Mt5ExecutionEngine:
         mm: bool = True,
         auto_trade: bool = True,
         prompt_callback: Callable = None,
+        multithread: bool = False,
+        shutdown_event: Event = None,
         optimizer: str = "equal",
         trail: bool = True,
         stop_trail: Optional[int] = None,
@@ -205,6 +212,10 @@ class Mt5ExecutionEngine:
                 the user for confimation.
             prompt_callback : Callback function to prompt the user for confirmation.
                 This is useful when integrating with GUI applications.
+             multithread : If True, use a thread pool to process signals in parallel.
+                If False, process them sequentially. Set this to True only if the engine
+                is running in a separate process. Default to False.
+            shutdown_event : Use to terminate the copy process when runs in a custum environment like web App or GUI.
             show_positions_orders : Print open positions and orders. Defaults to False.
             iter_time : Interval to check for signals and `mm`. Defaults to 5.
             use_trade_time : Open trades after the time is completed. Defaults to True.
@@ -249,6 +260,7 @@ class Mt5ExecutionEngine:
         self.mm = mm
         self.auto_trade = auto_trade
         self.prompt_callback = prompt_callback
+        self.multithread = multithread
         self.optimizer = optimizer
         self.trail = trail
         self.stop_trail = stop_trail
@@ -272,6 +284,9 @@ class Mt5ExecutionEngine:
 
         self._initialize_engine(**kwargs)
         self.strategy = self._init_strategy(**kwargs)
+        self.shutdown_event = (
+            shutdown_event if shutdown_event is not None else mp.Event()
+        )
         self._running = True
 
     def __repr__(self):
@@ -314,16 +329,17 @@ class Mt5ExecutionEngine:
     def _print_exc(self, msg: str, e: Exception):
         if isinstance(e, KeyboardInterrupt):
             logger.info("Stopping the Execution Engine ...")
+            self.stop()
             sys.exit(0)
         if self.debug_mode:
             raise ValueError(msg).with_traceback(e.__traceback__)
         else:
-            logger.error(f"{msg, repr(e)}")
+            logger.error(f"{msg}: {type(e).__name__}: {str(e)}")
 
     def _max_trades(self, mtrades):
         max_trades = {
             symbol: mtrades[symbol]
-            if mtrades is not None and symbol in mtrades
+            if mtrades is not None and isinstance(mtrades, dict) and symbol in mtrades
             else self.trades_instances[symbol].max_trade()
             for symbol in self.symbols
         }
@@ -338,7 +354,7 @@ class Mt5ExecutionEngine:
             expert_ids = [expert_ids]
         return expert_ids
 
-    def _init_strategy(self, **kwargs) -> Strategy | MT5Strategy:
+    def _init_strategy(self, **kwargs) -> MT5Strategy:
         try:
             check_mt5_connection(**kwargs)
             strategy = self.strategy_cls(
@@ -356,7 +372,7 @@ class Mt5ExecutionEngine:
         return strategy
 
     def _get_signal_info(self, signal, symbol, price, stoplimit):
-        account = Account(**self.kwargs)
+        account = self.strategy.account
         symbol_info = account.get_symbol_info(symbol)
 
         common_data = {
@@ -512,6 +528,9 @@ class Mt5ExecutionEngine:
                 or (period_type == "day" and closing)
                 or (period_type == "24/7" and closing)
             ):
+                logger.info(
+                    f"{self.ACCOUNT} Closing all positions and orders for {symbol} ..."
+                )
                 for id in self.expert_ids:
                     trade.close_positions(
                         position_type="all", id=id, comment=self.comment
@@ -627,13 +646,15 @@ class Mt5ExecutionEngine:
             )
             pass
 
-    def _handle_auto_trade(self, sigmsg, symbol) -> bool:
+    def _auto_trade(self, sigmsg, symbol) -> bool:
         if self.notify:
             self._send_notification(sigmsg, symbol)
         if self.auto_trade:
             return True
         if not self.auto_trade:
-            prompt = f"{sigmsg} \n Enter Y/Yes to accept or N/No to reject this order : "
+            prompt = (
+                f"{sigmsg} \n Enter Y/Yes to accept or N/No to reject this order : "
+            )
             if self.prompt_callback is not None:
                 auto_trade = self.prompt_callback(prompt)
             else:
@@ -649,7 +670,7 @@ class Mt5ExecutionEngine:
     def _open_buy(
         self, signal, symbol, id, trade: Trade, price, stoplimit, sigmsg, msg, comment
     ):
-        if not self._handle_auto_trade(sigmsg, symbol):
+        if not self._auto_trade(sigmsg, symbol):
             return
         if not self._check_retcode(trade, "BMKT"):
             logger.info(msg)
@@ -666,7 +687,7 @@ class Mt5ExecutionEngine:
     def _open_sell(
         self, signal, symbol, id, trade: Trade, price, stoplimit, sigmsg, msg, comment
     ):
-        if not self._handle_auto_trade(sigmsg, symbol):
+        if not self._auto_trade(sigmsg, symbol):
             return
         if not self._check_retcode(trade, "SMKT"):
             logger.info(msg)
@@ -859,46 +880,79 @@ class Mt5ExecutionEngine:
                     f"(e.g., if time_frame is 15m, iter_time must be 1.5, 3, 5, 15 etc)"
                 )
 
-    def _handle_signals(self, today, signals, buys, sells):
+    def _handle_one_signal(self, signal, today, buys, sells):
         try:
-            check_mt5_connection(**self.kwargs)
-            for signal in signals:
-                symbol = signal.symbol
-                trade: Trade = self.trades_instances[symbol]
-                if trade.trading_time() and today in self.trading_days:
-                    if signal.action is not None:
-                        action = (
-                            signal.action.value
-                            if isinstance(signal.action, TradeAction)
-                            else signal.action
-                        )
-                        self._run_trade_algorithm(
-                            action,
-                            symbol,
-                            signal.id,
-                            trade,
-                            signal.price,
-                            signal.stoplimit,
-                            buys,
-                            sells,
-                            signal.comment or self.comment,
-                        )
-                else:
-                    if len(self.symbols) >= 10:
-                        if symbol == self.symbols[-1]:
-                            logger.info(
-                                f"Not trading Time !!!, STRATEGY={self.STRATEGY} , ACCOUNT={self.ACCOUNT}"
-                            )
-                    else:
+            symbol = signal.symbol
+            trade: Trade = self.trades_instances[symbol]
+            if trade.trading_time() and today in self.trading_days:
+                if signal.action is not None:
+                    action = (
+                        signal.action.value
+                        if isinstance(signal.action, TradeAction)
+                        else signal.action
+                    )
+                    self._run_trade_algorithm(
+                        action,
+                        symbol,
+                        signal.id,
+                        trade,
+                        signal.price,
+                        signal.stoplimit,
+                        buys,
+                        sells,
+                        signal.comment or self.comment,
+                    )
+            else:
+                if len(self.symbols) >= 10:
+                    if symbol == self.symbols[-1]:
                         logger.info(
-                            f"Not trading Time !!! SYMBOL={trade.symbol}, STRATEGY={self.STRATEGY} , ACCOUNT={self.ACCOUNT}"
+                            f"Not trading Time !!!, STRATEGY={self.STRATEGY} , ACCOUNT={self.ACCOUNT}"
                         )
-                    self._check(buys[symbol], sells[symbol], symbol)
+                else:
+                    logger.info(
+                        f"Not trading Time !!! SYMBOL={trade.symbol}, STRATEGY={self.STRATEGY} , ACCOUNT={self.ACCOUNT}"
+                    )
+                self._check(buys[symbol], sells[symbol], symbol)
 
         except Exception as e:
-            msg = f"Handling Signals, SYMBOL={symbol}, STRATEGY={self.STRATEGY} , ACCOUNT={self.ACCOUNT}"
+            msg = (
+                f"Error handling signal for SYMBOL={signal.symbol} (SIGNAL: {action}), "
+                f"STRATEGY={self.STRATEGY}, ACCOUNT={self.ACCOUNT}"
+            )
             self._print_exc(msg, e)
-            pass
+
+    def _handle_all_signals(self, today, signals, buys, sells, max_workers=50):
+        try:
+            check_mt5_connection(**self.kwargs)
+        except Exception as e:
+            msg = "Initial MT5 connection check failed. Aborting signal processing."
+            self._print_exc(msg, e)
+            return
+
+        if not signals:
+            logger.info("No signals to process.")
+            return
+
+        # We want to create a temporary function that
+        # already has the 'today', 'buys', and 'sells' arguments filled in.
+        # This is necessary because executor.map only iterates over one sequence (signals).
+        signal_processor = functools.partial(
+            self._handle_one_signal, today=today, buys=buys, sells=sells
+        )
+        if self.multithread:
+            with concurrent.futures.ThreadPoolExecutor(
+                max_workers=max_workers
+            ) as executor:
+                # 'map' will apply our worker function to every item in the 'signals' list.
+                # It will automatically manage the distribution of tasks to the worker threads.
+                # We wrap it in list() to ensure all tasks are complete before moving on.
+                list(executor.map(signal_processor, signals))
+        else:
+            for signal in signals:
+                try:
+                    signal_processor(signal)
+                except Exception as e:
+                    self._print_exc(f"Failed to process signal {signal}: ", e)
 
     def _handle_period_end_actions(self, today):
         try:
@@ -918,7 +972,7 @@ class Mt5ExecutionEngine:
             pass
 
     def run(self):
-        while self._running:
+        while self._running and not self.shutdown_event.is_set():
             try:
                 check_mt5_connection(**self.kwargs)
                 positions_orders = self._check_positions_orders()
@@ -936,23 +990,27 @@ class Mt5ExecutionEngine:
                         self._check(buys[symbol], sells[symbol], symbol)
                 else:
                     self._update_risk(weights)
-                    self._handle_signals(today, signals, buys, sells)
+                    self._handle_all_signals(today, signals, buys, sells)
                 self._sleep()
                 self._handle_period_end_actions(today)
             except KeyboardInterrupt:
                 logger.info(
-                    f"Stopping Execution Engine for {self.STRATEGY} on {self.ACCOUNT}"
+                    f"Stopping Execution Engine for {self.STRATEGY} STRATEGY on {self.ACCOUNT} Account"
                 )
-                break
+                self.stop()
+                sys.exit(0)
             except Exception as e:
                 msg = f"Running Execution Engine, STRATEGY={self.STRATEGY} , ACCOUNT={self.ACCOUNT}"
                 self._print_exc(msg, e)
-                continue
 
     def stop(self):
         """Stops the execution engine."""
-        self._running = False
-        logger.info(f"Stopping Execution Engine for {self.STRATEGY} on {self.ACCOUNT}")
+        if self._running:
+            logger.info(
+                f"Stopping Execution Engine for {self.STRATEGY} STRATEGY on {self.ACCOUNT} Account"
+            )
+            self._running = False
+            self.shutdown_event.set()
         logger.info("Execution Engine stopped successfully.")
 
 
@@ -1000,6 +1058,7 @@ def RunMt5Engines(accounts: Dict[str, Dict], start_delay: float = 1.0):
 
     for account_id, params in accounts.items():
         log.info(f"Starting process for {account_id}")
+        params["multithread"] = True
         process = mp.Process(target=RunMt5Engine, args=(account_id,), kwargs=params)
         process.start()
         processes[process] = account_id