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

bbstrader/tseries.py

@@ -1,36 +1,24 @@
 """
 The `tseries` module is a designed for conducting
-advanced time series analysis in financial markets.
-It leverages statistical models and algorithms to perform
-tasks such as cointegration testing, volatility modeling,
-and filter-based estimation to assist in trading strategy development,
-market analysis, and financial data exploration.
+some simple time series analysis in financial markets.
 """
 
 import pprint
 import warnings
-from itertools import combinations
 from typing import List, Tuple, Union
 
 import matplotlib.pyplot as plt
 import numpy as np
 import pandas as pd
-import pmdarima as pm
 import seaborn as sns
 import statsmodels.api as sm
 import statsmodels.tsa.stattools as ts
 import yfinance as yf
-from arch import arch_model
 from filterpy.kalman import KalmanFilter
-from hurst import compute_Hc
 from pykalman import KalmanFilter as PyKalmanFilter
-from scipy.optimize import minimize
 from sklearn.linear_model import LogisticRegressionCV
 from sklearn.model_selection import GridSearchCV
 from sklearn.tree import DecisionTreeClassifier
-from statsmodels.graphics.tsaplots import plot_acf
-from statsmodels.stats.diagnostic import acorr_ljungbox
-from statsmodels.tsa.arima.model import ARIMA
 from statsmodels.tsa.stattools import adfuller, coint
 from statsmodels.tsa.vector_ar.var_model import VAR
 from statsmodels.tsa.vector_ar.vecm import coint_johansen
