bbstrader 0.2.99__py3-none-any.whl → 0.3.0__py3-none-any.whl

bbstrader/metatrader/rates.py

@@ -7,7 +7,7 @@ from pandas.tseries.holiday import USFederalHolidayCalendar
 from pandas.tseries.offsets import CustomBusinessDay
 
 from bbstrader.metatrader.account import AMG_EXCHANGES, Account, check_mt5_connection
-from bbstrader.metatrader.utils import TIMEFRAMES, TimeFrame, raise_mt5_error
+from bbstrader.metatrader.utils import TIMEFRAMES, TimeFrame, raise_mt5_error, SymbolType
 
 try:
     import MetaTrader5 as Mt5
@@ -46,13 +46,13 @@ COMD_CALENDARS = {
 }
 
 CALENDARS = {
-    "FX": "us_futures",
-    "STK": AMG_EXCHANGES,
-    "ETF": AMG_EXCHANGES,
-    "IDX": IDX_CALENDARS,
-    "COMD": COMD_CALENDARS,
-    "CRYPTO": "24/7",
-    "FUT": None,
+    SymbolType.FOREX: "us_futures",
+    SymbolType.STOCKS: AMG_EXCHANGES,
+    SymbolType.ETFs: AMG_EXCHANGES,
+    SymbolType.INDICES: IDX_CALENDARS,
+    SymbolType.COMMODITIES: COMD_CALENDARS,
+    SymbolType.CRYPTO: "24/7",
+    SymbolType.FUTURES: None,
 }
 
 SESSION_TIMEFRAMES = [
@@ -206,6 +206,7 @@ class Rates(object):
     ) -> Union[pd.DataFrame, None]:
         """Fetches data from MT5 and returns a DataFrame or None."""
         try:
