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

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,
@@ -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):

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(

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()
 
 

bbstrader/tseries.py

@@ -514,9 +514,8 @@ def get_corr(tickers: Union[List[str], Tuple[str, ...]], start: str, end: str) -
     >>> get_corr(['AAPL', 'MSFT', 'GOOG'], '2023-01-01', '2023-12-31')
     """
     # Download historical data
-    data = yf.download(tickers, start=start, end=end, multi_level_index=False)[
-        "Adj Close"
-    ]
+    data = yf.download(tickers, start=start, end=end, multi_level_index=False, auto_adjust=True)
+    data = data["Adj Close"] if "Adj Close" in data.columns else data["Close"]
 
     # Calculate correlation matrix
     correlation_matrix = data.corr()
@@ -685,8 +684,8 @@ def run_cadf_test(
         auto_adjust=True,
     )
     df = pd.DataFrame(index=_p0.index)
-    df[p0] = _p0["Adj Close"]
-    df[p1] = _p1["Adj Close"]
+    df[p0] = _p0["Close"]
+    df[p1] = _p1["Close"]
     df = df.dropna()
 
     # Calculate optimal hedge ratio "beta"
@@ -784,7 +783,7 @@ def run_hurst_test(symbol: str, start: str, end: str):
     print(f"\nHurst(GBM):  {_hurst(gbm)}")
     print(f"Hurst(MR):   {_hurst(mr)}")
     print(f"Hurst(TR):   {_hurst(tr)}")
-    print(f"Hurst({symbol}): {hurst(data['Adj Close'])}\n")
+    print(f"Hurst({symbol}): {hurst(data['Close'])}\n")
 
 
 def test_cointegration(ticker1, ticker2, start, end):
@@ -796,7 +795,7 @@ def test_cointegration(ticker1, ticker2, start, end):
         progress=False,
         multi_level_index=False,
         auto_adjust=True,
-    )["Adj Close"].dropna()
+    )["Close"].dropna()
 
     # Perform Johansen cointegration test
     result = coint_johansen(stock_data_pair, det_order=0, k_ar_diff=1)
@@ -947,8 +946,8 @@ def run_kalman_filter(
     )
 
     prices = pd.DataFrame(index=etf_df1.index)
-    prices[etfs[0]] = etf_df1["Adj Close"]
-    prices[etfs[1]] = etf_df2["Adj Close"]
+    prices[etfs[0]] = etf_df1["Close"]
+    prices[etfs[1]] = etf_df2["Close"]
 
     draw_date_coloured_scatterplot(etfs, prices)
     state_means, state_covs = calc_slope_intercept_kalman(etfs, prices)