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

bbstrader/trading/strategies.py

@@ -20,25 +20,17 @@ from datetime import datetime
 from queue import Queue
 from typing import Dict, List, Literal, Optional, Union
 
-import numpy as np
-import pandas as pd
-import yfinance as yf
-
 from bbstrader.btengine.backtest import BacktestEngine
 from bbstrader.btengine.data import DataHandler, MT5DataHandler, YFDataHandler
 from bbstrader.btengine.event import Events, SignalEvent
 from bbstrader.btengine.execution import MT5ExecutionHandler, SimExecutionHandler
 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
+
 
 __all__ = [
-    "SMAStrategy",
-    "ArimaGarchStrategy",
-    "KalmanFilterStrategy",
     "StockIndexSTBOTrading",
     "test_strategy",
     "get_quantities",
@@ -52,528 +44,6 @@ def get_quantities(quantities, symbol_list):
         return {symbol: quantities for symbol in symbol_list}
 
 
-class SMAStrategy(Strategy):
-    """
-    Carries out a basic Moving Average Crossover strategy bactesting with a
-    short/long simple weighted moving average. Default short/long
-    windows are 50/200 periods respectively and uses Hiden Markov Model
-    as risk Managment system for filteering signals.
-
-    The trading strategy for this class is exceedingly simple and is used to bettter
-    understood. The important issue is the risk management aspect (the Hmm model)
-
-    The Long-term trend following strategy is of the classic moving average crossover type.
-    The rules are simple:
-    -   At every bar calculate the 50-day and 200-day simple moving averages (SMA)
-    -   If the 50-day SMA exceeds the 200-day SMA and the strategy is not invested, then go long
-    -   If the 200-day SMA exceeds the 50-day SMA and the strategy is invested, then close the position
-    """
-
-    def __init__(
-        self,
-        bars: DataHandler = None,
-        events: Queue = None,
-        symbol_list: List[str] = None,
-        mode: TradingMode = TradingMode.BACKTEST,
-        **kwargs,
-    ):
-        """
-        Args:
-            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 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.
-            session_duration (float, optional): The duration of the trading session.
-            risk_window (int, optional): The window size for the risk model.
-            quantities (int, dict | optional): The default quantities of each asset to trade.
-        """
-        self.bars = bars
-        self.events = events
-        self.symbol_list = symbol_list or self.bars.symbol_list
-        self.mode = mode
-
-        self.kwargs = kwargs
-        self.short_window = kwargs.get("short_window", 50)
-        self.long_window = kwargs.get("long_window", 200)
-        self.tf = kwargs.get("time_frame", "D1")
-        self.qty = get_quantities(kwargs.get("quantities", 100), self.symbol_list)
-        self.sd = kwargs.get("session_duration", 23.0)
-        self.risk_models = build_hmm_models(self.symbol_list, **self.kwargs)
-        self.risk_window = kwargs.get("risk_window", self.long_window)
-        self.bought = self._calculate_initial_bought()
-
-    def _calculate_initial_bought(self):
-        bought = {}
-        for s in self.symbol_list:
-            bought[s] = "OUT"
-        return bought
-
-    def get_backtest_data(self):
-        symbol_data = {symbol: None for symbol in self.symbol_list}
-        for s in self.symbol_list:
-            bar_date = self.bars.get_latest_bar_datetime(s)
-            bars = self.bars.get_latest_bars_values(s, "adj_close", N=self.long_window)
-            returns_val = self.bars.get_latest_bars_values(
-                s, "returns", N=self.risk_window
-            )
-            if len(bars) >= self.long_window and len(returns_val) >= self.risk_window:
-                regime = self.risk_models[s].which_trade_allowed(returns_val)
-
-                short_sma = np.mean(bars[-self.short_window :])
-                long_sma = np.mean(bars[-self.long_window :])
-
-                symbol_data[s] = (short_sma, long_sma, regime, bar_date)
-        return symbol_data
-
-    def create_backtest_signals(self):
-        signals = {symbol: None for symbol in self.symbol_list}
-        symbol_data = self.get_backtest_data()
-        for s, data in symbol_data.items():
-            signal = None
-            if data is not None:
-                price = self.bars.get_latest_bar_value(s, "adj_close")
-                short_sma, long_sma, regime, bar_date = data
-                dt = bar_date
-                if regime == "LONG":
-                    # Bulliqh regime
-                    if short_sma < long_sma and self.bought[s] == "LONG":
-                        print(f"EXIT: {bar_date}")
-                        signal = SignalEvent(1, s, dt, "EXIT", price=price)
-                        self.bought[s] = "OUT"
-
-                    elif short_sma > long_sma and self.bought[s] == "OUT":
-                        print(f"LONG: {bar_date}")
-                        signal = SignalEvent(
-                            1, s, dt, "LONG", quantity=self.qty[s], price=price
-                        )
-                        self.bought[s] = "LONG"
-
-                elif regime == "SHORT":
-                    # Bearish regime
-                    if short_sma > long_sma and self.bought[s] == "SHORT":
-                        print(f"EXIT: {bar_date}")
-                        signal = SignalEvent(1, s, dt, "EXIT", price=price)
-                        self.bought[s] = "OUT"
-
-                    elif short_sma < long_sma and self.bought[s] == "OUT":
-                        print(f"SHORT: {bar_date}")
-                        signal = SignalEvent(
-                            1, s, dt, "SHORT", quantity=self.qty[s], price=price
-                        )
-                        self.bought[s] = "SHORT"
-                signals[s] = signal
-        return signals
-
-    def get_live_data(self):
-        symbol_data = {symbol: None for symbol in self.symbol_list}
-        for symbol in self.symbol_list:
-            sig_rate = Rates(symbol, self.tf, 0, self.risk_window + 2, **self.kwargs)
-            hmm_data = sig_rate.returns.values
-            prices = sig_rate.close.values
-            current_regime = self.risk_models[symbol].which_trade_allowed(hmm_data)
-            assert len(prices) >= self.long_window and len(hmm_data) >= self.risk_window
-            short_sma = np.mean(prices[-self.short_window :])
-            long_sma = np.mean(prices[-self.long_window :])
-            short_sma, long_sma, current_regime
-            symbol_data[symbol] = (short_sma, long_sma, current_regime)
-        return symbol_data
-
-    def create_live_signals(self):
-        signals = {symbol: None for symbol in self.symbol_list}
-        symbol_data = self.get_live_data()
-        for symbol, data in symbol_data.items():
-            signal = None
-            short_sma, long_sma, regime = data
-            if regime == "LONG":
-                if short_sma > long_sma:
-                    signal = "LONG"
-            elif regime == "SHORT":
-                if short_sma < long_sma:
-                    signal = "SHORT"
-            signals[symbol] = signal
-        return signals
-
-    def calculate_signals(self, event=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 == TradingMode.LIVE:
-            signals = self.create_live_signals()
-            return signals
-
-
-class ArimaGarchStrategy(Strategy):
-    """
-    The `ArimaGarchStrategy` class extends the `Strategy`
-    class to implement a backtesting framework for trading strategies based on
-    ARIMA-GARCH models, incorporating a Hidden Markov Model (HMM) for risk management.
-
-    Features
-    ========
-    - **ARIMA-GARCH Model**: Utilizes ARIMA for time series forecasting and GARCH for volatility forecasting, aimed at predicting market movements.
-
-    - **HMM Risk Management**: Employs a Hidden Markov Model to manage risks, determining safe trading regimes.
-
-    - **Event-Driven Backtesting**: Capable of simulating real-time trading conditions by processing market data and signals sequentially.
-
-    - **Live Trading**: Supports real-time trading by generating signals based on live ARIMA-GARCH predictions and HMM risk management.
-
-    Key Methods
-    ===========
-    - `get_backtest_data()`: Retrieves historical data for backtesting.
-    - `create_backtest_signal()`: Generates trading signals based on ARIMA-GARCH predictions and HMM risk management.
-    - `get_live_data()`: Retrieves live data for real-time trading.
-    - `create_live_signals()`: Generates trading signals based on live ARIMA-GARCH predictions and HMM risk management.
-    - `calculate_signals()`: Determines the trading signals based on the mode of operation (backtest or live).
-
-    """
-
-    def __init__(
-        self,
-        bars: DataHandler = None,
-        events: Queue = None,
-        symbol_list: List[str] = None,
-        mode: TradingMode = TradingMode.BACKTEST,
-        **kwargs,
-    ):
-        """
-        Args:
-            `bars`: A data handler object that provides market data.
-            `events`: An event queue object where generated signals are placed.
-            `symbol_list`: A list of symbols to consider for trading.
-            `mode`: The mode of operation for the strategy.
-            `arima_window`: The window size for rolling prediction in backtesting.
-            `time_frame`: The time frame for the data.
-            `quantities`: Quantity of each assets to trade.
-            `hmm_window`: Lookback period for HMM.
-        """
-        self.bars = bars
-        self.events = events
-        self.symbol_list = symbol_list or self.bars.symbol_list
-        self.mode = mode
-
-        self.qty = get_quantities(kwargs.get("quantities", 100), self.symbol_list)
-        self.arima_window = kwargs.get("arima_window", 252)
-        self.tf = kwargs.get("time_frame", "D1")
-        self.sd = kwargs.get("session_duration", 23.0)
-        self.risk_window = kwargs.get("hmm_window", 50)
-        self.risk_models = build_hmm_models(self.symbol_list, **kwargs)
-        self.arima_models = self._build_arch_models(**kwargs)
-
-        self.long_market = {s: False for s in self.symbol_list}
-        self.short_market = {s: False for s in self.symbol_list}
-
-    def _build_arch_models(self, **kwargs) -> Dict[str, ArimaGarchModel]:
-        arch_models = {symbol: None for symbol in self.symbol_list}
-        for symbol in self.symbol_list:
-            try:
-                rates = Rates(symbol, self.tf, 0)
-                data = rates.get_rates_from_pos()
-                assert data is not None, f"No data for {symbol}"
-            except AssertionError:
-                data = yf.download(symbol, start=kwargs.get("yf_start"))
-            arch = ArimaGarchModel(symbol, data, k=self.arima_window)
-            arch_models[symbol] = arch
-        return arch_models
-
-    def get_backtest_data(self):
-        symbol_data = {symbol: None for symbol in self.symbol_list}
-        for symbol in self.symbol_list:
-            M = self.arima_window
-            N = self.risk_window
-            dt = self.bars.get_latest_bar_datetime(symbol)
-            bars = self.bars.get_latest_bars_values(
-                symbol, "close", N=self.arima_window
-            )
-            returns = self.bars.get_latest_bars_values(
-                symbol, "returns", N=self.risk_window
-            )
-            df = pd.DataFrame()
-            df["Close"] = bars[-M:]
-            df = df.dropna()
-            arch_returns = self.arima_models[symbol].load_and_prepare_data(df)
-            data = arch_returns["diff_log_return"].iloc[-self.arima_window :]
-            if len(data) >= M and len(returns) >= N:
-                symbol_data[symbol] = (data, returns[-N:], dt)
-        return symbol_data
-
-    def create_backtest_signal(self):
-        signals = {symbol: None for symbol in self.symbol_list}
-        for symbol in self.symbol_list:
-            symbol_data = self.get_backtest_data()[symbol]
-            if symbol_data is not None:
-                data, returns, dt = symbol_data
-                signal = None
-                prediction = self.arima_models[symbol].get_prediction(data)
-                regime = self.risk_models[symbol].which_trade_allowed(returns)
-                price = self.bars.get_latest_bar_value(symbol, "adj_close")
-
-                # If we are short the market, check for an exit
-                if prediction > 0 and self.short_market[symbol]:
-                    signal = SignalEvent(1, symbol, dt, "EXIT", price=price)
-                    print(f"{dt}: EXIT SHORT")
-                    self.short_market[symbol] = False
-
-                # If we are long the market, check for an exit
-                elif prediction < 0 and self.long_market[symbol]:
-                    signal = SignalEvent(1, symbol, dt, "EXIT", price=price)
-                    print(f"{dt}: EXIT LONG")
-                    self.long_market[symbol] = False
-
-                if regime == "LONG":
-                    # If we are not in the market, go long
-                    if prediction > 0 and not self.long_market[symbol]:
-                        signal = SignalEvent(
-                            1,
-                            symbol,
-                            dt,
-                            "LONG",
-                            quantity=self.qty[symbol],
-                            price=price,
-                        )
-                        print(f"{dt}: LONG")
-                        self.long_market[symbol] = True
-
-                elif regime == "SHORT":
-                    # If we are not in the market, go short
-                    if prediction < 0 and not self.short_market[symbol]:
-                        signal = SignalEvent(
-                            1,
-                            symbol,
-                            dt,
-                            "SHORT",
-                            quantity=self.qty[symbol],
-                            price=price,
-                        )
-                        print(f"{dt}: SHORT")
-                        self.short_market[symbol] = True
-                signals[symbol] = signal
-        return signals
-
-    def get_live_data(self):
-        symbol_data = {symbol: None for symbol in self.symbol_list}
-        for symbol in self.symbol_list:
-            arch_data = Rates(symbol, self.tf, 0, self.arima_window)
-            rates = arch_data.get_rates_from_pos()
-            arch_returns = self.arima_models[symbol].load_and_prepare_data(rates)
-            window_data = arch_returns["diff_log_return"].iloc[-self.arima_window :]
-            hmm_returns = arch_data.returns.values[-self.risk_window :]
-            symbol_data[symbol] = (window_data, hmm_returns)
-        return symbol_data
-
-    def create_live_signals(self):
-        signals = {symbol: None for symbol in self.symbol_list}
-        data = self.get_live_data()
-        for symbol in self.symbol_list:
-            symbol_data = data[symbol]
-            if symbol_data is not None:
-                window_data, hmm_returns = symbol_data
-                prediction = self.arima_models[symbol].get_prediction(window_data)
-                regime = self.risk_models[symbol].which_trade_allowed(hmm_returns)
-                if regime == "LONG":
-                    if prediction > 0:
-                        signals[symbol] = "LONG"
-                elif regime == "SHORT":
-                    if prediction < 0:
-                        signals[symbol] = "SHORT"
-        return signals
-
-    def calculate_signals(self, event=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 == TradingMode.LIVE:
-            return self.create_live_signals()
-
-
-class KalmanFilterStrategy(Strategy):
-    """
-    The `KalmanFilterStrategy` class implements a backtesting framework for a
-    [pairs trading](https://en.wikipedia.org/wiki/Pairs_trade) strategy using
-    Kalman Filter for signals and Hidden Markov Models (HMM) for risk management.
-    This document outlines the structure and usage of the `KalmanFilterStrategy`,
-    including initialization parameters, main functions, and an example of how to run a backtest.
-    """
-
-    def __init__(
-        self,
-        bars: DataHandler = None,
-        events: Queue = None,
-        symbol_list: List[str] = None,
-        mode: TradingMode = TradingMode.BACKTEST,
-        **kwargs,
-    ):
-        """
-        Args:
-            `bars`: `DataHandler` for market data handling.
-            `events`: A queue for managing events.
-            `symbol_list`: List of ticker symbols for the pairs trading strategy.
-            `mode`: Mode of operation for the strategy.
-            kwargs : Additional keyword arguments including
-                - `quantity`: Quantity of assets to trade. Default is 100.
-                - `hmm_window`: Window size for calculating returns for the HMM. Default is 50.
-                - `hmm_tiker`: Ticker symbol used by the HMM for risk management.
-                - `time_frame`: Time frame for the data. Default is 'D1'.
-                - `session_duration`: Duration of the trading session. Default is 6.5.
-        """
-        self.bars = bars
-        self.events_queue = events
-        self.symbol_list = symbol_list or self.bars.symbol_list
-        self.mode = mode
-
-        self.hmm_tiker = kwargs.get("hmm_tiker")
-        self._assert_tikers()
-        self.account = Account(**kwargs)
-        self.hmm_window = kwargs.get("hmm_window", 50)
-        self.qty = kwargs.get("quantity", 100)
-        self.tf = kwargs.get("time_frame", "D1")
-        self.sd = kwargs.get("session_duration", 6.5)
-
-        self.risk_model = build_hmm_models(self.symbol_list, **kwargs)
-        self.kl_model = KalmanFilterModel(self.tickers, **kwargs)
-
-        self.long_market = False
-        self.short_market = False
-
-    def _assert_tikers(self):
-        if self.symbol_list is None or len(self.symbol_list) != 2:
-            raise ValueError("A list of 2 Tickers must be provide for this strategy")
-        self.tickers = self.symbol_list
-        if self.hmm_tiker is None:
-            raise ValueError(
-                "You need to provide a ticker used by the HMM for risk management"
-            )
-
-    def calculate_btxy(self, etqt, regime, dt):
-        # Make sure there is no position open
-        if etqt is None:
-            return
-        et, sqrt_Qt = etqt
-        theta = self.kl_model.theta
-        p1 = self.bars.get_latest_bar_value(self.tickers[1], "adj_close")
-        p0 = self.bars.get_latest_bar_value(self.tickers[0], "adj_close")
-        if et >= -sqrt_Qt and self.long_market:
-            print("CLOSING LONG: %s" % dt)
-            y_signal = SignalEvent(1, self.tickers[1], dt, "EXIT", price=p1)
-            x_signal = SignalEvent(1, self.tickers[0], dt, "EXIT", price=p0)
-            self.events_queue.put(y_signal)
-            self.events_queue.put(x_signal)
-            self.long_market = False
-
-        elif et <= sqrt_Qt and self.short_market:
-            print("CLOSING SHORT: %s" % dt)
-            y_signal = SignalEvent(1, self.tickers[1], dt, "EXIT", price=p1)
-            x_signal = SignalEvent(1, self.tickers[0], dt, "EXIT", price=p0)
-            self.events_queue.put(y_signal)
-            self.events_queue.put(x_signal)
-            self.short_market = False
-
-        # Long Entry
-        if regime == "LONG":
-            if et <= -sqrt_Qt and not self.long_market:
-                print("LONG: %s" % dt)
-                y_signal = SignalEvent(
-                    1, self.tickers[1], dt, "LONG", self.qty, 1.0, price=p1
-                )
-                x_signal = SignalEvent(
-                    1, self.tickers[0], dt, "SHORT", self.qty, theta[0], price=p0
-                )
-                self.events_queue.put(y_signal)
-                self.events_queue.put(x_signal)
-                self.long_market = True
-
-        # Short Entry
-        elif regime == "SHORT":
-            if et >= sqrt_Qt and not self.short_market:
-                print("SHORT: %s" % dt)
-                y_signal = SignalEvent(
-                    1, self.tickers[1], dt, "SHORT", self.qty, 1.0, price=p1
-                )
-                x_signal = SignalEvent(
-                    1, self.tickers[0], "LONG", self.qty, theta[0], price=p0
-                )
-                self.events_queue.put(y_signal)
-                self.events_queue.put(x_signal)
-                self.short_market = True
-
-    def calculate_livexy(self):
-        signals = {symbol: None for symbol in self.symbol_list}
-        p0_price = self.account.get_tick_info(self.tickers[0]).ask
-        p1_price = self.account.get_tick_info(self.tickers[1]).ask
-        prices = np.array([p0_price, p1_price])
-        et_std = self.kl_model.calculate_etqt(prices)
-        if et_std is not None:
-            et, std = et_std
-            y_signal = None
-            x_signal = None
-
-            if et >= -std or et <= std:
-                y_signal = "EXIT"
-                x_signal = "EXIT"
-
-            if et <= -std:
-                y_signal = "LONG"
-                x_signal = "SHORT"
-
-            if et >= std:
-                y_signal = "SHORT"
-                x_signal = "LONG"
-
-            signals[self.tickers[0]] = x_signal
-            signals[self.tickers[1]] = y_signal
-        return signals
-
-    def calculate_backtest_signals(self):
-        p0, p1 = self.tickers[0], self.tickers[1]
-        dt = self.bars.get_latest_bar_datetime(p0)
-        x = self.bars.get_latest_bar_value(p0, "close")
-        y = self.bars.get_latest_bar_value(p1, "close")
-        returns = self.bars.get_latest_bars_values(
-            self.hmm_tiker, "returns", N=self.hmm_window
-        )
-        latest_prices = np.array([-1.0, -1.0])
-        if len(returns) >= self.hmm_window:
-            latest_prices[0] = x
-            latest_prices[1] = y
-            et_qt = self.kl_model.calculate_etqt(latest_prices)
-            regime = self.risk_model[self.hmm_tiker].which_trade_allowed(returns)
-            self.calculate_btxy(et_qt, regime, dt)
-
-    def calculate_live_signals(self):
-        # Data Retrieval
-        signals = {symbol: None for symbol in self.symbol_list}
-        initial_signals = self.calculate_livexy()
-        hmm_data = Rates(self.hmm_ticker, self.tf, 0, self.hmm_window)
-        returns = hmm_data.returns.values
-        current_regime = self.risk_model[self.hmm_tiker].which_trade_allowed(returns)
-        for symbol in self.symbol_list:
-            if symbol in initial_signals:
-                signal = initial_signals[symbol]
-                if signal == "LONG" and current_regime == "LONG":
-                    signals[symbol] = "LONG"
-                elif signal == "SHORT" and current_regime == "SHORT":
-                    signals[symbol] = "SHORT"
-        return signals
-
-    def calculate_signals(self, event=None):
-        """
-        Calculate the Kalman Filter strategy.
-        """
-        if self.mode == TradingMode.BACKTEST and event is not None:
-            if event.type == Events.MARKET:
-                self.calculate_backtest_signals()
-        elif self.mode == TradingMode.LIVE:
-            return self.calculate_live_signals()
-
 
 class StockIndexSTBOTrading(Strategy):
     """
@@ -778,50 +248,6 @@ def _run_backtest(strategy_name: str, capital: float, symbol_list: list, kwargs:
     engine.simulate_trading()
 
 
-def _run_arch_backtest(capital: float = 100000.0, quantity: int = 1000):
-    hmm_data = yf.download("^GSPC", start="1990-01-01", end="2009-12-31")
-    kwargs = {
-        "quantity": quantity,
-        "yf_start": "2010-01-04",
-        "hmm_data": hmm_data,
-        "backtester_class": ArimaGarchStrategy,
-        "data_handler": YFDataHandler,
-    }
-    _run_backtest("ARIMA+GARCH & HMM", capital, ["^GSPC"], kwargs)
-
-
-def _run_kf_backtest(capital: float = 100000.0, quantity: int = 2000):
-    symbol_list = ["IEI", "TLT"]
-    tlt = yf.download("TLT", end="2008-07-09")
-    iei = yf.download("IEI", end="2008-07-09")
-    kwargs = {
-        "quantity": quantity,
-        "yf_start": "2009-08-03",
-        "hmm_data": {"IEI": iei, "TLT": tlt},
-        "hmm_tiker": "TLT",
-        "session_duration": 6.5,
-        "backtester_class": KalmanFilterStrategy,
-        "data_handler": YFDataHandler,
-    }
-    _run_backtest("Kalman Filter & HMM", capital, symbol_list, kwargs)
-
-
-def _run_sma_backtest(capital: float = 100000.0, quantity: int = 1):
-    spx_data = yf.download("^GSPC", start="1990-01-01", end="2009-12-31")
-    kwargs = {
-        "quantities": quantity,
-        "hmm_end": "2009-12-31",
-        "yf_start": "2010-01-04",
-        "hmm_data": spx_data,
-        "mt5_start": datetime(2010, 1, 1),
-        "mt5_end": datetime(2023, 1, 1),
-        "backtester_class": SMAStrategy,
-        "data_handler": MT5DataHandler,
-        "exc_handler": MT5ExecutionHandler,
-    }
-    _run_backtest("SMA & HMM", capital, ["[SP500]"], kwargs)
-
-
 def _run_sistbo_backtest(capital: float = 100000.0, quantity: int = None):
     ndx = "[NQ100]"
     spx = "[SP500]"
@@ -845,16 +271,8 @@ def _run_sistbo_backtest(capital: float = 100000.0, quantity: int = None):
     _run_backtest("Stock Index Short Term Buy Only ", capital, symbol_list, kwargs)
 
 
-_BACKTESTS = {
-    "sma": _run_sma_backtest,
-    "klf": _run_kf_backtest,
-    "arch": _run_arch_backtest,
-    "sistbo": _run_sistbo_backtest,
-}
-
-
 def test_strategy(
-    strategy: Literal["sma", "klf", "arch", "sistbo"] = "sma",
+    strategy: Literal["sistbo"] = "sistbo",
     quantity: Optional[int] = 100,
 ):
     """
@@ -862,14 +280,13 @@ def test_strategy(
 
     Args:
         strategy : The strategy to use in test mode. Default is `sma`.
-            - `sma` Execute `SMAStrategy`, for more detail see this class documentation.
-            - `klf` Execute `KalmanFilterStrategy`, for more detail see this class documentation.
-            - `arch` Execute `ArimaGarchStrategy`, for more detail see this class documentation.
             - `sistbo` Execute `StockIndexSTBOTrading`, for more detail see this class documentation.
         quantity : The quantity of assets to be used in the test backtest. Default is 1000.
 
     """
-    if strategy in _BACKTESTS:
-        _BACKTESTS[strategy](quantity=quantity)
-    else:
-        raise ValueError(f"Unknown strategy: {strategy}")
+    if strategy != "sistbo":
+        raise ValueError(
+            "Only 'sistbo' strategy is available for testing at the moment."
+        )
+    _run_sistbo_backtest(quantity=quantity)
+