+            rates = None
             if isinstance(start, int) and isinstance(count, int):
                 rates = Mt5.copy_rates_from_pos(
                     self.symbol, self.time_frame, start, count
@@ -248,7 +249,7 @@ class Rates(object):
         currencies = self.__account.get_currency_rates(self.symbol)
         s_info = self.__account.get_symbol_info(self.symbol)
         if symbol_type in CALENDARS:
-            if symbol_type == "STK" or symbol_type == "ETF":
+            if symbol_type == SymbolType.STOCKS or symbol_type == SymbolType.ETFs:
                 for exchange in CALENDARS[symbol_type]:
                     if exchange in get_calendar_names():
                         symbols = self.__account.get_stocks_from_exchange(
@@ -257,20 +258,20 @@ class Rates(object):
                         if self.symbol in symbols:
                             calendar = get_calendar(exchange, side="right")
                             break
-            elif symbol_type == "IDX":
+            elif symbol_type == SymbolType.INDICES:
                 calendar = get_calendar(
                     CALENDARS[symbol_type][currencies["mc"]], side="right"
                 )
-            elif symbol_type == "COMD":
+            elif symbol_type == SymbolType.COMMODITIES:
                 for commodity in CALENDARS[symbol_type]:
                     if commodity in s_info.path:
                         calendar = get_calendar(
                             CALENDARS[symbol_type][commodity], side="right"
                         )
-            elif symbol_type == "FUT":
+            elif symbol_type == SymbolType.FUTURES:
                 if "Index" in s_info.path:
                     calendar = get_calendar(
-                        CALENDARS["IDX"][currencies["mc"]], side="right"
+                        CALENDARS[SymbolType.INDICES][currencies["mc"]], side="right"
                     )
                 else:
                     for commodity, cal in COMD_CALENDARS.items():

bbstrader/metatrader/risk.py

@@ -6,7 +6,7 @@ from scipy.stats import norm
 
 from bbstrader.metatrader.account import Account
 from bbstrader.metatrader.rates import Rates
-from bbstrader.metatrader.utils import TIMEFRAMES, TimeFrame
+from bbstrader.metatrader.utils import TIMEFRAMES, TimeFrame, SymbolType
 
 try:
     import MetaTrader5 as Mt5
@@ -275,10 +275,12 @@ class RiskManagement(Account):
             swap = df["swap"].sum()
             total_profit = commisions + fees + swap + profit
             initial_balance = balance - total_profit
-            if balance != 0:
+            if equity != 0:
                 risk_alowed = (((equity - initial_balance) / equity) * 100) * -1
                 return round(risk_alowed, 2)
-        return 0.0
+            else: # Handle equity is zero
+                return 0.0
+        return 0.0 # This is for the case where df is None
 
     def get_lot(self) -> float:
         """ "Get the approprite lot size for a trade"""
@@ -498,10 +500,10 @@ class RiskManagement(Account):
         av_price = (s_info.bid + s_info.ask) / 2
         trade_risk = self.get_trade_risk()
         symbol_type = self.get_symbol_type(self.symbol)
-        FX = symbol_type == "FX"
-        COMD = symbol_type == "COMD"
-        FUT = symbol_type == "FUT"
-        CRYPTO = symbol_type == "CRYPTO"
+        FX = symbol_type == SymbolType.FOREX
+        COMD = symbol_type == SymbolType.COMMODITIES
+        FUT = symbol_type == SymbolType.FUTURES
+        CRYPTO = symbol_type == SymbolType.CRYPTO
         if COMD:
             supported = _COMMD_SUPPORTED_
             if "." in self.symbol:
@@ -652,14 +654,14 @@ class RiskManagement(Account):
         lot = self._check_lot(_lot)
 
         volume = round(lot * size * av_price)
-        if self.get_symbol_type(self.symbol) == "FX":
+        if self.get_symbol_type(self.symbol) == SymbolType.FOREX:
             volume = round((trade_loss * size) / loss)
             __lot = round((volume / size), 2)
             lot = self._check_lot(__lot)
 
         if (
-            self.get_symbol_type(self.symbol) == "COMD"
-            or self.get_symbol_type(self.symbol) == "CRYPTO"
+            self.get_symbol_type(self.symbol) == SymbolType.COMMODITIES
+            or self.get_symbol_type(self.symbol) == SymbolType.CRYPTO
             and size > 1
         ):
             lot = currency_risk / (sl * loss * size)
@@ -705,7 +707,7 @@ class RiskManagement(Account):
         if account:
             return AL
 
-        if self.get_symbol_type(self.symbol) == "FX":
+        if self.get_symbol_type(self.symbol) == SymbolType.FOREX:
             return AL
         else:
             s_info = self.symbol_info

bbstrader/metatrader/trade.py

@@ -33,12 +33,6 @@ __all__ = [
     "create_trade_instance",
 ]
 
-FILLING_TYPE = [
-    Mt5.ORDER_FILLING_IOC,
-    Mt5.ORDER_FILLING_RETURN,
-    Mt5.ORDER_FILLING_BOC,
-]
-
 log.add(
     f"{BBSTRADER_DIR}/logs/trade.log",
     enqueue=True,
@@ -50,6 +44,13 @@ global LOGGER
 LOGGER = log
 
 
+FILLING_TYPE = [
+    Mt5.ORDER_FILLING_IOC,
+    Mt5.ORDER_FILLING_RETURN,
+    Mt5.ORDER_FILLING_BOC,
+]
+
+
 class TradeAction(Enum):
     """
     An enumeration class for trade actions.
@@ -136,6 +137,15 @@ class TradeSignal:
             f"price={self.price}, stoplimit={self.stoplimit}), comment='{self.comment}'"
         )
 
+class TradingMode(Enum):
+    BACKTEST = "BACKTEST"
+    LIVE = "LIVE"
+
+    def isbacktest(self) -> bool:
+        return self == TradingMode.BACKTEST
+    def islive(self) -> bool:
+        return self == TradingMode.LIVE
+
 
 Buys = Literal["BMKT", "BLMT", "BSTP", "BSTPLMT"]
 Sells = Literal["SMKT", "SLMT", "SSTP", "SSTPLMT"]
@@ -152,6 +162,7 @@ Orders = Literal[
 
 EXPERT_ID = 98181105
 
+
 class Trade(RiskManagement):
     """
     Extends the `RiskManagement` class to include specific trading operations,
@@ -531,6 +542,7 @@ class Trade(RiskManagement):
             mm (bool): Weither to put stop loss and tp or not
             trail (bool): Weither to trail the stop loss or not
             comment (str): The comment for the opening position
+            volume (float): The volume (lot) to trade
             sl (float): The stop loss price
             tp (float): The take profit price
         """
@@ -621,7 +633,6 @@ class Trade(RiskManagement):
             mm (bool): Weither to put stop loss and tp or not
             trail (bool): Weither to trail the stop loss or not
             comment (str): The comment for the closing position
-                        symbol (str): The symbol to trade
             volume (float): The volume (lot) to trade
             sl (float): The stop loss price
             tp (float): The take profit price
@@ -834,7 +845,7 @@ class Trade(RiskManagement):
             action (str): (`'BMKT'`, `'SMKT'`) for Market orders
                 or (`'BLMT', 'SLMT', 'BSTP', 'SSTP', 'BSTPLMT', 'SSTPLMT'`) for pending orders
             price (float): The price at which to open an order
-            stoplimit (float): A price a pending Limit order is set at 
+            stoplimit (float): A price a pending Limit order is set at
                 when the price reaches the 'price' value (this condition is mandatory).
                 The pending order is not passed to the trading system until that moment
             id (int): The strategy id or expert Id
@@ -873,30 +884,30 @@ class Trade(RiskManagement):
     @property
     def orders(self):
         """Return all opened order's tickets"""
-        if len(self.opened_orders) != 0:
-            return self.opened_orders
-        return None
+        current_orders = self.get_current_orders() or []
+        opened_orders = set(current_orders + self.opened_orders)
+        return list(opened_orders) if len(opened_orders) != 0 else None
 
     @property
     def positions(self):
         """Return all opened position's tickets"""
-        if len(self.opened_positions) != 0:
-            return self.opened_positions
-        return None
+        current_positions = self.get_current_positions() or []
+        opened_positions = set(current_positions + self.opened_positions)
+        return list(opened_positions) if len(opened_positions) != 0 else None
 
     @property
     def buypos(self):
         """Return all buy  opened position's tickets"""
-        if len(self.buy_positions) != 0:
-            return self.buy_positions
-        return None
+        buy_positions = self.get_current_buys() or []
+        buy_positions = set(buy_positions + self.buy_positions)
+        return list(buy_positions) if len(buy_positions) != 0 else None
 
     @property
     def sellpos(self):
         """Return all sell  opened position's tickets"""
-        if len(self.sell_positions) != 0:
-            return self.sell_positions
-        return None
+        sell_positions = self.get_current_sells() or []
+        sell_positions = set(sell_positions + self.sell_positions)
+        return list(sell_positions) if len(sell_positions) != 0 else None
 
     @property
     def bepos(self):
@@ -1214,7 +1225,7 @@ class Trade(RiskManagement):
         Sets the break-even level for a given trading position.
 
         Args:
-            position (TradePosition): The trading position for which the break-even is to be set. 
+            position (TradePosition): The trading position for which the break-even is to be set.
                 This is the value return by `mt5.positions_get()`.
             be (int): The break-even level in points.
             level (float): The break-even level in price, if set to None , it will be calated automaticaly.
@@ -1446,7 +1457,7 @@ class Trade(RiskManagement):
         Args:
             ticket (int): Order ticket to modify (e.g TradeOrder.ticket)
             price (float): The price at which to modify the order
-            stoplimit (float): A price a pending Limit order is set at 
+            stoplimit (float): A price a pending Limit order is set at
                 when the price reaches the 'price' value (this condition is mandatory).
                 The pending order is not passed to the trading system until that moment
             sl (float): The stop loss in points
@@ -1597,7 +1608,7 @@ class Trade(RiskManagement):
     ):
         """
         Args:
-            order_type (str): Type of orders to close 
+            order_type (str): Type of orders to close
                 ('all', 'buy_stops', 'sell_stops', 'buy_limits', 'sell_limits', 'buy_stop_limits', 'sell_stop_limits')
             id (int): The unique ID of the Expert or Strategy
             comment (str): Comment for the closing position

bbstrader/metatrader/utils.py

@@ -70,27 +70,31 @@ class TimeFrame(Enum):
     Rrepresent a time frame object
     """
 
-    M1 = "1m"
-    M2 = "2m"
-    M3 = "3m"
-    M4 = "4m"
-    M5 = "5m"
-    M6 = "6m"
-    M10 = "10m"
-    M12 = "12m"
-    M15 = "15m"
-    M20 = "20m"
-    M30 = "30m"
-    H1 = "1h"
-    H2 = "2h"
-    H3 = "3h"
-    H4 = "4h"
-    H6 = "6h"
-    H8 = "8h"
-    H12 = "12h"
-    D1 = "D1"
-    W1 = "W1"
-    MN1 = "MN1"
+    M1 = TIMEFRAMES["1m"]
+    M2 = TIMEFRAMES["2m"]
+    M3 = TIMEFRAMES["3m"]
+    M4 = TIMEFRAMES["4m"]
+    M5 = TIMEFRAMES["5m"]
+    M6 = TIMEFRAMES["6m"]
+    M10 = TIMEFRAMES["10m"]
+    M12 = TIMEFRAMES["12m"]
+    M15 = TIMEFRAMES["15m"]
+    M20 = TIMEFRAMES["20m"]
+    M30 = TIMEFRAMES["30m"]
+    H1 = TIMEFRAMES["1h"]
+    H2 = TIMEFRAMES["2h"]
+    H3 = TIMEFRAMES["3h"]
+    H4 = TIMEFRAMES["4h"]
+    H6 = TIMEFRAMES["6h"]
+    H8 = TIMEFRAMES["8h"]
+    H12 = TIMEFRAMES["12h"]
+    D1 = TIMEFRAMES["D1"]
+    W1 = TIMEFRAMES["W1"]
+    MN1 = TIMEFRAMES["MN1"]
+
+    def __str__(self):
+        """Return the string representation of the time frame."""
+        return self.name
 
 
 class TerminalInfo(NamedTuple):
@@ -263,6 +267,23 @@ class SymbolInfo(NamedTuple):
     path: str
 
 
+class SymbolType(Enum):
+    """
+    Represents the type of a symbol.
+    """
+
+    FOREX = "FOREX"  # Forex currency pairs
+    FUTURES = "FUTURES"  # Futures contracts
+    STOCKS = "STOCKS"  # Stocks and shares
+    BONDS = "BONDS"  # Bonds
+    CRYPTO = "CRYPTO"  # Cryptocurrencies
+    ETFs = "ETFs"  # Exchange-Traded Funds
+    INDICES = "INDICES"  # Market indices
+    COMMODITIES = "COMMODITIES"  # Commodities
+    OPTIONS = "OPTIONS"  # Options contracts
+    unknown = "UNKNOWN"  # Unknown or unsupported type
+
+
 class TickInfo(NamedTuple):
     """
     Represents the last tick for the specified financial instrument.
@@ -465,10 +486,12 @@ class MT5TerminalError(Exception):
         self.message = message
 
     def __str__(self) -> str:
-        if self.message is None:
-            return f"{self.__class__.__name__}"
-        else:
-            return f"{self.__class__.__name__}, {self.message}"
+        # if self.message is None:
+        #     return f"{self.__class__.__name__}"
+        # else:
+        #     return f"{self.__class__.__name__}, {self.message}"
+        msg_str = str(self.message) if self.message is not None else ""
+        return f"{self.code} - {self.__class__.__name__}: {msg_str}"
 
 
 class GenericFail(MT5TerminalError):
@@ -561,6 +584,21 @@ class InternalFailTimeout(InternalFailError):
         super().__init__(MT5.RES_E_INTERNAL_FAIL_TIMEOUT, message)
 
 
+RES_E_FAIL = 1  # Generic error
+RES_E_INVALID_PARAMS = 2  # Invalid parameters
+RES_E_NOT_FOUND = 3  # Not found
+RES_E_INVALID_VERSION = 4  # Invalid version
+RES_E_AUTH_FAILED = 5  # Authorization failed
+RES_E_UNSUPPORTED = 6  # Unsupported method
+RES_E_AUTO_TRADING_DISABLED = 7  # Autotrading disabled
+
+# Actual internal error codes from MetaTrader5
+RES_E_INTERNAL_FAIL_CONNECT = -10000
+RES_E_INTERNAL_FAIL_INIT = -10001
+RES_E_INTERNAL_FAIL_SEND = -10006
+RES_E_INTERNAL_FAIL_RECEIVE = -10007
+RES_E_INTERNAL_FAIL_TIMEOUT = -10008
+
 # Dictionary to map error codes to exception classes
 _ERROR_CODE_TO_EXCEPTION_ = {
     MT5.RES_E_FAIL: GenericFail,
@@ -575,6 +613,18 @@ _ERROR_CODE_TO_EXCEPTION_ = {
     MT5.RES_E_INTERNAL_FAIL_INIT: InternalFailInit,
     MT5.RES_E_INTERNAL_FAIL_CONNECT: InternalFailConnect,
     MT5.RES_E_INTERNAL_FAIL_TIMEOUT: InternalFailTimeout,
+    RES_E_FAIL: GenericFail,
+    RES_E_INVALID_PARAMS: InvalidParams,
+    RES_E_NOT_FOUND: HistoryNotFound,
+    RES_E_INVALID_VERSION: InvalidVersion,
+    RES_E_AUTH_FAILED: AuthFailed,
+    RES_E_UNSUPPORTED: UnsupportedMethod,
+    RES_E_AUTO_TRADING_DISABLED: AutoTradingDisabled,
+    RES_E_INTERNAL_FAIL_SEND: InternalFailSend,
+    RES_E_INTERNAL_FAIL_RECEIVE: InternalFailReceive,
+    RES_E_INTERNAL_FAIL_INIT: InternalFailInit,
+    RES_E_INTERNAL_FAIL_CONNECT: InternalFailConnect,
+    RES_E_INTERNAL_FAIL_TIMEOUT: InternalFailTimeout,
 }
 
 
@@ -588,7 +638,10 @@ def raise_mt5_error(message: Optional[str] = None):
         MT5TerminalError: A specific exception based on the error code.
     """
     error = _ERROR_CODE_TO_EXCEPTION_.get(MT5.last_error()[0])
-    raise Exception(f"{error(None)} {message or MT5.last_error()[1]}")
+    if error is not None:
+        raise Exception(f"{error(None)} {message or MT5.last_error()[1]}")
+    else:
+        raise Exception(f"{message or MT5.last_error()[1]}")
 
 
 _ORDER_FILLING_TYPE_ = "https://www.mql5.com/en/docs/constants/tradingconstants/orderproperties#enum_order_type_filling"

bbstrader/models/factors.py

@@ -28,8 +28,10 @@ def _download_and_process_data(source, tickers, start, end, tf, path, **kwargs):
                     end=end,
                     progress=False,
                     multi_level_index=False,
+                    auto_adjust=True,
                 )
-                data = data.drop(columns=["Adj Close"], axis=1)
+                if "Adj Close" in data.columns:
+                    data = data.drop(columns=["Adj Close"], axis=1)
             elif source == "mt5":
                 start, end = pd.Timestamp(start), pd.Timestamp(end)
                 data = download_historical_data(

bbstrader/models/ml.py

@@ -250,12 +250,13 @@ class LightGBModel(object):
         data = pd.concat(data)
         data = (
             data.rename(columns={s: s.lower().replace(" ", "_") for s in data.columns})
-            .drop(columns=["adj_close"])
             .set_index("symbol", append=True)
             .swaplevel()
             .sort_index()
             .dropna()
         )
+        if "adj_close" in data.columns:
+            data = data.drop(columns=["adj_close"])
         return data
 
     def download_metadata(self, tickers):

bbstrader/models/nlp.py

@@ -331,8 +331,18 @@ FINANCIAL_LEXICON = {
 
 class TopicModeler(object):
     def __init__(self):
-        self.nlp = spacy.load("en_core_web_sm")
-        self.nlp.disable_pipes("ner")
+        nltk.download("punkt", quiet=True)
+        nltk.download("stopwords", quiet=True)
+
+        try:
+            self.nlp = spacy.load("en_core_web_sm")
+            self.nlp.disable_pipes("ner")
+        except OSError:
+            raise RuntimeError(
+                "The SpaCy model 'en_core_web_sm' is not installed.\n"
+                "Please install it by running:\n"
+                "   python -m spacy download en_core_web_sm"
+            )
 
     def preprocess_texts(self, texts: list[str]):
         def clean_doc(Doc):
@@ -506,6 +516,7 @@ class SentimentAnalyzer(object):
             reddit_posts = news.get_reddit_posts(
                 ticker, n_posts=top_news, **{k: kwargs.get(k) for k in rd_params}
             )
+            coindesk_news = news.get_coindesk_news(query=ticker, list_of_str=True)
             fmp_source_news = []
             fmp_news = news.get_fmp_news(kwargs.get("fmp_api"))
             for source in ["articles"]:  # , "releases", asset_type]:
@@ -518,7 +529,7 @@ class SentimentAnalyzer(object):
                     source_news = []
             if any([len(s) > 0 for s in [yahoo_news, google_news]]):
                 sources += 1
-            for source in [reddit_posts, fmp_source_news]:
+            for source in [reddit_posts, fmp_source_news, coindesk_news]:
                 if len(source) > 0:
                     sources += 1
             # Compute sentiment
@@ -531,11 +542,17 @@ class SentimentAnalyzer(object):
             fmp_sentiment = self.analyze_sentiment(
                 fmp_source_news, lexicon=lexicon, textblob=True
             )
+            coindesk_sentiment = self.analyze_sentiment(
+                coindesk_news, lexicon=lexicon, textblob=True
+            )
 
             # Weighted average sentiment score
             if sources != 0:
                 overall_sentiment = (
-                    news_sentiment + reddit_sentiment + fmp_sentiment
+                    news_sentiment
+                    + reddit_sentiment
+                    + fmp_sentiment
+                    + coindesk_sentiment
                 ) / sources
             else:
                 overall_sentiment = 0.0

bbstrader/trading/execution.py

@@ -9,7 +9,7 @@ from loguru import logger as log
 from bbstrader.btengine.strategy import MT5Strategy, Strategy
 from bbstrader.config import BBSTRADER_DIR
 from bbstrader.metatrader.account import Account, check_mt5_connection
-from bbstrader.metatrader.trade import Trade, TradeAction
+from bbstrader.metatrader.trade import Trade, TradeAction, TradingMode
 from bbstrader.trading.utils import send_message
 
 try:
@@ -174,6 +174,7 @@ class Mt5ExecutionEngine:
         strategy_cls: Strategy,
         /,
         mm: bool = True,
+        auto_trade: bool = True,
         optimizer: str = "equal",
         trail: bool = True,
         stop_trail: Optional[int] = None,
@@ -187,7 +188,7 @@ class Mt5ExecutionEngine:
         closing_pnl: Optional[float] = None,
         trading_days: Optional[List[str]] = None,
         comment: Optional[str] = None,
-        **kwargs
+        **kwargs,
     ):
         """
         Args:
@@ -197,6 +198,9 @@ class Mt5ExecutionEngine:
             mm : Enable Money Management. Defaults to True.
             optimizer : Risk management optimizer. Defaults to 'equal'.
                 See `bbstrader.models.optimization` module for more information.
+            auto_trade :  If set to true, when signal are generated by the strategy class,
+                the Execution engine will automaticaly open position in other whise it will prompt
+                the user for confimation.
             show_positions_orders : Print open positions and orders. Defaults to False.
             iter_time : Interval to check for signals and `mm`. Defaults to 5.
             use_trade_time : Open trades after the time is completed. Defaults to True.
@@ -239,6 +243,7 @@ class Mt5ExecutionEngine:
         self.trades_instances = trades_instances
         self.strategy_cls = strategy_cls
         self.mm = mm
+        self.auto_trade = auto_trade
         self.optimizer = optimizer
         self.trail = trail
         self.stop_trail = stop_trail
@@ -266,7 +271,7 @@ class Mt5ExecutionEngine:
     def __repr__(self):
         trades = self.trades_instances.keys()
         strategy = self.strategy_cls.__name__
-        return f"Mt5ExecutionEngine(Symbols={list(trades)}, Strategy={strategy})"
+        return f"{self.__class__.__name__}(Symbols={list(trades)}, Strategy={strategy})"
 
     def _initialize_engine(self, **kwargs):
         global logger
@@ -300,14 +305,14 @@ class Mt5ExecutionEngine:
             )
             return
 
-    def _print_exc(self, msg, e: Exception):
+    def _print_exc(self, msg: str, e: Exception):
         if isinstance(e, KeyboardInterrupt):
             logger.info("Stopping the Execution Engine ...")
             quit()
         if self.debug_mode:
             raise ValueError(msg).with_traceback(e.__traceback__)
         else:
-            logger.error(msg)
+            logger.error(f"{msg, repr(e)}")
 
     def _max_trades(self, mtrades):
         max_trades = {
@@ -331,7 +336,7 @@ class Mt5ExecutionEngine:
         try:
             check_mt5_connection(**kwargs)
             strategy: MT5Strategy = self.strategy_cls(
-                symbol_list=self.symbols, mode="live", **kwargs
+                symbol_list=self.symbols, mode=TradingMode.LIVE, **kwargs
             )
         except Exception as e:
             self._print_exc(
@@ -357,24 +362,24 @@ class Mt5ExecutionEngine:
         }
 
         info = (
-            "SIGNAL = {signal}, SYMBOL={symbol}, STRATEGY={strategy}, "
+            "SIGNAL={signal}, SYMBOL={symbol}, STRATEGY={strategy}, "
             "TIMEFRAME={timeframe}, ACCOUNT={account}"
         ).format(**common_data)
 
         sigmsg = (
-            "SIGNAL = {signal},\n"
-            "SYMBOL = {symbol},\n"
-            "TYPE = {symbol_type},\n"
-            "DESCRIPTION = {description},\n"
-            "PRICE = {price},\n"
-            "STOPLIMIT = {stoplimit},\n"
-            "STRATEGY = {strategy},\n"
-            "TIMEFRAME = {timeframe},\n"
-            "BROKER = {broker},\n"
-            "TIMESTAMP = {timestamp}"
+            "SIGNAL={signal},\n"
+            "SYMBOL={symbol},\n"
+            "TYPE={symbol_type},\n"
+            "DESCRIPTION={description},\n"
+            "PRICE={price},\n"
+            "STOPLIMIT={stoplimit},\n"
+            "STRATEGY={strategy},\n"
+            "TIMEFRAME={timeframe},\n"
+            "BROKER={broker},\n"
+            "TIMESTAMP={timestamp}"
         ).format(
             **common_data,
-            symbol_type=account.get_symbol_type(symbol),
+            symbol_type=account.get_symbol_type(symbol).value,
             description=symbol_info.description,
             price=price,
             stoplimit=stoplimit,
@@ -382,7 +387,7 @@ class Mt5ExecutionEngine:
             timestamp=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
         )
 
-        msg_template = "SYMBOL = {symbol}, STRATEGY = {strategy}, ACCOUNT = {account}"
+        msg_template = "SYMBOL={symbol}, STRATEGY={strategy}, ACCOUNT={account}"
         msg = f"Sending {signal} Order ... " + msg_template.format(**common_data)
         tfmsg = "Time Frame Not completed !!! " + msg_template.format(**common_data)
         riskmsg = "Risk not allowed !!! " + msg_template.format(**common_data)
@@ -621,6 +626,12 @@ class Mt5ExecutionEngine:
     ):
         if self.notify:
             self._send_notification(sigmsg, symbol)
+        if not self.auto_trade:
+            auto_trade = input(
+                f"{sigmsg} \n\n Please enter Y/Yes to accept this order or N/No to reject it :"
+            )
+            if not auto_trade.upper().startswith("Y"):
+                return
         if not self._check_retcode(trade, "BMKT"):
             logger.info(msg)
             trade.open_buy_position(
@@ -638,6 +649,12 @@ class Mt5ExecutionEngine:
     ):
         if self.notify:
             self._send_notification(sigmsg, symbol)
+        if not self.auto_trade:
+            auto_trade = input(
+                f"{sigmsg} \n\n Please enter Y/Yes to accept this order or N/No to reject it :"
+            )
+            if not auto_trade.upper().startswith("Y"):
+                return
         if not self._check_retcode(trade, "SMKT"):
             logger.info(msg)
             trade.open_sell_position(