bbstrader 0.2.0__py3-none-any.whl → 0.2.1__py3-none-any.whl

bbstrader/trading/execution.py

@@ -1,19 +1,15 @@
 import time
+import traceback
+import MetaTrader5 as MT5
 from datetime import datetime
+from logging import Logger
+from typing import Dict, List, Literal, Optional
+
+from bbstrader.btengine.strategy import MT5Strategy, Strategy
+from bbstrader.metatrader.account import check_mt5_connection
 from bbstrader.metatrader.trade import Trade
-from bbstrader.btengine.strategy import(
-    Strategy,
-    MT5Strategy
-)
 from bbstrader.trading.scripts import send_message
-from bbstrader.metatrader.account import check_mt5_connection
-from typing import (
-    Optional, 
-    Literal, 
-    Tuple, 
-    List,  
-    Dict
-)
+from bbstrader.core.utils import TradeAction
 
 __all__ = [
     'MT5ExecutionEngine',
@@ -37,23 +33,23 @@ _TF_MAPPING = {
 }
 
 TradingDays = [
-    'monday', 
-    'tuesday', 
-    'wednesday', 
-    'thursday', 
+    'monday',
+    'tuesday',
+    'wednesday',
+    'thursday',
     'friday'
 ]
 
-BUYS    = ['BMKT', 'BLMT', 'BSTP', 'BSTPLMT']
-SELLS   = ['SMKT', 'SLMT', 'SSTP', 'SSTPLMT']
+BUYS = ['BMKT', 'BLMT', 'BSTP', 'BSTPLMT']
+SELLS = ['SMKT', 'SLMT', 'SSTP', 'SSTPLMT']
 
-ORDERS_TYPES    = ["orders","buy_stops", "sell_stops", "buy_limits", 
-                    "sell_limits", "buy_stop_limits", "sell_stop_limits"]
+ORDERS_TYPES = ["orders", "buy_stops", "sell_stops", "buy_limits",
+                "sell_limits", "buy_stop_limits", "sell_stop_limits"]
 POSITIONS_TYPES = ["positions", "buys", "sells", "profitables", "losings"]
 
-ACTIONS     = ["buys", "sells"]
-STOPS       = ["buy_stops", "sell_stops"]
-LIMITS      = ["buy_limits", "sell_limits"]
+ACTIONS = ["buys", "sells"]
+STOPS = ["buy_stops", "sell_stops"]
+LIMITS = ["buy_limits", "sell_limits"]
 STOP_LIMITS = ["buy_stop_limits", "sell_stop_limits"]
 
 EXIT_SIGNAL_ACTIONS = {
@@ -68,33 +64,60 @@ EXIT_SIGNAL_ACTIONS = {
     "EXIT_SHORT_LIMIT":     {"sell_limits": "sell_limits"},
     "EXIT_STOP_LIMIT":      {sl: sl for sl in STOP_LIMITS},
     "EXIT_LONG_STOP_LIMIT": {STOP_LIMITS[0]: STOP_LIMITS[0]},
-    "EXIT_SHORT_STOP_LIMIT":{STOP_LIMITS[1]: STOP_LIMITS[1]},
-    "EXIT_PROFITABLES":     {"profitables": "profitables"},
-    "EXIT_LOSINGS":         {"losings": "losings"},
+    "EXIT_SHORT_STOP_LIMIT": {STOP_LIMITS[1]: STOP_LIMITS[1]},
+    "EXIT_PROFITABLES":     {"profitables": "profitable"},
+    "EXIT_LOSINGS":         {"losings": "losing"},
     "EXIT_ALL_POSITIONS":   {"positions": "all"},
     "EXIT_ALL_ORDERS":      {"orders": "all"}
 }
 
+COMMON_RETCODES = [
+    MT5.TRADE_RETCODE_MARKET_CLOSED,
+    MT5.TRADE_RETCODE_CLOSE_ONLY
+]
+
+NON_EXEC_RETCODES = {
+    'BMKT': [MT5.TRADE_RETCODE_SHORT_ONLY] + COMMON_RETCODES,
+    'SMKT': [MT5.TRADE_RETCODE_LONG_ONLY] + COMMON_RETCODES
+}
+
 
 def _mt5_execution(
-        symbol_list, trades_instances, strategy_cls, /,
-        mm, optimizer, trail, stop_trail, trail_after_points, be_plus_points, show_positions_orders,
-        iter_time, use_trade_time, period, period_end_action, closing_pnl, trading_days,
-        comment, **kwargs):
-    symbols  = symbol_list.copy()
+    symbol_list,
+    trades_instances,
+    strategy_cls, /,
+    mm,
+    optimizer,
+    trail,
+    stop_trail,
+    trail_after_points,
+    be_plus_points,
+    show_positions_orders,
+    iter_time,
+    use_trade_time,
+    period,
+    period_end_action,
+    closing_pnl,
+    trading_days,
+    comment,
+    **kwargs
+):
+    symbols = symbol_list.copy()
     time_frame = kwargs.get('time_frame', '15m')
     STRATEGY = kwargs.get('strategy_name')
-    mtrades  = kwargs.get('max_trades')
-    check_max_trades = kwargs.get('check_max_trades', True)
-    notify   = kwargs.get('notify', False)
+    mtrades = kwargs.get('max_trades')
+    notify = kwargs.get('notify', False)
     if notify:
-        telegram  = kwargs.get('telegram', False)
+        telegram = kwargs.get('telegram', False)
         bot_token = kwargs.get('bot_token')
-        chat_id   = kwargs.get('chat_id')
+        chat_id = kwargs.get('chat_id')
 
     expert_ids = kwargs.get('expert_id')
     if expert_ids is None:
-        expert_ids = set([trade.expert_id for trade in trades_instances.values()])
+        expert_ids = list(
+            set([trade.expert_id for trade in trades_instances.values()]))
+    elif isinstance(expert_ids, int):
+        expert_ids = [expert_ids]
 
     def update_risk(weights):
         if weights is not None:
@@ -104,11 +127,18 @@ def _mt5_execution(
                 trade = trades_instances[symbol]
                 trade.dailydd = round(weights[symbol], 5)
 
+    def check_retcode(trade: Trade, position):
+        if len(trade.retcodes) > 0:
+            for retcode in trade.retcodes:
+                if retcode in NON_EXEC_RETCODES[position]:
+                    return True
+        return False
+
     def _send_notification(signal):
-        send_message(message=signal, notify_me=notify, 
-                    telegram=telegram, token=bot_token, chat_id=chat_id)
-        
-    logger   = trades_instances[symbols[0]].logger
+        send_message(message=signal, notify_me=notify,
+                     telegram=telegram, token=bot_token, chat_id=chat_id)
+
+    logger: Logger = trades_instances[symbols[0]].logger
     max_trades = {symbol: mtrades[symbol]
                   if mtrades is not None and symbol in mtrades
                   else trades_instances[symbol].max_trade() for symbol in symbols}
@@ -121,23 +151,98 @@ def _mt5_execution(
             return
         if buys is not None or sells is not None:
             trades_instances[symbol].break_even(
-                mm=mm, trail=trail, stop_trail=stop_trail, 
+                mm=mm, trail=trail, stop_trail=stop_trail,
                 trail_after_points=trail_after_points, be_plus_points=be_plus_points)
-    num_days        = 0
-    time_intervals  = 0
-    trade_time      = _TF_MAPPING[time_frame]
+    num_days = 0
+    time_intervals = 0
+    trade_time = _TF_MAPPING[time_frame]
 
-    long_market   = {symbol: False for symbol in symbols}
-    short_market  = {symbol: False for symbol in symbols}
+    long_market = {symbol: False for symbol in symbols}
+    short_market = {symbol: False for symbol in symbols}
     try:
         check_mt5_connection(**kwargs)
-        strategy: MT5Strategy = strategy_cls(symbol_list=symbols, mode='live', **kwargs)
-    except Exception as e:
-        logger.error(f"Initializing strategy, {e}, STRATEGY={STRATEGY}")
+        strategy: MT5Strategy = strategy_cls(
+            symbol_list=symbols, mode='live', **kwargs)
+    except Exception:
+        logger.error(f"Initializing strategy, STRATEGY={STRATEGY}")
+        traceback.print_exc()
         return
     logger.info(
         f'Running {STRATEGY} Strategy in {time_frame} Interval ...')
-    
+
+    def run_trade_algorithm(signal, symbol, id, trade: Trade, price, stoplimit):
+        signal = 'BMKT' if signal == 'LONG' else signal
+        signal = 'SMKT' if signal == 'SHORT' else signal
+        info = f"SIGNAL = {signal}, SYMBOL={symbol}, STRATEGY={STRATEGY}, TIMEFRAME={time_frame}"
+        msg = f"Sending {signal} Order ... SYMBOL={symbol}, STRATEGY={STRATEGY}"
+        tfmsg = f"Time Frame Not completed !!! SYMBOL={symbol}, STRATEGY={STRATEGY}"
+        riskmsg = f"Risk not allowed !!! SYMBOL={symbol}, STRATEGY={STRATEGY}"
+        if signal not in EXIT_SIGNAL_ACTIONS:
+            if signal in NON_EXEC_RETCODES and not check_retcode(trade, signal):
+                logger.info(info)
+            elif signal not in NON_EXEC_RETCODES:
+                logger.info(info)
+        if signal in EXIT_SIGNAL_ACTIONS:
+            for exit_signal, actions in EXIT_SIGNAL_ACTIONS.items():
+                for position_type, order_type in actions.items():
+                    clos_func = getattr(
+                        trades_instances[symbol], f"get_current_{position_type}")
+                    if clos_func(id=id) is not None:
+                        if notify:
+                            _send_notification(info)
+                        if position_type in POSITIONS_TYPES:
+                            trade.close_positions(
+                                position_type=order_type, id=id)
+                        else:
+                            trade.close_orders(order_type=order_type, id=id)
+        elif signal in BUYS and not long_market[symbol]:
+            if use_trade_time:
+                if time_intervals % trade_time == 0 or buys[symbol] is None:
+                    if notify:
+                        _send_notification(info)
+                    if not check_retcode(trade, 'BMKT'):
+                        logger.info(msg)
+                        trade.open_buy_position(
+                            action=signal, price=price, stoplimit=stoplimit, id=id, mm=mm, comment=comment)
+                else:
+                    logger.info(tfmsg)
+                    check(buys[symbol], sells[symbol], symbol)
+            else:
+                if notify:
+                    _send_notification(info)
+                if not check_retcode(trade, 'BMKT'):
+                    logger.info(msg)
+                    trade.open_buy_position(
+                        action=signal, price=price, stoplimit=stoplimit, id=id, mm=mm, comment=comment)
+
+        elif signal in BUYS and long_market[symbol]:
+            logger.info(riskmsg)
+
+        elif signal in SELLS and not short_market[symbol]:
+            if use_trade_time:
+                if time_intervals % trade_time == 0 or sells[symbol] is None:
+                    if notify:
+                        _send_notification(info)
+                    if not check_retcode(trade, 'SMKT'):
+                        logger.info(msg)
+                        trade.open_sell_position(
+                            action=signal, price=price, stoplimit=stoplimit, id=id, mm=mm, comment=comment)
+                else:
+                    logger.info(tfmsg)
+                    check(buys[symbol], sells[symbol], symbol)
+            else:
+                if notify:
+                    _send_notification(info)
+                if not check_retcode(trade, 'SMKT'):
+                    logger.info(msg)
+                    trade.open_sell_position(
+                        action=signal, price=price, stoplimit=stoplimit, id=id, mm=mm, comment=comment)
+
+        elif signal in SELLS and short_market[symbol]:
+            logger.info(riskmsg)
+        else:
+            check(buys[symbol], sells[symbol], symbol)
+
     while True:
         try:
             check_mt5_connection(**kwargs)
@@ -150,7 +255,8 @@ def _mt5_execution(
                 for symbol in symbols:
                     positions_orders[type][symbol] = None
                     for id in expert_ids:
-                        func = getattr(trades_instances[symbol], f"get_current_{type}")
+                        func = getattr(
+                            trades_instances[symbol], f"get_current_{type}")
                         func_value = func(id=id)
                         if func_value is not None:
                             if positions_orders[type][symbol] is None:
@@ -166,120 +272,60 @@ def _mt5_execution(
                             logger.info(
                                 f"Current {type.upper()} SYMBOL={symbol}: \
                                     {positions_orders[type][symbol]}, STRATEGY={STRATEGY}")
-            if check_max_trades:
-                long_market = {
-                    symbol: buys[symbol] is not None 
-                    and len(buys[symbol]) >= max_trades[symbol] for symbol in symbols
-                }
-                short_market = {
-                    symbol: sells[symbol] is not None 
-                    and len(sells[symbol]) >= max_trades[symbol] for symbol in symbols
-                }
-
-        except Exception as e:
-            logger.error(f"Handling Positions and Orders, {e}, STRATEGY={STRATEGY}")
+            long_market = {
+                symbol: buys[symbol] is not None
+                and len(buys[symbol]) >= max_trades[symbol] for symbol in symbols
+            }
+            short_market = {
+                symbol: sells[symbol] is not None
+                and len(sells[symbol]) >= max_trades[symbol] for symbol in symbols
+            }
+
+        except Exception:
+            logger.error(
+                f"Handling Positions and Orders, STRATEGY={STRATEGY}")
+            traceback.print_exc()
             continue
         time.sleep(0.5)
         try:
             check_mt5_connection(**kwargs)
             signals = strategy.calculate_signals()
-            weights = None
-            if hasattr(strategy, 'apply_risk_management'):
-                weights = strategy.apply_risk_management(optimizer)
+            weights = (
+                strategy.apply_risk_management(optimizer)
+                if hasattr(strategy, 'apply_risk_management')
+                else None
+            )
             update_risk(weights)
-        except Exception as e:
-            logger.error(f"Calculating signal, {e}, STRATEGY={STRATEGY}")
+        except Exception:
+            logger.error(f"Calculating signal, STRATEGY={STRATEGY}")
+            traceback.print_exc()
             continue
-        for symbol in symbols:
+        for signal in signals:
             try:
                 check_mt5_connection(**kwargs)
+                symbol = signal.symbol
                 trade: Trade = trades_instances[symbol]
-                tfmsg = f"Time Frame Not completed !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}"
-                riskmsg = f"Risk not allowed !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}"
-                signal = signals[symbol]
-                if isinstance(signal, dict):
-                    action = signal.get('action')
-                    price = signal.get('price')
-                    id = signal.get('id', trade.expert_id)
-                    stoplimit = signal.get('stoplimit')
-                    signal = action
-                elif isinstance(signal, str):
-                    price = None
-                    stoplimit = None
-                    id = trade.expert_id
                 if trade.trading_time() and today in trading_days:
-                    if signal is not None:
-                        signal = 'BMKT' if signal == 'LONG' else signal
-                        signal = 'SMKT' if signal == 'SHORT' else signal
-                        info = f"SIGNAL = {signal}, SYMBOL={trade.symbol}, STRATEGY={STRATEGY}, TIMEFRAME={time_frame}"
-                        msg = f"Sending {signal} Order ... SYMBOL={trade.symbol}, STRATEGY={STRATEGY}"
-                        if signal not in EXIT_SIGNAL_ACTIONS:
-                            logger.info(info)
-                        if signal in EXIT_SIGNAL_ACTIONS:
-                            for exit_signal, actions in EXIT_SIGNAL_ACTIONS.items():
-                                for position_type, order_type in actions.items():
-                                    if positions_orders[position_type][symbol] is not None:
-                                        if notify:
-                                            _send_notification(info)
-                                        if position_type in POSITIONS_TYPES:
-                                            trade.close_positions(position_type=order_type, id=id)
-                                        else:
-                                            trade.close_orders(order_type=order_type, id=id)
-                        elif signal in BUYS and not long_market[symbol]:
-                            if use_trade_time:
-                                if time_intervals % trade_time == 0 or buys[symbol] is None:
-                                    logger.info(msg)
-                                    if notify:
-                                        _send_notification(info)
-                                    trade.open_buy_position(
-                                        action=signal, price=price, stoplimit=stoplimit, id=id, mm=mm, comment=comment)
-                                else:
-                                    logger.info(tfmsg)
-                                    check(buys[symbol], sells[symbol], symbol)
-                            else:
-                                logger.info(msg)
-                                if notify:
-                                    _send_notification(info)
-                                trade.open_buy_position(
-                                    action=signal, price=price, stoplimit=stoplimit, id=id, mm=mm, comment=comment)
-                        elif signal in BUYS:
-                            if check_max_trades:
-                                if long_market[symbol]:
-                                    logger.info(riskmsg)
-                            check(buys[symbol], sells[symbol], symbol)
-
-                        elif signal in SELLS and not short_market[symbol]:
-                            if use_trade_time:
-                                if time_intervals % trade_time == 0 or sells[symbol] is None:
-                                    logger.info(msg)
-                                    if notify:
-                                        _send_notification(info)
-                                    trade.open_sell_position(
-                                        action=signal, price=price, stoplimit=stoplimit, id=id, mm=mm, comment=comment)
-                                else:
-                                    logger.info(tfmsg)
-                                    check(buys[symbol], sells[symbol], symbol)
-                            else:
-                                logger.info(msg)
-                                if notify:
-                                    _send_notification(info)
-                                trade.open_sell_position(
-                                    action=signal, price=price, stoplimit=stoplimit, id=id, mm=mm, comment=comment)
-                        elif signal in SELLS:
-                            if check_max_trades:
-                                if short_market[symbol]:
-                                    logger.info(riskmsg)
-                            check(buys[symbol], sells[symbol], symbol)
-                    else:
-                        check(buys[symbol], sells[symbol], symbol)
+                    action = (
+                        signal.action.value if isinstance(signal.action, TradeAction)
+                        else signal.action
+                    )
+                    run_trade_algorithm(
+                        action, symbol, signal.id, trade, signal.price, signal.stoplimit)
+                elif len(symbols) > 10 and symbol == symbols[-1]:
+                    logger.info(
+                        f"Not trading Time !!!, STRATEGY={STRATEGY}")
                 else:
                     logger.info(
                         f"Not trading Time !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
-                    check(buys[symbol], sells[symbol], symbol)
+                check(buys[symbol], sells[symbol], symbol)
 
-            except Exception as e:
-                logger.error(f"Handling Signals {e}, SYMBOL={symbol}, STRATEGY={STRATEGY}")
+            except Exception:
+                logger.error(
+                    f"Handling Signals, SYMBOL={symbol}, STRATEGY={STRATEGY}")
+                traceback.print_exc()
                 continue
+
         time.sleep((60 * iter_time) - 1.0)
         if iter_time == 1:
             time_intervals += 1
@@ -293,24 +339,35 @@ def _mt5_execution(
         try:
             FRIDAY = 'friday'
             check_mt5_connection(**kwargs)
-            day_end = all(trade.days_end() for trade in trades_instances.values())
+            day_end = all(trade.days_end()
+                          for trade in trades_instances.values())
             if closing_pnl is not None:
-                closing = all(trade.positive_profit(id=trade.expert_id, th=closing_pnl) 
-                                  for trade in trades_instances.values())
-            else: closing = True
-            logmsg = lambda period: logger.info(
-                f"End of the {period} !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
-            sleepmsg = lambda sleep_time: logger.info(
+                closing = all(trade.positive_profit(id=trade.expert_id, th=closing_pnl)
+                              for trade in trades_instances.values())
+            else:
+                closing = True
+
+            def logmsg(period, symbol): return logger.info(
+                f"End of the {period} !!! SYMBOL={symbol}, STRATEGY={STRATEGY}")
+
+            def logmsgif(period, symbol):
+                return (
+                    logmsg(period, symbol) if len(symbols) <= 10 and symbol == symbols[-1]
+                    else logger.info(f'Not trading Time !!! , STRATEGY={STRATEGY}')
+                )
+            def sleepmsg(sleep_time): return logger.info(
                 f"Sleeping for {sleep_time} minutes ...\n")
-            sessionmsg = f"STARTING NEW TRADING SESSION ...\n"
+            sessionmsg = "STARTING NEW TRADING SESSION ...\n"
             if period.lower() == 'day':
                 for symbol in symbols:
                     trade = trades_instances[symbol]
                     if trade.days_end() and closing:
                         for id in expert_ids:
-                            trade.close_positions(position_type='all', id=id, comment=comment)
-                        logmsg("Day")
+                            trade.close_positions(
+                                position_type='all', id=id, comment=comment)
+                        logmsgif("Day", symbol)
                         trade.statistics(save=True)
+                strategy.perform_period_end_checks()
                 if day_end:
                     if period_end_action == 'break' and closing:
                         break
@@ -320,7 +377,8 @@ def _mt5_execution(
                         time.sleep(60 * sleep_time)
                         logger.info(sessionmsg)
                     elif period_end_action == 'sleep' and today == FRIDAY:
-                        sleep_time = trades_instances[symbols[-1]].sleep_time(weekend=True)
+                        sleep_time = trades_instances[symbols[-1]
+                                                      ].sleep_time(weekend=True)
                         sleepmsg(sleep_time)
                         time.sleep(60 * sleep_time)
                         logger.info(sessionmsg)
@@ -329,13 +387,15 @@ def _mt5_execution(
                 for symbol in symbols:
                     trade = trades_instances[symbol]
                     if trade.days_end() and today != FRIDAY:
-                        logmsg("Day")
+                        logmsgif("Day", symbol)
 
                     elif trade.days_end() and today == FRIDAY and closing:
                         for id in expert_ids:
-                            trade.close_positions(position_type='all', id=id, comment=comment)
-                        logmsg("Week")
+                            trade.close_positions(
+                                position_type='all', id=id, comment=comment)
+                        logmsgif("Week", symbol)
                         trade.statistics(save=True)
+                strategy.perform_period_end_checks()
                 if day_end and today != FRIDAY:
                     sleep_time = trades_instances[symbols[-1]].sleep_time()
                     sleepmsg(sleep_time)
@@ -345,7 +405,8 @@ def _mt5_execution(
                     if period_end_action == 'break' and closing:
                         break
                     elif period_end_action == 'sleep' or not closing:
-                        sleep_time = trades_instances[symbols[-1]].sleep_time(weekend=True)
+                        sleep_time = trades_instances[symbols[-1]
+                                                      ].sleep_time(weekend=True)
                         sleepmsg(sleep_time)
                         time.sleep(60 * sleep_time)
                         logger.info(sessionmsg)
@@ -354,18 +415,20 @@ def _mt5_execution(
                 for symbol in symbols:
                     trade = trades_instances[symbol]
                     if trade.days_end() and today != FRIDAY:
-                        logmsg("Day")
+                        logmsgif("Day", symbol)
                     elif trade.days_end() and today == FRIDAY:
-                        logmsg("Week")
+                        logmsgif("Week", symbol)
                     elif (
                         trade.days_end()
                         and today == FRIDAY
                         and num_days/len(symbols) >= 20
                     ) and closing:
                         for id in expert_ids:
-                            trade.close_positions(position_type='all', id=id, comment=comment)
-                        logmsg("Month")
+                            trade.close_positions(
+                                position_type='all', id=id, comment=comment)
+                        logmsgif("Month", symbol)
                         trade.statistics(save=True)
+                strategy.perform_period_end_checks()
                 if day_end and today != FRIDAY:
                     sleep_time = trades_instances[symbols[-1]].sleep_time()
                     sleepmsg(sleep_time)
@@ -374,7 +437,7 @@ def _mt5_execution(
                     num_days += 1
                 elif day_end and today == FRIDAY:
                     sleep_time = trades_instances[symbols[-1]
-                                                ].sleep_time(weekend=True)
+                                                  ].sleep_time(weekend=True)
                     sleepmsg(sleep_time)
                     time.sleep(60 * sleep_time)
                     logger.info(sessionmsg)
@@ -382,10 +445,12 @@ def _mt5_execution(
                 elif (day_end
                         and today == FRIDAY
                         and num_days/len(symbols) >= 20
-                    ):
+                      ):
                     break
-        except Exception as e:
-            logger.error(f"Handling period end actions, {e}, STRATEGY={STRATEGY}")
+        except Exception:
+            logger.error(
+                f"Handling period end actions, STRATEGY={STRATEGY}")
+            traceback.print_exc()
             continue
 
 
@@ -411,7 +476,7 @@ class MT5ExecutionEngine():
 
     Examples
     --------
-    
+
     >>> from bbstrader.metatrader import create_trade_instance
     >>> from bbstrader.trading.execution import MT5ExecutionEngine
     >>> from bbstrader.trading.strategies import StockIndexCFDTrading
@@ -487,7 +552,7 @@ class MT5ExecutionEngine():
                  trading_days:       Optional[List[str]] = TradingDays,
                  comment:            Optional[str] = None,
                  **kwargs
-        ):
+                 ):
         """
         Args:
             symbol_list : List of symbols to trade
@@ -518,7 +583,7 @@ class MT5ExecutionEngine():
             1. For `trail` , `stop_trail` , `trail_after_points` , `be_plus_points` see `bbstrader.metatrader.trade.Trade.break_even()` .
             2. All Strategies must inherit from `bbstrader.btengine.strategy.Strategy` or `bbstrader.btengine.strategy.MT5Strategy` class
             and have a `calculate_signals` method that returns a dictionary of signals for each symbol in symbol_list.
-            
+
             3. All strategies must have the following arguments in their `__init__` method:
                 - bars (DataHandler): DataHandler instance default to None
                 - events (Queue): Queue instance default to None
@@ -528,7 +593,7 @@ class MT5ExecutionEngine():
                     The keyword arguments are all the additional arguments passed to the `MT5ExecutionEngine` class,
                     the `Strategy` class, the `DataHandler` class, the `Portfolio` class and the `ExecutionHandler` class.
                 - The `bars` and `events` arguments are used for backtesting only.
-            
+
             4. All strategies must generate signals for backtesting and live trading.
             See the `bbstrader.trading.strategies` module for more information on how to create custom strategies.
             See `bbstrader.metatrader.account.check_mt5_connection()` for more details on how to connect to MT5 terminal.
@@ -556,7 +621,7 @@ class MT5ExecutionEngine():
         trades = self.trades_instances.keys()
         s = self.strategy_cls.__name__
         return f"MT5ExecutionEngine(Symbols={list(trades)}, Strategy={s})"
-    
+
     def run(self):
         check_mt5_connection(**self.kwargs)
         _mt5_execution(
@@ -581,4 +646,5 @@ class MT5ExecutionEngine():
         )
 
 
-class TWSExecutionEngine():...
+class TWSExecutionEngine():
+    ...

bbstrader/trading/scripts.py

@@ -1,10 +1,12 @@
 import asyncio
-from telegram import Bot
+
 from notifypy import Notify
+from telegram import Bot
 from telegram.error import TelegramError
 
 __all__ = ['send_telegram_message', 'send_notification', 'send_message']
 
+
 async def send_telegram_message(token, chat_id, text=''):
     """
     Send a message to a telegram chat
@@ -23,6 +25,7 @@ async def send_telegram_message(token, chat_id, text=''):
     except TelegramError as e:
         print(f"Error sending message: {e}")
 
+
 def send_notification(title, message=''):
     """
     Send a desktop notification
@@ -35,9 +38,10 @@ def send_notification(title, message=''):
     notification.title = title
     notification.message = message
     notification.send()
-    
-def send_message(title='SIGNAL', message='New signal', 
-                notify_me=False, telegram=False, token=None, chat_id=None):
+
+
+def send_message(title='SIGNAL', message='New signal',
+                 notify_me=False, telegram=False, token=None, chat_id=None):
     """
     Send a message to the user