bbstrader 0.1.5__py3-none-any.whl → 0.1.7__py3-none-any.whl

bbstrader/trading/execution.py

@@ -1,965 +1,386 @@
+from math import log
 import time
-import pandas as pd
-import numpy as np
 from datetime import datetime
-from bbstrader.metatrader.rates import Rates
 from bbstrader.metatrader.trade import Trade
-from bbstrader.trading.utils import tf_mapping
-from bbstrader.strategies import (
-    ArimaGarchStrategy, SMAStrategy, KLFStrategy, OrnsteinUhlenbeck,
-)
-from bbstrader.models.risk import HMMRiskManager
-from bbstrader.metatrader.utils import config_logger
-from typing import Optional, Literal, List, Tuple
-
-logger = config_logger(log_file='trade.log', console_log=False)
-
-TRADING_DAYS = ['Monday', 'Tuesday', 'Wednesday', 'Thursday', 'Friday']
-# ========  SMA TRADING ======================
-def sma_trading(
-    trade: Trade,
-    tf: Optional[str] = '1h',
-    sma: Optional[int] = 35,
-    lma: Optional[int] = 80,
-    mm: Optional[bool] = True,
-    max_t: Optional[int] = 1,
-    iter_time: Optional[int |float] = 30,
-    risk_manager: str = 'hmm',
-    period: Literal['day', 'week', 'month'] = 'week',
-    **kwargs
+from bbstrader.trading.strategies import Strategy
+from typing import Optional, Literal, List, Tuple, Dict
+import MetaTrader5 as mt5
+from bbstrader.metatrader.account import INIT_MSG
+from bbstrader.metatrader.utils import raise_mt5_error
+
+
+_TF_MAPPING = {
+    '1m':  1,
+    '3m':  3,
+    '5m':  5,
+    '10m': 10,
+    '15m': 15,
+    '30m': 30,
+    '1h':  60,
+    '2h':  120,
+    '4h':  240,
+    'D1':  1440
+}
+
+TRADING_DAYS = [
+    'monday', 
+    'tuesday', 
+    'wednesday', 
+    'thursday', 
+    'friday'
+]
+
+def _check_mt5_connection():
+    if not mt5.initialize():
+        raise_mt5_error(INIT_MSG)
+
+def _mt5_execution(
+    symbol_list, trades_instances, strategy_cls, /,
+        mm, time_frame, iter_time, period, trading_days,
+        comment, **kwargs
 ):
-    """
-    Executes a Simple Moving Average (SMA) trading strategy 
-    with optional risk management using Hidden Markov Models (HMM).
-
-    Parameters
-    ==========
-    trade : Trade
-        The Trade object that encapsulates trading operations like 
-        opening, closing positions, etc.
-    tf : str, optional
-        Time frame for the trading strategy, defaults to '1h' (1 hour).
-    sma : int, optional
-        Short Moving Average period, defaults to 35.
-    lma : int, optional
-        Long Moving Average period, defaults to 80.
-    mm : bool, optional
-        Money management flag to enable/disable money management, defaults to True.
-    max_t : int, optional
-        Maximum number of trades allowed, defaults to 1.
-    iter_time : Union[int, float], optional
-        Iteration time for the trading loop, defaults to 30 seconds.
-    risk_manager : str
-        Specifies the risk management strategy to use, 
-        'hmm' for Hidden Markov Model.
-    period : Literal['day', 'week', 'month'], optional
-        Trading period to reset statistics and close positions, 
-        can be 'day', 'week', or 'month', defaults to 'week'.
-    **kwargs
-        Additional keyword arguments for the HMM risk manager.
-
-    Returns
-    =======
-    None
-
-    Notes
-    =====
-    This function integrates a trading strategy based on simple moving averages 
-    with an optional risk management layer using HMM.
-    It periodically checks for trading signals and executes buy or sell orders 
-    based on the strategy signals and risk management conditions.
-    The trading period (day, week, month) determines when to reset statistics 
-    and close all positions.
-
-    This function includes an infinite loop with time delays designed 
-    to run continuously during market hours. Ensure proper exception handling 
-    and resource management when integrating into a live trading environment.
-    """
-
-    def check(buys: list, sells: list):
-        if buys is not None or sells is not None:
-            logger.info(f"Checking for Break even SYMBOL={trade.symbol}...")
-            trade.break_even()
+    symbols = symbol_list.copy()
+    STRATEGY = kwargs.get('strategy_name')
+    _max_trades = kwargs.get('max_trades')
+    logger = kwargs.get('logger')
+    max_trades = {symbol: _max_trades[symbol] for symbol in symbols}
+    if comment is None:
+        trade = trades_instances[symbols[0]]
+        comment = f"{trade.expert_name}@{trade.version}"
+
+    def check(buys: List, sells: List, symbol: str):
+        if not mm:
+            return
+        if buys is not None:
+            logger.info(
+                f"Checking for Break even, SYMBOL={symbol}...STRATEGY={STRATEGY}")
+            trades_instances[symbol].break_even(mm=mm)
+        if sells is not None:
+            logger.info(
+                f"Checking for Break even, SYMBOL={symbol}...STRATEGY={STRATEGY}")
+            trades_instances[symbol].break_even(mm=mm)
+    num_days = 0
+    time_intervals = 0
+    trade_time = _TF_MAPPING[time_frame]
 
-    time_frame_mapping = tf_mapping()
-    if tf == 'D1':
-        trade_time = trade.get_minutes()
-    else:
-        trade_time = time_frame_mapping[tf]
+    long_market = {symbol: False for symbol in symbols}
+    short_market = {symbol: False for symbol in symbols}
 
-    rate = Rates(trade.symbol, tf, 0)
-    data = rate.get_rates_from_pos()
-    strategy = SMAStrategy(short_window=sma, long_window=lma)
-    hmm = HMMRiskManager(data=data, verbose=True,
-                         iterations=1000, **kwargs)
-    time_intervals = 0
-    long_market = False
-    short_market = False
-    num_days = 0
     logger.info(
-        f'Running SMA Strategy on {trade.symbol} in {tf} Interval ...\n')
+        f'Running {STRATEGY} Strategy on {symbols} in {time_frame} Interval ...')
+    strategy: Strategy = strategy_cls(
+        symbol_list=symbols, mode='live', **kwargs)
+
     while True:
-        current_date = datetime.now()
-        today = current_date.strftime("%A")
         try:
-            buys = trade.get_current_buys()
-            if buys is not None:
-                logger.info(
-                    f"Current buy positions SYMBOL={trade.symbol}: {buys}, STRATEGY=SMA")
-            sells = trade.get_current_sells()
-            if sells is not None:
-                logger.info(
-                    f"Current sell positions SYMBOL={trade.symbol}: {sells}, STRATEGY=SMA")
-            long_market = buys is not None and len(buys) >= max_t
-            short_market = sells is not None and len(sells) >= max_t
-
+            _check_mt5_connection()
+            current_date = datetime.now()
+            today = current_date.strftime("%A").lower()
             time.sleep(0.5)