@@ -40,19 +28,8 @@ warnings.filterwarnings("ignore")
 
 
 __all__ = [
-    "load_and_prepare_data",
-    "fit_best_arima",
-    "fit_garch",
-    "predict_next_return",
-    "get_prediction",
-    "get_corr",
-    "run_cadf_test",
-    "run_hurst_test",
-    "run_coint_test",
     "run_kalman_filter",
-    "ArimaGarchModel",
     "KalmanFilterModel",
-    "OrnsteinUhlenbeck",
     "remove_correlated_assets",
     "check_stationarity",
     "remove_stationary_assets",
@@ -70,458 +47,54 @@ __all__ = [
 # *******************************************
 
 
-def load_and_prepare_data(df: pd.DataFrame):
-    """
-    Prepares financial time series data for analysis.
-
-    This function takes a pandas DataFrame containing financial data,
-    calculates logarithmic returns, and the first difference
-    of these logarithmic returns. It handles missing values
-    by filling them with zeros.
-
-    Args:
-        df (pd.DataFrame): DataFrame containing at least
-            a `Close` column with closing prices of a financial asset.
-
-    Returns:
-        pd.DataFrame: DataFrame with additional
-            columns for logarithmic returns (`log_return`)
-            and the first difference of logarithmic returns (`diff_log_return`),
-            with `NaN` values filled with `0`.
-    """
-    # Load data
-    data = df.copy()
-    # Calculate logarithmic returns
-    data["log_return"] = np.log(data["Close"] / data["Close"].shift(1))
-    # Differencing if necessary
-    data["diff_log_return"] = data["log_return"].diff()
-    # Drop NaN values
-    data.fillna(0, inplace=True)
-    return data
-
-
-def fit_best_arima(window_data: Union[pd.Series, np.ndarray]):
-    """
-    Identifies and fits the best `ARIMA` model
-    based on the Akaike Information Criterion `(AIC)`.
-
-    Iterates through different combinations of `p` and `q`
-    parameters (within specified ranges) for the ARIMA model,
-    fits them to the provided data, and selects the combination
-    with the lowest `AIC` value.
+def load_and_prepare_data(df):
+    warnings.warn("`load_and_prepare_data` is removed.", DeprecationWarning)
 
-    Args:
-        window_data (pd.Series or np.ndarray):
-            Time series data to fit the `ARIMA` model on.
 
-    Returns:
-        ARIMA result object: The fitted `ARIMA` model with the lowest `AIC`.
-    """
-    if isinstance(window_data, pd.Series):
-        window_data = window_data.values
-
-    window_data = window_data[~(np.isnan(window_data) | np.isinf(window_data))]
-    # Fit ARIMA model with best parameters
-    model = pm.auto_arima(
-        window_data,
-        start_p=1,
-        start_q=1,
-        max_p=6,
-        max_q=6,
-        seasonal=False,
-        stepwise=True,
+def fit_best_arima(window_data):
+    warnings.warn(
+        "`fit_best_arima` is deprecated, use `pmdarima.auto_arima` instead.",
+        DeprecationWarning,
     )
-    final_order = model.order
-    from arch.utility.exceptions import ConvergenceWarning as ArchWarning
-    from statsmodels.tools.sm_exceptions import ConvergenceWarning as StatsWarning
-
-    with warnings.catch_warnings():
-        warnings.filterwarnings("ignore", category=StatsWarning, module="statsmodels")
-        warnings.filterwarnings("ignore", category=ArchWarning, module="arch")
-        try:
-            best_arima_model = ARIMA(
-                window_data + 1e-5, order=final_order, missing="drop"
-            ).fit()
-            return best_arima_model
-        except np.linalg.LinAlgError:
-            # Catch specific linear algebra errors
-            print("LinAlgError occurred, skipping this data point.")
-            return None
-        except Exception as e:
-            # Catch any other unexpected errors and log them
-            print(f"An error occurred: {e}")
-            return None
-
-
-def fit_garch(window_data: Union[pd.Series, np.ndarray]):
-    """
-    Fits an `ARIMA` model to the data to get residuals,
-    then fits a `GARCH(1,1)` model on these residuals.
-
-    Utilizes the residuals from the best `ARIMA` model fit to
-    then model volatility using a `GARCH(1,1)` model.
 
-    Args:
-        window_data (pd.Series or np.ndarray):
-            Time series data for which to fit the `ARIMA` and `GARCH` models.
 
-    Returns:
-        tuple: A tuple containing the `ARIMA` result
-            object and the `GARCH` result object.
-    """
-    arima_result = fit_best_arima(window_data)
-    if arima_result is None:
-        return None, None
-    resid = np.asarray(arima_result.resid)
-    resid = resid[~(np.isnan(resid) | np.isinf(resid))]
-    garch_model = arch_model(resid, p=1, q=1, rescale=False)
-    garch_result = garch_model.fit(disp="off")
-    return arima_result, garch_result
+def fit_garch(window_data):
+    warnings.warn(
+        "`fit_garch` is deprecated, use `arch.arch_model` instead.",
+        DeprecationWarning,
+    )
 
 
 def predict_next_return(arima_result, garch_result):
-    """
-    Predicts the next return value using fitted `ARIMA` and `GARCH` models.
-
-    Combines the next period forecast from the `ARIMA` model
-    with the next period volatility forecast from the `GARCH` model
-    to predict the next return value.
-
-    Args:
-        arima_result (ARIMA result object): The fitted `ARIMA` model result.
-        garch_result (ARCH result object): The fitted `GARCH` model result.
-
-    Returns:
-        float: The predicted next return, adjusted for predicted volatility.
-    """
-    if arima_result is None or garch_result is None:
-        return 0
-    # Predict next value with ARIMA
-    arima_pred = arima_result.forecast(steps=1)
-    # Predict next volatility with GARCH
-    garch_pred = garch_result.forecast(horizon=1)
-    next_volatility = garch_pred.variance.iloc[-1, 0]
-
-    # Combine predictions (return + volatility)
-    if not isinstance(arima_pred, np.ndarray):
-        pred = arima_pred.values[0]
-    else:
-        pred = arima_pred[0]
-    return pred + next_volatility
-
-
-def get_prediction(window_data: Union[pd.Series, np.ndarray]):
-    """
-    Orchestrator function to get the next period's return prediction.
-
-    This function ties together the process of fitting
-    both `ARIMA` and `GARCH` models on the provided data
-    and then predicting the next period's return using these models.
+    warnings.warn(
+        "`predict_next_return` is deprecated.",
+        DeprecationWarning,
+    )
 
-    Args:
-        window_data (Union[pd.Series , np.ndarray]):
-            Time series data to fit the models and predict the next return.
 
-    Returns
-        float: Predicted next return value.
-    """
-    arima_result, garch_result = fit_garch(window_data)
-    prediction = predict_next_return(arima_result, garch_result)
-    return prediction
+def get_prediction(window_data):
+    warnings.warn(
+        "`get_prediction` is deprecated, ",
+        DeprecationWarning,
+    )
 
 
 class ArimaGarchModel:
-    """
-    This class implements a time serie model
-    that combines `ARIMA (AutoRegressive Integrated Moving Average)`
-    and `GARCH (Generalized Autoregressive Conditional Heteroskedasticity)` models
-    to predict future returns based on historical price data.
-
-    The model is implemented in the following steps:
-    1. Data Preparation: Load and prepare the historical price data.
-    2. Modeling: Fit the ARIMA model to the data and then fit the GARCH model to the residuals.
-    3. Prediction: Predict the next return using the ARIMA model and the next volatility using the GARCH model.
-    4. Trading Strategy: Execute the trading strategy based on the predictions.
-    5. Vectorized Backtesting: Backtest the trading strategy using the historical data.
-
-    Exemple:
-        >>> import yfinance as yf
-        >>> from bbstrader.tseries import ArimaGarchModel
-        >>> from bbstrader.tseries import load_and_prepare_data
-
-        >>> if __name__ == '__main__':
-        >>>     # ARCH SPY Vectorize Backtest
-        >>>     k = 252
-        >>>     data = yf.download("SPY", start="2010-01-02", end="2015-12-31")
-        >>>     arch = ArimaGarchModel("SPY", data, k=k)
-        >>>     df = load_and_prepare_data(data)
-        >>>     arch.show_arima_garch_results(df['diff_log_return'].values[-k:])
-        >>>     arch.backtest_strategy()
-    """
-
     def __init__(self, symbol, data, k: int = 252):
-        """
-        Initializes the ArimaGarchStrategy class.
-
-        Args:
-            symbol (str): The ticker symbol for the financial instrument.
-            data (pd.DataFrame): `The raw dataset containing at least the 'Close' prices`.
-            k (int): The window size for rolling prediction in backtesting.
-        """
-        self.symbol = symbol
-        self.data = self.load_and_prepare_data(data)
-        self.k = k
-
-    # Step 1: Data Preparation
-    def load_and_prepare_data(self, df):
-        """
-        Prepares the dataset by calculating logarithmic returns
-            and differencing if necessary.
-
-        Args:
-            df (pd.DataFrame): `The raw dataset containing at least the 'Close' prices`.
-
-        Returns:
-            pd.DataFrame: The dataset with additional columns
-                for log returns and differenced log returns.
-        """
-        return load_and_prepare_data(df)
-
-    # Step 2: Modeling (ARIMA + GARCH)
-    def fit_best_arima(self, window_data):
-        """
-        Fits the ARIMA model to the provided window of data,
-            selecting the best model based on AIC.
-
-        Args:
-            window_data (np.array): The dataset for a specific window period.
-
-        Returns:
-            ARIMA model: The best fitted ARIMA model based on AIC.
-        """
-        return fit_best_arima(window_data)
-
-    def fit_garch(self, window_data):
-        """
-        Fits the GARCH model to the residuals of the best ARIMA model.
-
-        Args:
-            window_data (np.array): The dataset for a specific window period.
-
-        Returns:
-            tuple: Contains the ARIMA result and GARCH result.
-        """
-        return fit_garch(window_data)
-
-    def show_arima_garch_results(self, window_data, acf=True, test_resid=True):
-        """
-        Displays the ARIMA and GARCH model results, including plotting
-        ACF of residuals and conducting , Box-Pierce and Ljung-Box tests.
-
-        Args:
-            window_data (np.array): The dataset for a specific window period.
-            acf (bool, optional): If True, plot the ACF of residuals. Defaults to True.
-
-            test_resid (bool, optional):
-                If True, conduct Box-Pierce and Ljung-Box tests on residuals. Defaults to True.
-        """
-        arima_result = self.fit_best_arima(window_data)
-        resid = np.asarray(arima_result.resid)
-        resid = resid[~(np.isnan(resid) | np.isinf(resid))]
-        garch_model = arch_model(resid, p=1, q=1, rescale=False)
-        garch_result = garch_model.fit(disp="off")
-        residuals = garch_result.resid
-
-        # TODO : Plot the ACF of the residuals
-        if acf:
-            fig = plt.figure(figsize=(12, 8))
-            # Plot the ACF of ARIMA residuals
-            ax1 = fig.add_subplot(211, ylabel="ACF")
-            plot_acf(resid, alpha=0.05, ax=ax1, title="ACF of ARIMA Residuals")
-            ax1.set_xlabel("Lags")
-            ax1.grid(True)
-
-            # Plot the ACF of GARCH residuals on the same axes
-            ax2 = fig.add_subplot(212, ylabel="ACF")
-            plot_acf(residuals, alpha=0.05, ax=ax2, title="ACF of GARCH  Residuals")
-            ax2.set_xlabel("Lags")
-            ax2.grid(True)
-
-            # Plot the figure
-            plt.tight_layout()
-            plt.show()
-
-        # TODO : Conduct Box-Pierce and Ljung-Box Tests of the residuals
-        if test_resid:
-            print(arima_result.summary())
-            print(garch_result.summary())
-            bp_test = acorr_ljungbox(resid, return_df=True)
-            print("Box-Pierce and Ljung-Box Tests Results  for ARIMA:\n", bp_test)
-
-    # Step 3: Prediction
-    def predict_next_return(self, arima_result, garch_result):
-        """
-        Predicts the next return using the ARIMA model
-            and the next volatility using the GARCH model.
-
-        Args:
-            arima_result (ARIMA model): The ARIMA model result.
-            garch_result (GARCH model): The GARCH model result.
-
-        Returns:
-            float: The predicted next return.
-        """
-        return predict_next_return(arima_result, garch_result)
-
-    def get_prediction(self, window_data):
-        """
-        Generates a prediction for the next return based on a window of data.
-
-        Args:
-            window_data (np.array): The dataset for a specific window period.
-
-        Returns:
-            float: The predicted next return.
-        """
-        return get_prediction(window_data)
-
-    def calculate_signals(self, window_data):
-        """
-        Calculates the trading signal based on the prediction.
-
-        Args:
-            window_data (np.array): The dataset for a specific window period.
-
-        Returns:
-            str: The trading signal ('LONG', 'SHORT', or None).
-        """
-        prediction = self.get_prediction(window_data)
-        if prediction > 0:
-            signal = "LONG"
-        elif prediction < 0:
-            signal = "SHORT"
-        else:
-            signal = None
-        return signal
-
-    # Step 4: Trading Strategy
-
-    def execute_trading_strategy(self, predictions):
-        """
-        Executes the trading strategy based on a list
-        of predictions, determining positions to take.
-
-        Args:
-            predictions (list): A list of predicted returns.
-
-        Returns:
-            list: A list of positions (1 for 'LONG', -1 for 'SHORT', 0 for 'HOLD').
-        """
-        positions = []  # Long if 1, Short if -1
-        previous_position = 0  # Initial position
-        for prediction in predictions:
-            if prediction > 0:
-                current_position = 1  # Long
-            elif prediction < 0:
-                current_position = -1  # Short
-            else:
-                current_position = previous_position  # Hold previous position
-            positions.append(current_position)
-            previous_position = current_position
-
-        return positions
-
-    # Step 5: Vectorized Backtesting
-    def generate_predictions(self):
-        """
-        Generator that yields predictions one by one.
-        """
-        data = self.data
-        window_size = self.k
-        for i in range(window_size, len(data)):
-            print(
-                f"Processing window {i - window_size + 1}/{len(data) - window_size}..."
-            )
-            window_data = data["diff_log_return"].iloc[i - window_size : i]
-            next_return = self.get_prediction(window_data)
-            yield next_return
-
-    def backtest_strategy(self):
-        """
-        Performs a backtest of the strategy over
-        the entire dataset, plotting cumulative returns.
-        """
-        data = self.data
-        window_size = self.k
-        print(
-            f"Starting backtesting for {self.symbol}\n"
-            f"Window size {window_size}.\n"
-            f"Total iterations: {len(data) - window_size}.\n"
+        warnings.warn(
+            "`ArimaGarchModel` is deprecated, use `pmdarima.auto_arima` and `arch.arch_model` instead.",
+            DeprecationWarning,
         )
-        predictions_generator = self.generate_predictions()
-
-        positions = self.execute_trading_strategy(predictions_generator)
-
-        strategy_returns = (
-            np.array(positions[:-1]) * data["log_return"].iloc[window_size + 1 :].values
-        )
-        buy_and_hold = data["log_return"].iloc[window_size + 1 :].values
-        buy_and_hold_returns = np.cumsum(buy_and_hold)
-        cumulative_returns = np.cumsum(strategy_returns)
-        dates = data.index[window_size + 1 :]
-        self.plot_cumulative_returns(cumulative_returns, buy_and_hold_returns, dates)
-
-        print("\nBacktesting completed !!")
-
-    # Function to plot the cumulative returns
-    def plot_cumulative_returns(self, strategy_returns, buy_and_hold_returns, dates):
-        """
-        Plots the cumulative returns of the ARIMA+GARCH strategy against
-            a buy-and-hold strategy.
-
-        Args:
-            strategy_returns (np.array): Cumulative returns from the strategy.
-            buy_and_hold_returns (np.array): Cumulative returns from a buy-and-hold strategy.
-            dates (pd.Index): The dates corresponding to the returns.
-        """
-        plt.figure(figsize=(14, 7))
-        plt.plot(dates, strategy_returns, label="ARIMA+GARCH ", color="blue")
-        plt.plot(dates, buy_and_hold_returns, label="Buy & Hold", color="red")
-        plt.xlabel("Time")
-        plt.ylabel("Cumulative Returns")
-        plt.title(f"ARIMA+GARCH Strategy vs. Buy & Hold on ({self.symbol})")
-        plt.legend()
-        plt.grid(True)
-        plt.show()
 
 
 # *********************************************
 # STATS TEST (Cointegration , Mean Reverting)*
 # *********************************************
 def get_corr(tickers: Union[List[str], Tuple[str, ...]], start: str, end: str) -> None:
-    """
-    Calculates and prints the correlation matrix of the adjusted closing prices
-    for a given list of stock tickers within a specified date range.
-
-    Args:
-        tickers (Union[List[str] , Tuple[str, ...]]):
-        A list or tuple of valid stock tickers (e.g., ['AAPL', 'MSFT', 'GOOG']).
-        start (str): The start date for the historical data in 'YYYY-MM-DD' format.
-        end (str): The end date for the historical data in 'YYYY-MM-DD' format.
-
-    Example:
-    >>> from bbstrader.tseries import get_corr
-    >>> 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, auto_adjust=True)
-    data = data["Adj Close"] if "Adj Close" in data.columns else data["Close"]
-
-    # Calculate correlation matrix
-    correlation_matrix = data.corr()
-
-    # Display the matrix
-    print(correlation_matrix)
+    warnings.warn(
+        "`get_corr` is deprecated, use pandas DataFrame's `corr` method instead.",
+        DeprecationWarning,
+    )
 
 
 def plot_price_series(df: pd.DataFrame, ts1: str, ts2: str):
@@ -722,119 +295,22 @@ def run_cadf_test(
     pprint.pprint(cadf)
 
 
-def _hurst(ts):
-    """
-    Returns the Hurst Exponent of the time series vector ts,
-    """
-    # Create the range of lag values
-    lags = range(2, 100)
-
-    # Calculate the array of the variances of the lagged differences
-    tau = [np.sqrt(np.std(np.subtract(ts[lag:], ts[:-lag]))) for lag in lags]
-
-    # Use a linear fit to estimate the Hurst Exponent
-    poly = np.polyfit(np.log(lags), np.log(tau), 1)
-
-    # Return the Hurst exponent from the polyfit output
-    return poly[0] * 2.0
-
-
-# Function to calculate Hurst Exponent
-
-
-def hurst(time_series):
-    H, c, data_range = compute_Hc(time_series, kind="price", simplified=True)
-    return H
-
-
 def run_hurst_test(symbol: str, start: str, end: str):
-    """
-    Calculates and prints the Hurst Exponent for a given stock's adjusted closing prices
-    within a specified date range, and for three generated series (Geometric Brownian Motion,
-    Mean-Reverting, and Trending).
-
-    The Hurst Exponent is used to determine the long-term memory of a time series.
-
-    Args:
-        symbol (str): A valid stock ticker symbol (e.g., 'AAPL').
-        start (str): The start date for the historical data in 'YYYY-MM-DD' format.
-        end (str): The end date for the historical data in 'YYYY-MM-DD' format.
-
-    Example:
-    >>> from bbstrader.tseries import run_hurst_test
-
-    >>> run_hurst_test('AAPL', '2023-01-01', '2023-12-31')
-    """
-    data = yf.download(
-        symbol,
-        start=start,
-        end=end,
-        progress=False,
-        multi_level_index=False,
-        auto_adjust=True,
+    warnings.warn(
+        "`run_hurst_test` is deprecated, use `hurst.compute_Hc` instead.",
+        DeprecationWarning,
     )
 
-    # Create a Geometric Brownian Motion, Mean-Reverting, and Trending Series
-    gbm = np.log(np.cumsum(np.random.randn(100000)) + 1000)
-    mr = np.log(np.random.randn(100000) + 1000)
-    tr = np.log(np.cumsum(np.random.randn(100000) + 1) + 1000)
-
-    # Output the Hurst Exponent for each of the series
-    print(f"\nHurst(GBM):  {_hurst(gbm)}")
-    print(f"Hurst(MR):   {_hurst(mr)}")
-    print(f"Hurst(TR):   {_hurst(tr)}")
-    print(f"Hurst({symbol}): {hurst(data['Close'])}\n")
-
 
 def test_cointegration(ticker1, ticker2, start, end):
-    # Download historical data
-    stock_data_pair = yf.download(
-        [ticker1, ticker2],
-        start=start,
-        end=end,
-        progress=False,
-        multi_level_index=False,
-        auto_adjust=True,
-    )["Close"].dropna()
-
-    # Perform Johansen cointegration test
-    result = coint_johansen(stock_data_pair, det_order=0, k_ar_diff=1)
-
-    # Get the cointegration rank
-    traces_stats = result.lr1
-    print(f"\nTraces Stats: \n{traces_stats}")
-
-    # Get the critical values for 95% confidence level
-    critical_values = result.cvt
-    print(f"\nCritical Values: \n{critical_values}")
-
-    # Compare the cointegration rank with critical values
-    if traces_stats[0] > critical_values[:, 1].all():
-        print(f"\n{ticker1} and {ticker2} are cointegrated.\n")
-    else:
-        print(f"\nNo cointegration found for {ticker1} and {ticker2}.\n")
+    warnings.warn(
+        "`test_cointegration` is deprecated, see statsmodels.tsa.stattools.coint instead.",
+        DeprecationWarning,
+    )
 
 
 def run_coint_test(tickers: List[str], start: str, end: str) -> None:
-    """
-    Performs pairwise cointegration tests on a list of stock tickers over a specified date range.
-
-    For each unique pair of tickers, the function downloads historical adjusted closing prices and
-    tests for cointegration.
-
-    Args:
-        tickers (List[str]): A list of valid stock ticker symbols (e.g., ['AAPL', 'MSFT', 'GOOG']).
-        start (str): The start date for the historical data in 'YYYY-MM-DD' format.
-        end (str): The end date for the historical data in 'YYYY-MM-DD' format.
-
-    Example:
-    >>> from bbstrader.tseries import run_coint_test
-
-    >>> run_coint_test(['AAPL', 'MSFT', 'GOOG'], '2023-01-01', '2023-12-31')
-    """
-    # Loop through ticker combinations
-    for ticker1, ticker2 in combinations(tickers, 2):
-        test_cointegration(ticker1, ticker2, start, end)
+    test_cointegration()
 
 
 # *********************************
@@ -1086,158 +562,12 @@ class KalmanFilterModel:
             return None
 
 
-# ******************************************
-#         ORNSTEIN UHLENBECK PROCESS       *
-# ******************************************
-
-
 class OrnsteinUhlenbeck:
-    """
-    The Ornstein-Uhlenbeck process is a mathematical model
-    used to describe the behavior of a mean-reverting stochastic process.
-    We use it  to model the price dynamics of an asset that tends
-    to revert to a long-term mean.
-
-    We Estimate the drift (θ), volatility (σ), and long-term mean (μ)
-    based on historical price data; then we Simulate the OU process
-    using the estimated parameters.
-
-    https://en.wikipedia.org/wiki/Ornstein%E2%80%93Uhlenbeck_process
-    """
-
     def __init__(self, prices: np.ndarray, returns: bool = True, timeframe: str = "D1"):
-        """
-        Initializes the OrnsteinUhlenbeck instance.
-
-        Args:
-            prices (np.ndarray) : Historical close prices.
-
-            retrurns (bool) : Use it to indicate weither
-                you want  to simulate the returns or your raw data
-
-            timeframe (str) : The time  frame for the Historical prices
-                (1m, 5m, 15m, 30m, 1h, 4h, D1)
-        """
-        self.prices = prices
-        if returns:
-            series = pd.Series(self.prices)
-            self.returns = series.pct_change().dropna().values
-        else:
-            self.returns = self.prices
-
-        time_frame_mapping = {
-            "1m": 1 / (24 * 60),  # 1 minute intervals
-            "5m": 5 / (24 * 60),  # 5 minute intervals
-            "15m": 15 / (24 * 60),  # 15 minute intervals
-            "30m": 30 / (24 * 60),  # 30 minute intervals
-            "1h": 1 / 24,  # 1 hour intervals
-            "4h": 4 / 24,  # 4 hour intervals
-            "D1": 1,  # Daily intervals
-        }
-        if timeframe not in time_frame_mapping:
-            raise ValueError("Unsupported time frame")
-        self.tf = time_frame_mapping[timeframe]
-
-        params = self.estimate_parameters()
-        self.mu_hat = params[0]  # Mean (μ)
-        self.theta_hat = params[1]  # Drift (θ)
-        self.sigma_hat = params[2]  # Volatility (σ)
-        print(f"Estimated μ: {self.mu_hat}")
-        print(f"Estimated θ: {self.theta_hat}")
-        print(f"Estimated σ: {self.sigma_hat}")
-
-    def ornstein_uhlenbeck(self, mu, theta, sigma, dt, X0, n):
-        """
-        Simulates the Ornstein-Uhlenbeck process.
-
-        Args:
-            mu (float): Estimated long-term mean.
-            theta (float): Estimated drift.
-            sigma (float): Estimated volatility.
-            dt (float): Time step.
-            X0 (float): Initial value.
-            n (int): Number of time steps.
-
-        Returns:
-            np.ndarray : Simulated process.
-        """
-        x = np.zeros(n)
-        x[0] = X0
-        for t in range(1, n):
-            dW = np.random.normal(loc=0, scale=np.sqrt(dt))
-            # O-U process differential equation
-            x[t] = x[t - 1] + (theta * (mu - x[t - 1]) * dt) + (sigma * dW)
-            # dW is a Wiener process
-            # (theta * (mu - x[t-1]) * dt) represents the mean-reverting tendency
-            # (sigma * dW) represents the random volatility
-        return x
-
-    def estimate_parameters(self):
-        """
-        Estimates the mean-reverting parameters (μ, θ, σ)
-        using the negative log-likelihood.
-
-        Returns:
-            Tuple: Estimated μ, θ, and σ.
-        """
-        initial_guess = [0, 0.1, np.std(self.returns)]
-        result = minimize(self._neg_log_likelihood, initial_guess, args=(self.returns,))
-        mu, theta, sigma = result.x
-        return mu, theta, sigma
-
-    def _neg_log_likelihood(self, params, returns):
-        """
-        Calculates the negative
-            log-likelihood for parameter estimation.
-
-        Args:
-            params (list): List of parameters [mu, theta, sigma].
-            returns (np.ndarray): Historical returns.
-
-        Returns:
-            float: Negative log-likelihood.
-        """
-        mu, theta, sigma = params
-        dt = self.tf
-        n = len(returns)
-        ou_simulated = self.ornstein_uhlenbeck(mu, theta, sigma, dt, 0, n + 1)
-        residuals = ou_simulated[1 : n + 1] - returns
-        neg_ll = 0.5 * np.sum(residuals**2) / sigma**2 + 0.5 * n * np.log(
-            2 * np.pi * sigma**2
+        warnings.warn(
+            "`OrnsteinUhlenbeck` is deprecated, use `statsmodels.tsa` instead.",
+            DeprecationWarning,
         )
-        return neg_ll
-
-    def simulate_process(self, returns=None, n=100, p=None):
-        """
-        Simulates the OU process multiple times .
-
-        Args:
-            returns (np.ndarray): Historical returns.
-            n (int): Number of simulations to perform.
-            p (int): Number of time steps.
-
-        Returns:
-            np.ndarray: 2D array representing simulated processes.
-        """
-        if returns is None:
-            returns = self.returns
-        if p is not None:
-            T = p
-        else:
-            T = len(returns)
-        dt = self.tf
-
-        dW_matrix = np.random.normal(loc=0, scale=np.sqrt(dt), size=(n, T))
-        simulations_matrix = np.zeros((n, T))
-        simulations_matrix[:, 0] = returns[-1]
-
-        for t in range(1, T):
-            simulations_matrix[:, t] = (
-                simulations_matrix[:, t - 1]
-                + self.theta_hat * (self.mu_hat - simulations_matrix[:, t - 1]) * dt
-                + self.sigma_hat * dW_matrix[:, t]
-            )
-        return simulations_matrix
 
 
 def remove_correlated_assets(df: pd.DataFrame, cutoff=0.99):