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

bbstrader/models/nlp.py

@@ -1,14 +1,16 @@
+import contextlib
+import os
 import re
 import time
 from datetime import datetime
-from typing import Dict
+from typing import Dict, List, Tuple
 
 import dash
 import matplotlib.pyplot as plt
 import nltk
 import pandas as pd
 import plotly.express as px
-import spacy
+import en_core_web_sm
 from dash import dcc, html
 from dash.dependencies import Input, Output
 from nltk.corpus import stopwords
@@ -18,6 +20,7 @@ from vaderSentiment.vaderSentiment import SentimentIntensityAnalyzer
 
 from bbstrader.core.data import FinancialNews
 
+
 __all__ = [
     "TopicModeler",
     "SentimentAnalyzer",
@@ -331,9 +334,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 = en_core_web_sm.load()
+            self.nlp.disable_pipes("ner")
+        except OSError:
+            raise OSError(
+                "SpaCy model 'en_core_web_sm' not found. "
+                "Please install it using 'python -m spacy download en_core_web_sm'."
+            )
+        
     def preprocess_texts(self, texts: list[str]):
         def clean_doc(Doc):
             doc = []
@@ -382,22 +394,25 @@ class SentimentAnalyzer(object):
         - Downloads NLTK tokenization (`punkt`) and stopwords.
         - Loads the `en_core_web_sm` SpaCy model with Named Entity Recognition (NER) disabled.
         - Initializes VADER's SentimentIntensityAnalyzer for sentiment scoring.
+
+        Args:
+            use_spacy (bool): If True, uses SpaCy for lemmatization. Defaults to False.
         """
         nltk.download("punkt", quiet=True)
         nltk.download("stopwords", quiet=True)
 
+        self.analyzer = SentimentIntensityAnalyzer()
+        self._stopwords = set(stopwords.words("english"))
+
         try:
-            self.nlp = spacy.load("en_core_web_sm")
+            self.nlp = en_core_web_sm.load()
             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"
+            raise OSError(
+                "SpaCy model 'en_core_web_sm' not found. "
+                "Please install it using 'python -m spacy download en_core_web_sm'."
             )
-
-        self.analyzer = SentimentIntensityAnalyzer()
-        self._stopwords = set(stopwords.words("english"))
+        self.news = FinancialNews()
 
     def preprocess_text(self, text: str):
         """
@@ -415,13 +430,18 @@ class SentimentAnalyzer(object):
         Returns:
             str: The cleaned and lemmatized text.
         """
+        if not isinstance(text, str):
+            raise ValueError(f"{self.__class__.__name__}: preprocess_text expects a string, got {type(text)}")
         text = text.lower()
         text = re.sub(r"http\S+", "", text)
         text = re.sub(r"[^a-zA-Z\s]", "", text)
+
         words = word_tokenize(text)
         words = [word for word in words if word not in self._stopwords]
+
         doc = self.nlp(" ".join(words))
         words = [t.lemma_ for t in doc if t.lemma_ != "-PRON-"]
+
         return " ".join(words)
 
     def analyze_sentiment(self, texts, lexicon=None, textblob=False) -> float:
@@ -460,7 +480,7 @@ class SentimentAnalyzer(object):
         return avg_sentiment
 
     def get_sentiment_for_tickers(
-        self, tickers, lexicon=None, asset_type="stock", top_news=10, **kwargs
+        self, tickers: List[str] | List[Tuple[str, str]], lexicon=None, asset_type="stock", top_news=10, **kwargs
     ) -> Dict[str, float]:
         """
         Computes sentiment scores for a list of financial tickers based on news and social media data.
@@ -477,9 +497,18 @@ class SentimentAnalyzer(object):
         3. Computes an overall sentiment score using a weighted average approach.
 
         Args:
-            tickers (list of str): A list of stock, forex, crypto, or other asset tickers.
+            tickers (List[str] | List[Tuple[str, str]]): A list of asset tickers to analyze
+                - if using tuples, the first element is the ticker and the second is the asset type.
+                - if using a single string, the asset type must be specified or the default is "stock".
             lexicon (dict, optional): A custom sentiment lexicon to update VADER's default lexicon.
-            asset_type (str, optional): The type of asset (e.g., "stock", "forex", "crypto"). Defaults to "stock".
+            asset_type (str, optional): The type of asset, Defaults to "stock",                
+                supported types include:
+                - "stock": Stock symbols (e.g., AAPL, MSFT)
+                - "etf": Exchange-traded funds (e.g., SPY, QQQ)
+                - "future": Futures contracts (e.g., CL=F for crude oil)
+                - "forex": Forex pairs (e.g., EURUSD=X, USDJPY=X)
+                - "crypto": Cryptocurrency pairs (e.g., BTC-USD, ETH-USD)
+                - "index": Stock market indices (e.g., ^GSPC for S&P 500)
             top_news (int, optional): Number of news articles/posts to fetch per source. Defaults to 10.
             **kwargs: Additional parameters for API authentication and data retrieval, including:
                 - fmp_api (str): API key for Financial Modeling Prep.
@@ -490,63 +519,85 @@ class SentimentAnalyzer(object):
                              - Positive values indicate positive sentiment.
                              - Negative values indicate negative sentiment.
                              - Zero indicates neutral sentiment.
+        Notes:
+            The tickers names must follow yahoo finance conventions.
         """
         sentiment_results = {}
-        rd_params = ["client_id", "client_secret", "user_agent"]
-        news = FinancialNews()
-        for ticker in tickers:
-            # Collect data
-            sources = 0
-            yahoo_news = news.get_yahoo_finance_news(
-                ticker, asset_type=asset_type, n_news=top_news
-            )
-            google_news = news.get_google_finance_news(
-                ticker, asset_type=asset_type, n_news=top_news
-            )
-            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]:
-                try:
-                    source_news = fmp_news.get_news(
-                        ticker, source=source, symbol=ticker, **kwargs
+        rd_params = {"client_id", "client_secret", "user_agent"}
+        fm_params = {"start", "end", "page", "limit"}
+        with open(os.devnull, 'w') as devnull:
+            with contextlib.redirect_stdout(devnull), contextlib.redirect_stderr(devnull):
+                for asset in tickers:
+                    if isinstance(asset, tuple):
+                        ticker, asset_type = asset
+                    if asset_type not in [
+                        "stock",
+                        "etf",
+                        "future",
+                        "forex",
+                        "crypto",
+                        "index",
+                    ]:
+                        raise ValueError(
+                            f"Unsupported asset type '{asset_type}'. "
+                            "Supported types: stock, etf, future, forex, crypto, index."
+                        )
+                    # Collect data
+                    sources = 0
+                    yahoo_news = self.news.get_yahoo_finance_news(
+                        ticker, asset_type=asset_type, n_news=top_news
+                    )
+                    google_news = self.news.get_google_finance_news(
+                        ticker, asset_type=asset_type, n_news=top_news
+                    )
+                    reddit_posts = []
+                    if all(kwargs.get(rd) for rd in rd_params):
+                        reddit_posts = self.news.get_reddit_posts(
+                            ticker, n_posts=top_news, **{k: kwargs.get(k) for k in rd_params}
+                        )
+                    coindesk_news = self.news.get_coindesk_news(query=ticker, list_of_str=True)
+                    fmp_source_news = []
+                    if kwargs.get("fmp_api"):
+                        fmp_news = self.news.get_fmp_news(kwargs.get("fmp_api"))
+                        for src in ["articles"]:  # , "releases", asset_type]:
+                            try:
+                                source_news = fmp_news.get_news(
+                                    ticker, source=src, symbol=ticker, **{k: kwargs.get(k) for k in fm_params}
+                                )
+                                fmp_source_news += source_news
+                            except Exception:
+                                continue
+                    if any([len(s) > 0 for s in [yahoo_news, google_news]]):
+                        sources += 1
+                    for source in [reddit_posts, fmp_source_news, coindesk_news]:
+                        if len(source) > 0:
+                            sources += 1
+                    # Compute sentiment
+                    news_sentiment = self.analyze_sentiment(
+                        yahoo_news + google_news, lexicon=lexicon
+                    )
+                    reddit_sentiment = self.analyze_sentiment(
+                        reddit_posts, lexicon=lexicon, textblob=True
+                    )
+                    fmp_sentiment = self.analyze_sentiment(
+                        fmp_source_news, lexicon=lexicon, textblob=True
+                    )
+                    coindesk_sentiment = self.analyze_sentiment(
+                        coindesk_news, lexicon=lexicon, textblob=True
                     )
-                    fmp_source_news += source_news
-                except Exception:
-                    source_news = []
-            if any([len(s) > 0 for s in [yahoo_news, google_news]]):
-                sources += 1
-            for source in [reddit_posts, fmp_source_news, coindesk_news]:
-                if len(source) > 0:
-                    sources += 1
-            # Compute sentiment
-            news_sentiment = self.analyze_sentiment(
-                yahoo_news + google_news, lexicon=lexicon
-            )
-            reddit_sentiment = self.analyze_sentiment(
-                reddit_posts, lexicon=lexicon, textblob=True
-            )
-            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
-                    + coindesk_sentiment
-                ) / sources
-            else:
-                overall_sentiment = 0.0
-            sentiment_results[ticker] = overall_sentiment
+                    # Weighted average sentiment score
+                    if sources != 0:
+                        overall_sentiment = (
+                            news_sentiment
+                            + reddit_sentiment
+                            + fmp_sentiment
+                            + coindesk_sentiment
+                        ) / sources
+                    else:
+                        overall_sentiment = 0.0
+                    sentiment_results[ticker] = overall_sentiment
+                    time.sleep(1)  # To avoid hitting API rate limits
 
         return sentiment_results
 
@@ -641,8 +692,10 @@ class SentimentAnalyzer(object):
         bar and scatter plots. It fetches new sentiment data at specified intervals.
 
         Args:
-            tickers (list[str]):
-                A list of asset tickers (e.g., ["AAPL", "GOOGL", "TSLA"]).
+            tickers (List[str] | List[Tuple[str, str]]):
+                A list of financial asset tickers to analyze.
+                - If using tuples, the first element is the ticker and the second is the asset type.
+                - If using a single string, the asset type must be specified or defaults to "stock".
             asset_type (str, optional):
                 The type of financial asset ("stock", "forex", "crypto"). Defaults to "stock".
             lexicon (dict, optional):

bbstrader/trading/execution.py

@@ -1,7 +1,8 @@
 import multiprocessing as mp
+import sys
 import time
 from datetime import date, datetime
-from typing import Dict, List, Literal, Optional
+from typing import Callable, Dict, List, Literal, Optional
 
 import pandas as pd
 from loguru import logger as log
@@ -9,7 +10,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:
@@ -88,7 +89,7 @@ NON_EXEC_RETCODES = {
 log.add(
     f"{BBSTRADER_DIR}/logs/execution.log",
     enqueue=True,
-    level="INFO",
+    level="DEBUG",
     format="{time:YYYY-MM-DD HH:mm:ss} | {level} | {name} | {message}",
 )
 
@@ -171,9 +172,11 @@ class Mt5ExecutionEngine:
         self,
         symbol_list: List[str],
         trades_instances: Dict[str, Trade],
-        strategy_cls: Strategy,
+        strategy_cls: Strategy | MT5Strategy,
         /,
         mm: bool = True,
+        auto_trade: bool = True,
+        prompt_callback: Callable = None,
         optimizer: str = "equal",
         trail: bool = True,
         stop_trail: Optional[int] = None,
@@ -187,7 +190,7 @@ class Mt5ExecutionEngine:
         closing_pnl: Optional[float] = None,
         trading_days: Optional[List[str]] = None,
         comment: Optional[str] = None,
-        **kwargs
+        **kwargs,
     ):
         """
         Args:
@@ -197,6 +200,11 @@ 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.
+            prompt_callback : Callback function to prompt the user for confirmation.
+                This is useful when integrating with GUI applications.
             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 +247,8 @@ class Mt5ExecutionEngine:
         self.trades_instances = trades_instances
         self.strategy_cls = strategy_cls
         self.mm = mm
+        self.auto_trade = auto_trade
+        self.prompt_callback = prompt_callback
         self.optimizer = optimizer
         self.trail = trail
         self.stop_trail = stop_trail
@@ -262,11 +272,12 @@ class Mt5ExecutionEngine:
 
         self._initialize_engine(**kwargs)
         self.strategy = self._init_strategy(**kwargs)
+        self._running = True
 
     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 +311,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()
+            sys.exit(0)
         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 = {
@@ -327,11 +338,11 @@ class Mt5ExecutionEngine:
             expert_ids = [expert_ids]
         return expert_ids
 
-    def _init_strategy(self, **kwargs):
+    def _init_strategy(self, **kwargs) -> Strategy | MT5Strategy:
         try:
             check_mt5_connection(**kwargs)
-            strategy: MT5Strategy = self.strategy_cls(
-                symbol_list=self.symbols, mode="live", **kwargs
+            strategy = self.strategy_cls(
+                symbol_list=self.symbols, mode=TradingMode.LIVE, **kwargs
             )
         except Exception as e:
             self._print_exc(
@@ -357,32 +368,32 @@ 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),
-            description=symbol_info.description,
-            price=price,
+            symbol_type=account.get_symbol_type(symbol).value,
+            description=symbol_info.description if symbol_info else "N/A",
+            price=price if price else "MARKET",
             stoplimit=stoplimit,
             broker=account.broker.name,
             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)
@@ -515,7 +526,7 @@ class Mt5ExecutionEngine:
     def _daily_end_checks(self, today, closing, sessionmsg):
         self.strategy.perform_period_end_checks()
         if self.period_end_action == "break" and closing:
-            exit(0)
+            sys.exit(0)
         elif self.period_end_action == "sleep" and today != FRIDAY or not closing:
             self._sleep_over_night(sessionmsg)
         elif self.period_end_action == "sleep" and today == FRIDAY:
@@ -527,7 +538,7 @@ class Mt5ExecutionEngine:
         elif today == FRIDAY:
             self.strategy.perform_period_end_checks()
             if self.period_end_action == "break" and closing:
-                exit(0)
+                sys.exit(0)
             elif self.period_end_action == "sleep" or not closing:
                 self._sleep_over_weekend(sessionmsg)
 
@@ -536,7 +547,7 @@ class Mt5ExecutionEngine:
             self._sleep_over_night(sessionmsg)
         elif today == FRIDAY and self._is_month_ends() and closing:
             self.strategy.perform_period_end_checks()
-            exit(0)
+            sys.exit(0)
         else:
             self._sleep_over_weekend(sessionmsg)
 
@@ -616,11 +627,30 @@ class Mt5ExecutionEngine:
             )
             pass
 
+    def _handle_auto_trade(self, sigmsg, symbol) -> bool:
+        if self.notify:
+            self._send_notification(sigmsg, symbol)
+        if self.auto_trade:
+            return True
+        if not self.auto_trade:
+            prompt = f"{sigmsg} \n Enter Y/Yes to accept or N/No to reject this order : "
+            if self.prompt_callback is not None:
+                auto_trade = self.prompt_callback(prompt)
+            else:
+                auto_trade = input(prompt)
+            if not auto_trade.upper().startswith("Y"):
+                info = f"Order Rejected !!! SYMBOL={symbol}, STRATEGY={self.STRATEGY} , ACCOUNT={self.ACCOUNT}"
+                logger.info(info)
+                if self.notify:
+                    self._send_notification(info, symbol)
+                return False
+        return True
+
     def _open_buy(
         self, signal, symbol, id, trade: Trade, price, stoplimit, sigmsg, msg, comment
     ):
-        if self.notify:
-            self._send_notification(sigmsg, symbol)
+        if not self._handle_auto_trade(sigmsg, symbol):
+            return
         if not self._check_retcode(trade, "BMKT"):
             logger.info(msg)
             trade.open_buy_position(
@@ -636,8 +666,8 @@ class Mt5ExecutionEngine:
     def _open_sell(
         self, signal, symbol, id, trade: Trade, price, stoplimit, sigmsg, msg, comment
     ):
-        if self.notify:
-            self._send_notification(sigmsg, symbol)
+        if not self._handle_auto_trade(sigmsg, symbol):
+            return
         if not self._check_retcode(trade, "SMKT"):
             logger.info(msg)
             trade.open_sell_position(
@@ -888,7 +918,7 @@ class Mt5ExecutionEngine:
             pass
 
     def run(self):
-        while True:
+        while self._running:
             try:
                 check_mt5_connection(**self.kwargs)
                 positions_orders = self._check_positions_orders()
@@ -910,13 +940,21 @@ class Mt5ExecutionEngine:
                 self._sleep()
                 self._handle_period_end_actions(today)
             except KeyboardInterrupt:
-                logger.info("Stopping the Execution Engine ...")
+                logger.info(
+                    f"Stopping Execution Engine for {self.STRATEGY} on {self.ACCOUNT}"
+                )
                 break
             except Exception as e:
                 msg = f"Running Execution Engine, STRATEGY={self.STRATEGY} , ACCOUNT={self.ACCOUNT}"
                 self._print_exc(msg, e)
                 continue
 
+    def stop(self):
+        """Stops the execution engine."""
+        self._running = False
+        logger.info(f"Stopping Execution Engine for {self.STRATEGY} on {self.ACCOUNT}")
+        logger.info("Execution Engine stopped successfully.")
+
 
 def RunMt5Engine(account_id: str, **kwargs):
     """Starts an MT5 execution engine for a given account.

bbstrader/trading/strategies.py

@@ -31,6 +31,7 @@ from bbstrader.btengine.execution import MT5ExecutionHandler, SimExecutionHandle
 from bbstrader.btengine.strategy import Strategy
 from bbstrader.metatrader.account import Account
 from bbstrader.metatrader.rates import Rates
+from bbstrader.metatrader.trade import TradingMode
 from bbstrader.models.risk import build_hmm_models
 from bbstrader.tseries import ArimaGarchModel, KalmanFilterModel
 
@@ -73,7 +74,7 @@ class SMAStrategy(Strategy):
         bars: DataHandler = None,
         events: Queue = None,
         symbol_list: List[str] = None,
-        mode: Literal["backtest", "live"] = "backtest",
+        mode: TradingMode = TradingMode.BACKTEST,
         **kwargs,
     ):
         """
@@ -81,7 +82,7 @@ class SMAStrategy(Strategy):
             bars (DataHandler): A data handler object that provides market data.
             events (Queue): An event queue object where generated signals are placed.
             symbol_list (List[str]): A list of symbols to consider for trading.
-            mode (Literal['backtest', 'live']): The mode of operation for the strategy.
+            mode TradingMode: The mode of operation for the strategy.
             short_window (int, optional): The period for the short moving average.
             long_window (int, optional): The period for the long moving average.
             time_frame (str, optional): The time frame for the data.
@@ -196,13 +197,13 @@ class SMAStrategy(Strategy):
         return signals
 
     def calculate_signals(self, event=None):
-        if self.mode == "backtest" and event is not None:
+        if self.mode == TradingMode.BACKTEST and event is not None:
             if event.type == Events.MARKET:
                 signals = self.create_backtest_signals()
                 for signal in signals.values():
                     if signal is not None:
                         self.events.put(signal)
-        elif self.mode == "live":
+        elif self.mode == TradingMode.LIVE:
             signals = self.create_live_signals()
             return signals
 
@@ -238,7 +239,7 @@ class ArimaGarchStrategy(Strategy):
         bars: DataHandler = None,
         events: Queue = None,
         symbol_list: List[str] = None,
-        mode: Literal["backtest", "live"] = "backtest",
+        mode: TradingMode = TradingMode.BACKTEST,
         **kwargs,
     ):
         """
@@ -384,13 +385,13 @@ class ArimaGarchStrategy(Strategy):
         return signals
 
     def calculate_signals(self, event=None):
-        if self.mode == "backtest" and event is not None:
+        if self.mode == TradingMode.BACKTEST and event is not None:
             if event.type == Events.MARKET:
                 signals = self.create_backtest_signal()
                 for signal in signals.values():
                     if signal is not None:
                         self.events.put(signal)
-        elif self.mode == "live":
+        elif self.mode == TradingMode.LIVE:
             return self.create_live_signals()
 
 
@@ -408,7 +409,7 @@ class KalmanFilterStrategy(Strategy):
         bars: DataHandler = None,
         events: Queue = None,
         symbol_list: List[str] = None,
-        mode: Literal["backtest", "live"] = "backtest",
+        mode: TradingMode = TradingMode.BACKTEST,
         **kwargs,
     ):
         """
@@ -567,10 +568,10 @@ class KalmanFilterStrategy(Strategy):
         """
         Calculate the Kalman Filter strategy.
         """
-        if self.mode == "backtest" and event is not None:
+        if self.mode == TradingMode.BACKTEST and event is not None:
             if event.type == Events.MARKET:
                 self.calculate_backtest_signals()
-        elif self.mode == "live":
+        elif self.mode == TradingMode.LIVE:
             return self.calculate_live_signals()
 
 
@@ -589,7 +590,7 @@ class StockIndexSTBOTrading(Strategy):
         bars: DataHandler = None,
         events: Queue = None,
         symbol_list: List[str] = None,
-        mode: Literal["backtest", "live"] = "backtest",
+        mode: TradingMode = TradingMode.BACKTEST,
         **kwargs,
     ):
         """
@@ -632,7 +633,7 @@ class StockIndexSTBOTrading(Strategy):
         self.heightest_price = {index: None for index in symbols}
         self.lowerst_price = {index: None for index in symbols}
 
-        if self.mode == "backtest":
+        if self.mode == TradingMode.BACKTEST:
             self.qty = get_quantities(quantities, symbols)
             self.num_buys = {index: 0 for index in symbols}
             self.buy_prices = {index: [] for index in symbols}
@@ -751,10 +752,10 @@ class StockIndexSTBOTrading(Strategy):
                     self.buy_prices[index] = []
 
     def calculate_signals(self, event=None) -> Dict[str, Union[str, None]]:
-        if self.mode == "backtest" and event is not None:
+        if self.mode == TradingMode.BACKTEST and event is not None:
             if event.type == Events.MARKET:
                 self.calculate_backtest_signals()
-        elif self.mode == "live":
+        elif self.mode == TradingMode.LIVE:
             return self.calculate_live_signals()