-            sig_rate = Rates(trade.symbol, tf, 0, lma)
-            hmm_data = sig_rate.get_returns.values
-            current_regime = hmm.which_trade_allowed(hmm_data)
-            logger.info(f'CURRENT REGIME = {current_regime}, SYMBOL={trade.symbol}, STRATEGY=SMA')
-            ma_data = sig_rate.get_close.values
-            signal = strategy.calculate_signals(ma_data)
-            logger.info(f"Calculating signal...SYMBOL={trade.symbol}, STRATEGY=SMA")
-            comment = f"{trade.expert_name}@{trade.version}"
-            if trade.trading_time() and today in TRADING_DAYS:
-                if signal is not None:
-                    logger.info(f"SIGNAL = {signal}, SYMBOL={trade.symbol}, STRATEGY=SMA")
-                    if signal == "EXIT" and short_market:
-                        trade.close_positions(position_type='sell')
-                        short_market = False
-                    elif signal == "EXIT" and long_market:
-                        trade.close_positions(position_type='buy')
-                        long_market = False
-
-                    if current_regime == 'LONG':
-                        if signal == "LONG" and not long_market:
-                            if time_intervals % trade_time == 0 or buys is None:
-                                logger.info(f"Sending buy Order .... SYMBOL={trade.symbol}, STRATEGY=SMA")
+            buys = {
+                symbol: trades_instances[symbol].get_current_buys()
+                for symbol in symbols
+            }
+            sells = {
+                symbol: trades_instances[symbol].get_current_sells()
+                for symbol in symbols
+            }
+            for symbol in symbols:
+                if buys[symbol] is not None:
+                    logger.info(
+                        f"Current buy positions SYMBOL={symbol}: {buys[symbol]}, STRATEGY={STRATEGY}")
+                if sells[symbol] is not None:
+                    logger.info(
+                        f"Current sell positions SYMBOL={symbol}: {sells[symbol]}, 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 as e:
+            logger.error(f"{e}, STRATEGY={STRATEGY}")
+        time.sleep(0.5)
+        for symbol in symbols:
+            try:
+                trade = trades_instances[symbol]
+                logger.info(
+                    f"Calculating signal... SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
+                signal = strategy.calculate_signals()[symbol]
+                if trade.trading_time() and today in trading_days:
+                    if signal is not None:
+                        logger.info(
+                            f"SIGNAL = {signal}, SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
+                        if signal in ("EXIT", "EXIT_LONG") and long_market[symbol]:
+                            trade.close_positions(position_type='buy')
+                        elif signal in ("EXIT", "EXIT_SHORT") and short_market[symbol]:
+                            trade.close_positions(position_type='sell')
+                        elif signal == "LONG" and not long_market[symbol]:
+                            if time_intervals % trade_time == 0 or buys[symbol] is None:
+                                logger.info(
+                                    f"Sending buy Order ... SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
                                 trade.open_buy_position(mm=mm, comment=comment)
                             else:
-                                check(buys, sells)
-                        elif signal == "LONG" and long_market:
-                            logger.info(f"Sorry Risk not allowed !!! SYMBOL={trade.symbol}, STRATEGY=SMA")
-                            check(buys, sells)
-
-                    elif current_regime == 'SHORT':
-                        if signal == "SHORT" and not short_market:
-                            if time_intervals % trade_time == 0 or sells is None:
-                                logger.info(f"Sending Sell Order .... SYMBOL={trade.symbol}, STRATEGY=SMA")
+                                check(buys[symbol], sells[symbol], symbol)
+                        elif signal == "LONG" and long_market[symbol]:
+                            logger.info(
+                                f"Sorry Risk not allowed !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
+                            check(buys[symbol], sells[symbol], symbol)
+
+                        elif signal == "SHORT" and not short_market[symbol]:
+                            if time_intervals % trade_time == 0 or sells[symbol] is None:
+                                logger.info(
+                                    f"Sending sell Order ... SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
                                 trade.open_sell_position(
                                     mm=mm, comment=comment)
                             else:
-                                check(buys, sells)
-                        elif signal == "SHORT" and short_market:
-                            logger.info(f"Sorry Risk not Allowed !!! SYMBOL={trade.symbol}, STRATEGY=SMA")
-                            check(buys, sells)
-                else:
-                    logger.info(f"There is no signal !! SYMBOL={trade.symbol}, STRATEGY=SMA")
-                    check(buys, sells)
-            else:
-                logger.info(f"Sorry It is Not trading Time !!! SYMBOL={trade.symbol}, STRATEGY=SMA")
-                check(buys, sells)
-        except Exception as e:
-            logger.error(f"{e}, SYMBOL={trade.symbol}, STRATEGY=SMA")
-        time.sleep((60 * iter_time) - 1.5)
-        if iter_time == 1:
-            time_intervals += 1
-        elif iter_time == trade_time:
-            time_intervals += trade_time
-        else:
-            time_intervals += (trade_time/iter_time)
-        if period.lower() == 'month':
-            if trade.days_end() and today != 'Friday':
-                sleep_time = trade.sleep_time()
-                logger.info(f"End of the Day !!! SYMBOL={trade.symbol}, STRATEGY=SMA")
-                time.sleep(60 * sleep_time)
-                num_days += 1
-
-            elif trade.days_end() and today == 'Friday':
-                logger.info(f"End of the Week !!! SYMBOL={trade.symbol}, STRATEGY=SMA")
-                sleep_time = trade.sleep_time(weekend=True)
-                time.sleep(60 * sleep_time)
-                num_days += 1
-
-            elif (
-                trade.days_end()
-                and today == 'Friday'
-                and num_days >= 20
-            ):
-                trade.close_positions(position_type='all', comment=comment)
-                logger.info(f"End of the Month !!! SYMBOL={trade.symbol}, STRATEGY=SMA")
-                trade.statistics(save=True)
-                break
-
-        elif period.lower() == 'week':
-            if trade.days_end() and today != 'Friday':
-                sleep_time = trade.sleep_time()
-                time.sleep(60 * sleep_time)
-
-            elif trade.days_end() and today == 'Friday':
-                trade.close_positions(position_type='all', comment=comment)
-                logger.info(f"End of the Week !!! SYMBOL={trade.symbol}, STRATEGY=SMA")
-                trade.statistics(save=True)
-                break
-
-        elif period.lower() == 'day':
-            if trade.days_end():
-                trade.close_positions(position_type='all', comment=comment)
-                logger.info(f"End of the Day !!! SYMBOL={trade.symbol}, STRATEGY=SMA")
-                trade.statistics(save=True)
-                break
-
-
-# ========= PAIR TRADING =====================
-def pair_trading(
-    pair: List[str] | Tuple[str],
-    p0: Trade,
-    p1: Trade,
-    tf: str,
-    /,
-    max_t: Optional[int] = 1,
-    mm: Optional[bool] = True,
-    iter_time: Optional[int | float] = 30,
-    risk_manager: Optional[str] = None,
-    rm_ticker: Optional[str] = None,
-    rm_window: Optional[int] = None,
-    period: Literal['day', 'week', 'month'] = 'month',
-    **kwargs
-):
-    """
-    Implements a pair trading strategy with optional risk management 
-    using Hidden Markov Models (HMM). This strategy trades pairs of assets 
-    based on their historical price relationship, seeking to capitalize on converging prices.
-
-    :param pair (list[str] | tuple[str]): The trading pair represented as a list or tuple of symbols (e.g., ['AAPL', 'GOOG']).
-    :param p0 (Trade): Trade object for the first asset in the pair.
-    :param p1 (Trade): Trade object for the second asset in the pair.
-    :param tf (str): Time frame for the trading strategy (e.g., '1h' for 1 hour).
-    :param max_t (int, optional): Maximum number of trades allowed at any time for each asset in the pair, defaults to 1.
-    
-    :param mm (bool, optional): Money management flag to enable/disable money management, defaults to True.
-    :param iter_time (int | float ,optional): Iteration time (in minutes) for the trading loop, defaults to 30.
-    :param risk_manager: Specifies the risk management model to use default is None , Hidden Markov Model ('hmm) Can be use.
-    :param rm_window: Window size for the risk model use for the prediction, defaults to None. Must be specified if `risk_manager` is not None.
-    
-    :param period (str, optional): Trading period to reset statistics and close positions, can be 'day', 'week', or 'month'. 
-    :param kwargs: Additional keyword arguments for HMM risk manager.
-
-    This function continuously evaluates the defined pair for trading opportunities 
-    based on the strategy logic, taking into account the specified risk management 
-    approach if applicable. It aims to profit from the mean reversion behavior typically
-    observed in closely related financial instruments.
-
-    Note: 
-    This function includes an infinite loop with time delays designed to run continuously during market hours.
-    Proper exception handling and resource management are crucial for live trading environments.
-    """
-    regime = False
-    if risk_manager is not None:
-        assert rm_ticker is not None
-        assert rm_window is not None
-        regime = True
-
-    def p0_check(p0_positions):
-        if p0_positions is not None:
-            logger.info(f"Checking for breakeven on {pair[0]} positions...STRATEGY=KLF")
-            p0.break_even()
-
-    def p1_check(p1_positions):
-        if p1_positions is not None:
-            logger.info(f"Checking for breakeven on {pair[1]} positions...STRATEGY=KLF")
-            p1.break_even()
-
-    time_frame_mapping = tf_mapping()
-    if tf == 'D1':
-        trade_time = p0.get_minutes()
-    else:
-        trade_time = time_frame_mapping[tf]
-
-    if regime:
-        if risk_manager == 'hmm':
-            rate = Rates(rm_ticker, tf, 0)
-            data = rate.get_rates_from_pos()
-            hmm = HMMRiskManager(data=data, verbose=True, iterations=5000, **kwargs)
-
-    time_intervals = 0
-    long_market = False
-    short_market = False
-    num_days = 0
-    logger.info(
-        f'Running KLF Strategy on {pair[0]} and {pair[1]} in {tf} Interval ...\n')
-    while True:
-        current_date = datetime.now()
-        today = current_date.strftime("%A")
-        try:
-            # Data Retrieval
-            p0_ = Rates(pair[0], tf, 0, 10)
-            p1_ = Rates(pair[1], tf, 0, 10)
-
-            p0_data = p0_.get_close
-            p1_data = p1_.get_close
-            prices = np.array(
-                [p0_data.values[-1], p1_data.values[-1]]
-            )
-            strategy = KLFStrategy(pair)
-            if regime:
-                if risk_manager == 'hmm':
-                    hmm_data = Rates(rm_ticker, tf, 0, rm_window)
-                    returns = hmm_data.get_returns.values
-                    current_regime = hmm.which_trade_allowed(returns)
-                    logger.info(f'CURRENT REGIME ={current_regime}, STRATEGY=KLF')
-            else:
-                current_regime = None
-
-            p0_positions = p0.get_current_open_positions()
-            time.sleep(0.5)
-            p1_positions = p1.get_current_open_positions()
-            time.sleep(0.5)
-            p1_buys = p1.get_current_buys()
-            p0_buys = p0.get_current_buys()
-            time.sleep(0.5)
-            if p1_buys is not None:
-                logger.info(f"Current buy positions on {pair[1]}: {p1_buys}, STRATEGY=KLF")
-            if p0_buys is not None:
-                logger.info(f"Current buy positions on {pair[0]}: {p0_buys}, STRATEGY=KLF")
-            time.sleep(0.5)
-            p1_sells = p1.get_current_sells()
-            p0_sells = p0.get_current_sells()
-            time.sleep(0.5)
-            if p1_sells is not None:
-                logger.info(f"Current sell positions on {pair[1]}: {p1_sells}, STRATEGY=KLF")
-            if p0_sells is not None:
-                logger.info(f"Current sell positions on {pair[0]}: {p0_sells}, STRATEGY=KLF")
-
-            p1_long_market = p1_buys is not None and len(p1_buys) >= max_t
-            p0_long_market = p0_buys is not None and len(p0_buys) >= max_t
-            p1_short_market = p1_sells is not None and len(p1_sells) >= max_t
-            p0_short_market = p0_sells is not None and len(p0_sells) >= max_t
-
-            logger.info(f"Calculating Signals SYMBOL={pair}...STRATEGY=KLF")
-            signals = strategy.calculate_signals(prices)
-            comment = f"{p0.expert_name}@{p0.version}"
-
-            if signals is not None:
-                logger.info(f'SIGNALS = {signals}, STRATEGY=KLF')
-                if p0.trading_time() and today in TRADING_DAYS:
-                    p1_signal = signals[pair[1]]
-                    p0_signal = signals[pair[0]]
-                    if p1_signal == "EXIT" and p0_signal == "EXIT":
-                        if p1_positions is not None:
-                            logger.info(f"Exiting Positions On [{pair[1]}], STRATEGY=KLF")
-                            p1.close_positions(position_type='all', comment=comment)
-                            p1_long_market = False
-                            p1_short_market = False
-                        if p0_positions is not None:
-                            logger.info(f"Exiting Positions On [{pair[0]}], STRATEGY=KLF")
-                            p0.close_positions(position_type='all', comment=comment)
-                            p1_long_market = False
-                            p1_short_market = False
-                    if current_regime is not None:
-                        if (
-                            p1_signal == "LONG"
-                            and p0_signal == "SHORT"
-                            and current_regime == 'LONG'
-                        ):
-                            if not p1_long_market:
-                                if time_intervals % trade_time == 0 or p1_buys is None:
-                                    logger.info(f"Going LONG on [{pair[1]}], STRATEGY=KLF")
-                                    p1.open_buy_position(
-                                        mm=mm, comment=comment)
-                                else:
-                                    p1_check(p1_positions)
-                            else:
-                                logger.info(f"Sorry Risk Not allowed on [{pair[1]}], STRATEGY=KLF")
-                                p1_check(p1_positions)
-
-                            if not p0_short_market:
-                                if time_intervals % trade_time == 0 or p0_sells is None:
-                                    logger.info(f"Going SHORT on [{pair[0]}]")
-                                    p0.open_sell_position(
-                                        mm=mm, comment=comment)
-                                else:
-                                    p0_check(p0_positions)
-                            else:
-                                logger.info(
-                                    f"Sorry Risk Not allowed on [{pair[0]}], STRATEGY=KLF")
-                                p0_check(p0_positions)
-                        elif (
-                            p1_signal == "SHORT"
-                            and p0_signal == "LONG"
-                            and current_regime == 'SHORT'
-                        ):
-                            if not p1_short_market:
-                                if time_intervals % trade_time == 0 or p1_sells is None:
-                                    logger.info(f"Going SHORT on [{pair[1]}], STRATEGY=KLF")
-                                    p1.open_sell_position(
-                                        mm=mm, comment=comment)
-                                else:
-                                    p1_check(p1_positions)
-                            else:
-                                logger.info(f"Sorry Risk Not allowed on [{pair[1]}], STRATEGY=KLF")
-                                p1_check(p1_positions)
-
-                            if not p0_long_market:
-                                if time_intervals % trade_time == 0 or p0_buys is None:
-                                    logger.info(f"Going LONG on [{pair[0]}], STRATEGY=KLF")
-                                    p0.open_buy_position(
-                                        mm=mm, comment=comment)
-                                else:
-                                    p0_check(p0_positions)
-                            else:
-                                logger.info(
-                                    f"Sorry Risk Not allowed on [{pair[0]}], STRATEGY=KLF")
-                                p0_check(p0_positions)
+                                check(buys[symbol], sells[symbol], symbol)
+                        elif signal == "SHORT" and short_market[symbol]:
+                            logger.info(
+                                f"Sorry Risk not allowed !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
+                            check(buys[symbol], sells[symbol], symbol)
                     else:
-                        if (
-                            p1_signal == "LONG"
-                            and p0_signal == "SHORT"
-                        ):
-                            if not p1_long_market:
-                                if time_intervals % trade_time == 0 or p1_buys is None:
-                                    logger.info(f"Going LONG on [{pair[1]}], STRATEGY=KLF")
-                                    p1.open_buy_position(
-                                        mm=mm, comment=comment)
-                                else:
-                                    p1_check(p1_positions)
-                            else:
-                                logger.info(f"Sorry Risk Not allowed on [{pair[1]}], STRATEGY=KLF")
-                                p1_check(p1_positions)
-
-                            if not p0_short_market:
-                                if time_intervals % trade_time == 0 or p0_sells is None:
-                                    logger.info(f"Going SHORT on [{pair[0]}], STRATEGY=KLF")
-                                    p0.open_sell_position(
-                                        mm=mm, comment=comment)
-                                else:
-                                    p0_check(p0_positions)
-                            else:
-                                logger.info(
-                                    f"Sorry Risk Not allowed on [{pair[0]}], STRATEGY=KLF")
-                                p0_check(p0_positions)
-                        elif (
-                            p1_signal == "SHORT"
-                            and p0_signal == "LONG"
-                        ):
-                            if not p1_short_market:
-                                if time_intervals % trade_time == 0 or p1_sells is None:
-                                    logger.info(f"Going SHORT on [{pair[1]}], STRATEGY=KLF")
-                                    p1.open_sell_position(
-                                        mm=mm, comment=comment)
-                                else:
-                                    p1_check(p1_positions)
-                            else:
-                                logger.info(f"Sorry Risk Not allowed on [{pair[1]}], STRATEGY=KLF")
-                                p1_check(p1_positions)
-
-                            if not p0_long_market:
-                                if time_intervals % trade_time == 0 or p0_buys is None:
-                                    logger.info(f"Going LONG on [{pair[0]}], STRATEGY=KLF")
-                                    p0.open_buy_position(
-                                        mm=mm, comment=comment)
-                                else:
-                                    p0_check(p0_positions)
-                            else:
-                                logger.info(
-                                    f"Sorry Risk Not allowed on [{pair[0]}], STRATEGY=KLF")
-                                p0_check(p0_positions)
+                        logger.info(
+                            f"There is no signal !! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
+                        check(buys[symbol], sells[symbol], symbol)
                 else:
                     logger.info(
-                        f"It is Not trading time !!! STRATEGY=KLF, SYMBOLS={pair}")
-                    p0_check(p0_positions)
-                    p1_check(p1_positions)
-            else:
-                logger.info(
-                    f"There is no signal !!! STRATEGY=KLF, SYMBOLS={pair}")
-                    
-                p0_check(p0_positions)
-                p1_check(p1_positions)
-
-        except Exception as e:
-            logger.error(f"{e}, STRATEGY=KLF, SYMBOLS={pair}")
+                        f"Sorry It is Not trading Time !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
+                    check(buys[symbol], sells[symbol], symbol)
 
-        time.sleep((60 * iter_time) - 2.5)
+            except Exception as e:
+                logger.error(f"{e}, SYMBOL={symbol}, STRATEGY={STRATEGY}")
 
+        time.sleep((60 * iter_time) - 1.0)
         if iter_time == 1:
             time_intervals += 1
-        elif iter_time == trade_time:
-            time_intervals += trade_time
+        elif trade_time % iter_time == 0:
+            time_intervals += iter_time
         else:
-            time_intervals += (trade_time/iter_time)
-
-        if period.lower() == 'month':
-            if p0.days_end() and today != 'Friday':
-                logger.info(
-                    f"End of the Day !!! STRATEGY=KLF, SYMBOLS={pair}")
-                    
-                sleep_time = p0.sleep_time()
-                time.sleep(60 * sleep_time)
-                num_days += 1
-
-            elif p0.days_end() and today == 'Friday':
-                logger.info(
-                    f"End of the Week !!! STRATEGY=KLF, SYMBOLS={pair}")
-                sleep_time = p0.sleep_time(weekend=True)
-                time.sleep(60 * sleep_time)
-                num_days += 1
-
-            elif (
-                    p0.days_end()
-                and today == 'Friday'
-                and num_days >= 20
-            ):
-                p0.close_positions(position_type='all', comment=comment)
-                p1.close_positions(position_type='all', comment=comment)
-                logger.info(
-                    f"End of the Month !!! STRATEGY=KLF, SYMBOLS={pair}")                    
-                p0.statistics(save=True)
-                p1.statistics(save=True)
+            raise ValueError(
+                f"iter_time must be a multiple of the {time_frame} !!!"
+                f"(e.g; if time_frame is 15m, iter_time must be 1.5, 3, 3, 15 etc)"
+            )
+        print()
+        if period.lower() == 'day':
+            for symbol in symbols:
+                trade = trades_instances[symbol]
+                if trade.days_end():
+                    trade.close_positions(position_type='all', comment=comment)
+                    logger.info(
+                        f"End of the Day !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
+                    trade.statistics(save=True)
+            if trades_instances[symbols[-1]].days_end():
                 break
 
         elif period.lower() == 'week':
-            if p0.days_end() and today != 'Friday':
-                sleep_time = p0.sleep_time()
-                time.sleep(60 * sleep_time)
-
-            elif p0.days_end() and today == 'Friday':
-                p0.close_positions(position_type='all', comment=comment)
-                p1.close_positions(position_type='all', comment=comment)
-                logger.info(
-                    f"End of the Week !!! STRATEGY=KLF, SYMBOLS={pair}")
-                p0.statistics(save=True)
-                p1.statistics(save=True)
-                break
+            for symbol in symbols:
+                trade = trades_instances[symbol]
+                if trade.days_end() and today != 'friday':
+                    logger.info(
+                        f"End of the Day !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
 
-        elif period.lower() == 'day':
-            if p0.days_end():
-                p0.close_positions(position_type='all', comment=comment)
-                p1.close_positions(position_type='all', comment=comment)
-                logger.info(
-                    f"End of the Day !!! STRATEGY=KLF, SYMBOLS={pair}")                   
-                p0.statistics(save=True)
-                p1.statistics(save=True)
+                elif trade.days_end() and today == 'friday':
+                    trade.close_positions(position_type='all', comment=comment)
+                    logger.info(
+                        f"End of the Week !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
+                    trade.statistics(save=True)
+            if trades_instances[symbols[-1]].days_end() and today != 'friday':
+                sleep_time = trades_instances[symbols[-1]].sleep_time()
+                logger.info(f"Sleeping for {sleep_time} minutes ...")
+                time.sleep(60 * sleep_time)
+                logger.info("\nSTARTING NEW TRADING SESSION ...")
+            elif trades_instances[symbols[-1]].days_end() and today == 'friday':
                 break
 
-
-# ========= ORNSTEIN UHLENBECK TRADING ========
-def ou_trading(
-    trade: Trade,
-    tf: Optional[str] = '1h',
-    p: Optional[int] = 20,
-    n: Optional[int] = 20,
-    ou_window: Optional[int] = 2000,
-    max_t: Optional[int] = 1,
-    mm: Optional[bool] = True,
-    iter_time: Optional[int | float] = 30,
-    risk_manager: Optional[str] = None,
-    rm_window: Optional[int] = None,
-    period: Literal['day', 'week', 'month'] = 'month',
-    **kwargs
-):
-    """
-    Executes the Ornstein-Uhlenbeck (OU) trading strategy, 
-    incorporating various risk management and trading frequency adjustments.
-
-    :param trade: A `Trade` instance, containing methods and attributes for executing trades.
-    :param tf: Time frame for the trading strategy, default is '1h'.
-    :param mm: Boolean indicating if money management is enabled, default is True.
-    :param max_t: Maximum number of trades allowed at any given time, default is 1.
-    :param p: Period length for calculating returns, default is 20.
-    :param n: Window size for the Ornstein-Uhlenbeck strategy calculation, default is 20.
-    :param iter_time: Iteration time for the trading loop, can be an integer or float. 
-    :param ou_window: Lookback period for the OU strategy, defaults to 2000.
-    :param risk_manager: Specifies the risk management model to use
-        default is None , Hidden Markov Model ('hmm) Can be use.
-    :param rm_window: Window size for the risk model use for the prediction, defaults to None. 
-        Must be specified if `risk_manager` is not None.
-    :param period: Defines the trading period as 'month', 'week', or 'day'
-        affecting how and when positions are closed.
-    :param kwargs: Additional keyword arguments for risk management models or other customizations.
-
-    This function manages trading based on the OU strategy, adjusting for risk and time-based criteria. 
-    It includes handling of trading sessions, buy/sell signal generation, risk management through the HMM model, and period-based
-    trading evaluation.
-    """
-    regime = False
-    if risk_manager is not None:
-        if risk_manager.lower() == 'hmm':
-            assert rm_window is not None
-            regime = True
-
-    rate = Rates(trade.symbol, tf, 0)
-    data = rate.get_rates_from_pos()
-    def check(buys: list, sells: list):
-        if buys is not None or sells is not None:
-            logger.info(f"Checking for Break even on {trade.symbol}... STRATEGY=OU")
-            trade.break_even()
-
-    time_frame_mapping = tf_mapping()
-    if tf == 'D1':
-        trade_time = trade.get_minutes()
-    else:
-        trade_time = time_frame_mapping[tf]
-
-    if regime:
-        if risk_manager == 'hmm':
-            hmm = HMMRiskManager(data=data, verbose=True, **kwargs)
-    strategy = OrnsteinUhlenbeck(data['Close'].values[-ou_window:], timeframe=tf)
-
-    time_intervals = 0
-    long_market = False
-    short_market = False
-    num_days = 0
-    logger.info(f'Running OU Strategy on {trade.symbol} in {tf} Interval ...\n')
-    while True:
-        current_date = datetime.now()
-        today = current_date.strftime("%A")
-        try:
-            buys = trade.get_current_buys()
-            if buys is not None:
-                logger.info(f"Current buy positions on {trade.symbol}: {buys}, STRATEGY=OU")
-            sells = trade.get_current_sells()
-            if sells is not None:
-                logger.info(f"Current sell positions on {trade.symbol}: {sells}, STRATEGY=OU")
-            long_market = buys is not None and len(buys) >= max_t
-            short_market = sells is not None and len(sells) >= max_t
-
-            time.sleep(0.5)
-            if regime:
-                if risk_manager == 'hmm':
-                    hmm_returns = Rates(trade.symbol, tf, 0, rm_window)
-                    hmm_returns_val = hmm_returns.get_returns.values
-                    current_regime = hmm.which_trade_allowed(hmm_returns_val)
+        elif period.lower() == 'month':
+            for symbol in symbols:
+                trade = trades_instances[symbol]
+                if trade.days_end() and today != 'friday':
                     logger.info(
-                        f'CURRENT REGIME = {current_regime}, SYMBOL={trade.symbol}, STRATEGY=OU')
-            else:
-                current_regime = None
-            logger.info(f"Calculating signal... SYMBOL={trade.symbol}, STRATEGY=OU")
-            ou_returns = Rates(trade.symbol, tf, 0, p)
-            returns_val = ou_returns.get_returns.values
-            signal = strategy.calculate_signals(returns_val, p=p, n=n)
-            comment = f"{trade.expert_name}@{trade.version}"
-            if trade.trading_time() and today in TRADING_DAYS:
-                if signal is not None:
-                    logger.info(f"SIGNAL = {signal}, SYMBOL={trade.symbol}, STRATEGY=OU")
-                    if signal == "LONG" and short_market:
-                        trade.close_positions(position_type='sell')
-                        short_market = False
-                    elif signal == "SHORT" and long_market:
-                        trade.close_positions(position_type='buy')
-                        long_market = False
-                    if current_regime is not None:
-                        if current_regime == 'LONG':
-                            if signal == "LONG" and not long_market:
-                                if time_intervals % trade_time == 0 or buys is None:
-                                    logger.info(f"Sending buy Order .... SYMBOL={trade.symbol}, STRATEGY=OU")
-                                    trade.open_buy_position(
-                                        mm=mm, comment=comment)
-                                else:
-                                    check(buys, sells)
+                        f"End of the Day !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
 
-                            elif signal == "LONG" and long_market:
-                                logger.info(f"Sorry Risk not allowed !!! SYMBOL={trade.symbol}, STRATEGY=OU")
-                                check(buys, sells)
-
-                        elif current_regime == 'SHORT':
-                            if signal == "SHORT" and not short_market:
-                                if time_intervals % trade_time == 0 or sells is None:
-                                    logger.info(f"Sending Sell Order .... SYMBOL={trade.symbol}, STRATEGY=OU")
-                                    trade.open_sell_position(
-                                        mm=mm, comment=comment)
-                                else:
-                                    check(buys, sells)
-                            elif signal == "SHORT" and short_market:
-                                logger.info(f"Sorry Risk not Allowed !!! SYMBOL={trade.symbol}, STRATEGY=OU")
-                                check(buys, sells)
-                    else:
-                        if signal == "LONG" and not long_market:
-                            if time_intervals % trade_time == 0 or buys is None:
-                                logger.info(f"Sending buy Order .... SYMBOL={trade.symbol}, STRATEGY=OU")
-                                trade.open_buy_position(mm=mm, comment=comment)
-                            else:
-                                check(buys, sells)
-
-                        elif signal == "LONG" and long_market:
-                            logger.info(f"Sorry Risk not allowed !!! SYMBOL={trade.symbol}, STRATEGY=OU")
-                            check(buys, sells)
-
-                        if signal == "SHORT" and not short_market:
-                            if time_intervals % trade_time == 0 or sells is None:
-                                logger.info(f"Sending Sell Order .... SYMBOL={trade.symbol}, STRATEGY=OU")
-                                trade.open_sell_position(
-                                    mm=mm, comment=comment)
-                            else:
-                                check(buys, sells)
-                        elif signal == "SHORT" and short_market:
-                            logger.info(f"Sorry Risk not Allowed !!! SYMBOL={trade.symbol}, STRATEGY=OU")
-                            check(buys, sells)
-                else:
-                    logger.info(f"There is no signal !!! SYMBOL={trade.symbol}, STRATEGY=OU")
-                    check(buys, sells)
-            else:
-                logger.info(f"Sorry It is Not trading Time !!! SYMBOL={trade.symbol}, STRATEGY=OU")
-                check(buys, sells)
-        except Exception as e:
-            print(f"{e}, SYMBOL={trade.symbol}, STRATEGY=OU")
-        time.sleep((60 * iter_time) - 1.5)
-        if iter_time == 1:
-            time_intervals += 1
-        elif iter_time == trade_time:
-            time_intervals += trade_time
-        else:
-            time_intervals += (trade_time/iter_time)
-
-        if period.lower() == 'month':
-            if trade.days_end() and today != 'Friday':
-                logger.info(f"End of the Day !!! SYMBOL={trade.symbol}, STRATEGY=OU")
-                sleep_time = trade.sleep_time()
+                elif trade.days_end() and today == 'friday':
+                    logger.info(
+                        f"End of the Week !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
+                elif (
+                    trade.days_end()
+                    and today == 'friday'
+                    and num_days/len(symbols) >= 20
+                ):
+                    trade.close_positions(position_type='all', comment=comment)
+                    logger.info(
+                        f"End of the Month !!! SYMBOL={trade.symbol}, STRATEGY={STRATEGY}")
+                    trade.statistics(save=True)
+            if trades_instances[symbols[-1]].days_end() and today != 'friday':
+                sleep_time = trades_instances[symbols[-1]].sleep_time()
+                logger.info(f"Sleeping for {sleep_time} minutes ...")
                 time.sleep(60 * sleep_time)
+                logger.info("\nSTARTING NEW TRADING SESSION ...")
                 num_days += 1
-
-            elif trade.days_end() and today == 'Friday':
-                logger.info(f"End of the Week !!! SYMBOL={trade.symbol}, STRATEGY=OU")
-                sleep_time = trade.sleep_time(weekend=True)
+            elif trades_instances[symbols[-1]].days_end() and today == 'friday':
+                sleep_time = trades_instances[symbols[-1]
+                                              ].sleep_time(weekend=True)
+                logger.info(f"Sleeping for {sleep_time} minutes ...")
                 time.sleep(60 * sleep_time)
+                logger.info("\nSTARTING NEW TRADING SESSION ...")
                 num_days += 1
-
-            elif (
-                    trade.days_end()
-                and today == 'Friday'
-                and num_days >= 20
-            ):
-                trade.close_positions(position_type='all', comment=comment)
-                logger.info(f"End of the Month !!! SYMBOL={trade.symbol}, STRATEGY=OU")
-                trade.statistics(save=True)
+            elif (trades_instances[symbols[-1]].days_end()
+                  and today == 'friday'
+                  and num_days/len(symbols) >= 20
+                  ):
                 break
 
-        elif period.lower() == 'week':
-            if trade.days_end() and today != 'Friday':
-                sleep_time = trade.sleep_time()
-                time.sleep(60 * sleep_time)
-
-            elif trade.days_end() and today == 'Friday':
-                trade.close_positions(position_type='all', comment=comment)
-                logger.info(f"End of the Week !!! SYMBOL={trade.symbol}, STRATEGY=OU")
-                trade.statistics(save=True)
-                break
 
-        elif period.lower() == 'day':
-            if trade.days_end():
-                trade.close_positions(position_type='all', comment=comment)
-                logger.info(f"End of the Day !!! SYMBOL={trade.symbol}, STRATEGY=OU")
-                trade.statistics(save=True)
-                break
+def _tws_execution(*args, **kwargs):
+    raise NotImplementedError("TWS Execution is not yet implemented !!!")
 
-
-# ========= ARIMA + GARCH TRADING =======================
-def arch_trading(
-    trade: Trade,
-    tf: str = 'D1',
-    k: int = 500, 
-    max_t: Optional[int] = 1,
-    mm: Optional[bool] = True,
-    iter_time: Optional[int | float] = 30,
-    risk_manager: Optional[str] = None,
-    rm_window: Optional[int] = None,
-    period: Literal['day', 'week', 'month'] = 'month',
-    **kwargs
-):
+_TERMINALS = {
+    'MT5': _mt5_execution,
+    'TWS': _tws_execution
+}
+class ExecutionEngine():
     """
-    Executes trading based on the ARCH (Autoregressive Conditional Heteroskedasticity) model, with 
-    the capability to incorporate a risk management strategy, specifically a Hidden Markov Model (HMM), 
-    to adjust trading decisions based on the market regime.
-
-    :param trade: A `Trade` instance, necessary for executing trades and managing positions.
-    :param tf: Time frame for the trading data, default is 'D1' (daily).
-    :param k: Number of past points to consider for the ARCH model analysis, default is 500.
-    :param mm: Boolean flag indicating if money management strategies should be applied, default is True.
-    :param max_t: Maximum number of trades allowed at any given time, default is 1.
-    :param iter_time: Time in minutes between each iteration of the trading loop. Can be an integer or float.
-    :param risk_manager: Specifies the risk management model to use. Default is None. 
-    :param rm_window: Window size for the risk model use for the prediction, defaults to None. 
-        Must be specified if `risk_manager` is not None.
-    :param period: Trading period to consider for closing positions, options are 'month', 'week', or 'day'. 
-                   This affects the frequency at which statistics are calculated and positions are closed.
-    :param kwargs: Additional keyword arguments for the risk management models or other strategy-specific settings.
-
-    This function is designed to perform trading based on ARCH model predictions, managing risk using an HMM where 
-    applicable, and handling trade executions and position management based on the specified parameters. It includes 
-    considerations for trading times, money management, and periodic evaluation of trading performance.
+    The `ExecutionEngine` class serves as the central hub for executing your trading strategies within the `bbstrader` framework. 
+    It orchestrates the entire trading process, ensuring seamless interaction between your strategies, market data, and your chosen 
+    trading platform (currently MetaTrader 5 (MT5) and Interactive Brokers TWS).
+
+    Key Features
+    ------------
+
+    - **Strategy Execution:** The `ExecutionEngine` is responsible for running your strategy, retrieving signals, and executing trades based on those signals.
+    - **Time Management:** You can define a specific time frame for your trades and set the frequency with which the engine checks for signals and manages trades.
+    - **Trade Period Control:** Define whether your strategy runs for a day, a week, or a month, allowing for flexible trading durations.
+    - **Money Management:** The engine supports optional money management features, allowing you to control risk and optimize your trading performance.
+    - **Trading Day Configuration:** You can customize the days of the week your strategy will execute, providing granular control over your trading schedule.
+    - **Platform Integration:** The `ExecutionEngine` is currently designed to work with both MT5 and TWS platforms, ensuring compatibility and flexibility in your trading environment.
+
+    Examples
+    --------
+    
+    >>> from bbstrader.metatrader import create_trade_instance
+    >>> from bbstrader.trading.execution import ExecutionEngine
+    >>> from bbstrader.trading.strategies import StockIndexCFDTrading
+    >>> from bbstrader.metatrader.utils import config_logger
+    >>> 
+    >>> if __name__ == '__main__':
+    >>>     logger = config_logger(index_trade.log, console_log=True)
+    >>>     # Define symbols
+    >>>     ndx = '[NQ100]'
+    >>>     spx = '[SP500]'
+    >>>     dji = '[DJI30]'
+    >>>     dax = 'GERMANY40'
+    >>>  
+    >>>     symbol_list = [spx, dax, dji,  ndx]
+    >>> 
+    >>>     trade_kwargs = {
+    ...        'expert_id': 5134,
+    ...        'version': 2.0,
+    ...        'time_frame': '15m',
+    ...        'var_level': 0.99,
+    ...        'start_time': '8:30',
+    ...        'finishing_time': '19:30',
+    ...        'ending_time': '21:30',
+    ...        'max_risk': 5.0,
+    ...        'daily_risk': 0.10,
+    ...        'pchange_sl': 1.5,
+    ...        'rr': 3.0,
+    ...        'logger': logger
+    ...    }
+    >>>     strategy_kwargs = {
+    ...        'max_trades': {ndx: 3, spx: 3, dji: 3, dax: 3},
+    ...        'expected_returns': {ndx: 1.5, spx: 1.5, dji: 1.0, dax: 1.0},
+    ...        'strategy_name': 'SISTBO',
+    ...        'logger': logger,
+    ...        'expert_id': 5134
+    ...    }
+    >>>     trades_instances = create_trade_instance(
+    ...        symbol_list, trade_kwargs,
+    ...        logger=logger,
+    ...    )
+    >>> 
+    >>>     engine = ExecutionEngine(
+    ...        symbol_list,
+    ...        trades_instances,
+    ...        StockIndexCFDTrading,
+    ...        time_frame='15m',
+    ...        iter_time=5,
+    ...        mm=True,
+    ...        period='week',
+    ...        comment='bbs_SISTBO_@2.0',
+    ...        **strategy_kwargs
+    ...    )
+    >>>     engine.run(terminal='MT5')
     """
-    regime = False
-    if risk_manager is not None:
-        if risk_manager.lower() == 'hmm':
-            assert rm_window is not None
-            regime = True
-
-    def check(buys: list, sells: list):
-        if buys is not None or sells is not None:
-            logger.info(f"Checking for Break even on {trade.symbol}...")
-            trade.break_even()
-
-    time_frame_mapping = tf_mapping()
-    if tf == 'D1':
-        trade_time = trade.get_minutes()
-    else:
-        trade_time = time_frame_mapping[tf]
-
-    rate = Rates(trade.symbol, tf, 0)
-    data = rate.get_rates_from_pos()
-    strategy = ArimaGarchStrategy(trade.symbol, data, k=k)
-    if regime:
-        if risk_manager == 'hmm':
-            hmm = HMMRiskManager(data=data, verbose=True, iterations=5000, **kwargs)
-
-    time_intervals = 0
-    long_market = False
-    short_market = False
-    num_days = 0
-    logger.info(
-        f'Running ARIMA + GARCH Strategy on {trade.symbol} in {tf} Interval ...\n')
-    while True:
-        current_date = datetime.now()
-        today = current_date.strftime("%A")
-        try:
-            buys = trade.get_current_buys()
-            if buys is not None:
-                logger.info(f"Current buy positions on {trade.symbol}: {buys}, STRATEGY=ARCH")
-            sells = trade.get_current_sells()
-            if sells is not None:
-                logger.info(f"Current sell positions on {trade.symbol}: {sells}, STRATEGY=ARCH")
-            long_market = buys is not None and len(buys) >= max_t
-            short_market = sells is not None and len(sells) >= max_t
-
-            time.sleep(0.5)
-            if regime:
-                if risk_manager == 'hmm':
-                    hmm_returns = Rates(trade.symbol, tf, 0, rm_window)
-                    hmm_returns_val = hmm_returns.get_returns.values
-                    current_regime = hmm.which_trade_allowed(hmm_returns_val)
-                    logger.info(f'CURRENT REGIME = {current_regime}, SYMBOL={trade.symbol}, STRATEGY=ARCH')
-            else:
-                current_regime = None
-            logger.info(f"Calculating Signal ... SYMBOL={trade.symbol}, STRATEGY=ARCH")
-            arch_data = Rates(trade.symbol, tf, 0, k)
-            rates = arch_data.get_rates_from_pos()
-            arch_returns = strategy.load_and_prepare_data(rates)
-            window_data = arch_returns['diff_log_return'].iloc[-k:]
-            signal = strategy.calculate_signals(window_data)
-
-            comment = f"{trade.expert_name}@{trade.version}"
-            if trade.trading_time() and today in TRADING_DAYS:
-                if signal is not None:
-                    logger.info(f"SIGNAL = {signal}, SYMBOL={trade.symbol}, STRATEGY=ARCH")
-                    if signal == "LONG" and short_market:
-                        trade.close_positions(position_type='sell')
-                        short_market = False
-                    elif signal == "SHORT" and long_market:
-                        trade.close_positions(position_type='buy')
-                        long_market = False
-                    if current_regime is not None:
-                        if current_regime == 'LONG':
-                            if signal == "LONG" and not long_market:
-                                if time_intervals % trade_time == 0 or buys is None:
-                                    logger.info(f"Sending buy Order .... SYMBOL={trade.symbol}, STRATEGY=ARCH")
-                                    trade.open_buy_position(
-                                        mm=mm, comment=comment)
-                                else:
-                                    check(buys, sells)
 
-                            elif signal == "LONG" and long_market:
-                                logger.info(f"Sorry Risk not allowed !!! SYMBOL={trade.symbol}, STRATEGY=ARCH")
-                                check(buys, sells)
-
-                        elif current_regime == 'SHORT':
-                            if signal == "SHORT" and not short_market:
-                                if time_intervals % trade_time == 0 or sells is None:
-                                    logger.info(f"Sending Sell Order .... SYMBOL={trade.symbol}, STRATEGY=ARCH")
-                                    trade.open_sell_position(
-                                        mm=mm, comment=comment)
-                                else:
-                                    check(buys, sells)
-                            elif signal == "SHORT" and short_market:
-                                logger.info(f"Sorry Risk not Allowed !!! SYMBOL={trade.symbol}, STRATEGY=ARCH")
-                                check(buys, sells)
-                    else:
-                        if signal == "LONG" and not long_market:
-                            if time_intervals % trade_time == 0 or buys is None:
-                                logger.info(f"Sending buy Order .... SYMBOL={trade.symbol}, STRATEGY=ARCH")
-                                trade.open_buy_position(mm=mm, comment=comment)
-                            else:
-                                check(buys, sells)
-
-                        elif signal == "LONG" and long_market:
-                            logger.info(f"Sorry Risk not allowed !!! SYMBOL={trade.symbol}, STRATEGY=ARCH")
-                            check(buys, sells)
-
-                        if signal == "SHORT" and not short_market:
-                            if time_intervals % trade_time == 0 or sells is None:
-                                logger.info(f"Sending Sell Order .... SYMBOL={trade.symbol}, STRATEGY=ARCH")
-                                trade.open_sell_position(
-                                    mm=mm, comment=comment)
-                            else:
-                                check(buys, sells)
-
-                        elif signal == "SHORT" and short_market:
-                            logger.info(f"Sorry Risk not Allowed !!! SYMBOL={trade.symbol}, STRATEGY=ARCH")
-                            check(buys, sells)
-                else:
-                    logger.info("There is no signal !!")
-                    check(buys, sells)
-            else:
-                logger.info(f"Sorry It is Not trading Time !!! SYMBOL={trade.symbol}, STRATEGY=ARCH")
-                check(buys, sells)
-
-        except Exception as e:
-            print(f"{e}, SYMBOL={trade.symbol}, STRATEGY=ARCH")
-
-        time.sleep((60 * iter_time) - 1.5)
-        if iter_time == 1:
-            time_intervals += 1
-        elif iter_time == trade_time:
-            time_intervals += trade_time
-        else:
-            time_intervals += (trade_time/iter_time)
-
-        if period.lower() == 'month':
-            if trade.days_end() and today != 'Friday':
-                logger.info(f"End of the Day !!! SYMBOL={trade.symbol}, STRATEGY=ARCH")
-                sleep_time = trade.sleep_time()
-                time.sleep(60 * sleep_time)
-                num_days += 1
-
-            elif trade.days_end() and today == 'Friday':
-                logger.info(f"End of the Week !!! SYMBOL={trade.symbol}, STRATEGY=ARCH")
-                sleep_time = trade.sleep_time(weekend=True)
-                time.sleep(60 * sleep_time)
-                num_days += 1
-
-            elif (
-                    trade.days_end()
-                and today == 'Friday'
-                and num_days >= 20
-            ):
-                trade.close_positions(position_type='all', comment=comment)
-                logger.info(f"End of the Month !!! SYMBOL={trade.symbol}, STRATEGY=ARCH")
-                trade.statistics(save=True)
-                break
-
-        elif period.lower() == 'week':
-            if trade.days_end() and today != 'Friday':
-                sleep_time = trade.sleep_time()
-                time.sleep(60 * sleep_time)
-
-            elif trade.days_end() and today == 'Friday':
-                trade.close_positions(position_type='all', comment=comment)
-                logger.info(f"End of the Week !!! SYMBOL={trade.symbol}, STRATEGY=ARCH")
-                trade.statistics(save=True)
-                break
-
-        elif period.lower() == 'day':
-            if trade.days_end():
-                trade.close_positions(position_type='all', comment=comment)
-                logger.info(f"End of the Day !!! SYMBOL={trade.symbol}, STRATEGY=ARCH")
-                trade.statistics(save=True)
-                break
+    def __init__(self,
+                 symbol_list:        List[str],
+                 trades_instances:   Dict[str, Trade],
+                 strategy_cls:       Strategy,
+                 /,
+                 mm:                 Optional[bool] = True,
+                 time_frame:         Optional[str] = '15m',
+                 iter_time:          Optional[int | float] = 5,
+                 period:             Literal['day', 'week', 'month'] = 'week',
+                 trading_days:       Optional[List[str]] = TRADING_DAYS,
+                 comment:            Optional[str] = None,
+                 **kwargs
+                 ):
+        """
+        Args:
+            symbol_list : List of symbols to trade
+            trades_instances : Dictionary of Trade instances
+            strategy_cls : Strategy class to use for trading
+            mm : Enable Money Management. Defaults to False.
+            time_frame : Time frame to trade. Defaults to '15m'.
+            iter_time : Interval to check for signals and `mm`. Defaults to 5.
+            period : Period to trade. Defaults to 'week'.
+            trading_days : Trading days in a week. Defaults to monday to friday.
+            comment: Comment for trades. Defaults to None.
+            **kwargs: Additional keyword arguments
+                - strategy_name (Optional[str]): Strategy name. Defaults to None.
+                - max_trades (Dict[str, int]): Maximum trades per symbol. Defaults to None.
+                - logger (Optional[logging.Logger]): Logger instance. Defaults to None.
+
+        Note:
+            1. All Strategies must inherit from `bbstrader.btengine.strategy.Strategy` class
+            and have a `calculate_signals` method that returns a dictionary of signals for each symbol in symbol_list.
+            
+            2. 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
+                - symbol_list (List[str]): List of symbols to trade can be none for backtesting
+                - mode (str): Mode of the strategy. Must be either 'live' or 'backtest'
+                - **kwargs: Additional keyword arguments
+                    The keyword arguments are all the additional arguments passed to the `ExecutionEngine` class,
+                    the `Strategy` class, the `DataHandler` class, the `Portfolio` class and the `ExecutionHandler` class.
+                - The `bars` and `events` arguments are used for backtesting only.
+            
+            3. 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.
+        """
+        self.symbol_list = symbol_list
+        self.trades_instances = trades_instances
+        self.strategy_cls = strategy_cls
+        self.mm = mm
+        self.time_frame = time_frame
+        self.iter_time = iter_time
+        self.period = period
+        self.trading_days = trading_days
+        self.comment = comment
+        self.kwargs = kwargs
+
+    def run(self, terminal: Literal['MT5', 'TWS']):
+        if terminal not in _TERMINALS:
+            raise ValueError(
+                f"Invalid terminal: {terminal}. Must be either 'MT5' or 'TWS'")
+        _TERMINALS[terminal](
+                self.symbol_list,
+                self.trades_instances,
+                self.strategy_cls,
+                mm=self.mm,
+                time_frame=self.time_frame,
+                iter_time=self.iter_time,
+                period=self.period,
+                trading_days=self.trading_days,
+                comment=self.comment,
+                **self.kwargs
+            )