bbstrader 0.1.7__py3-none-any.whl → 0.1.9__py3-none-any.whl

bbstrader/tseries.py

@@ -8,6 +8,8 @@ market analysis, and financial data exploration.
 """
 import numpy as np
 import pandas as pd
+import pprint
+import warnings
 import yfinance as yf
 from arch import arch_model
 from statsmodels.tsa.arima.model import ARIMA
@@ -25,13 +27,12 @@ from statsmodels.graphics.tsaplots import plot_acf
 from itertools import combinations
 from typing import Union, List, Tuple
 from statsmodels.stats.diagnostic import acorr_ljungbox
-import pprint
-import warnings
+from arch.utility.exceptions import ConvergenceWarning as ArchWarning
+from statsmodels.tools.sm_exceptions import ConvergenceWarning as StatsWarning
 warnings.filterwarnings("ignore")
+warnings.filterwarnings("ignore", category=StatsWarning, module='statsmodels')
+warnings.filterwarnings("ignore", category=ArchWarning, module='arch')
 
-# *******************************************
-#          ARIMA AND GARCH MODELS          *
-# *******************************************
 
 __all__ = [
     "load_and_prepare_data",
@@ -49,6 +50,10 @@ __all__ = [
     "OrnsteinUhlenbeckModel"
 ]
 
+# *******************************************
+#          ARIMA AND GARCH MODELS          *
+# *******************************************
+
 
 def load_and_prepare_data(df: pd.DataFrame):
     """
@@ -99,7 +104,7 @@ def fit_best_arima(window_data: Union[pd.Series, np.ndarray]):
     """
     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(
@@ -112,10 +117,6 @@ def fit_best_arima(window_data: Union[pd.Series, np.ndarray]):
         stepwise=True
     )
     final_order = model.order
-    from arch.utility.exceptions import ConvergenceWarning as ArchConvergenceWarning
-    from statsmodels.tools.sm_exceptions import ConvergenceWarning as StatsConvergenceWarning
-    warnings.filterwarnings("ignore", category=StatsConvergenceWarning)
-    warnings.filterwarnings("ignore", category=ArchConvergenceWarning)
     try:
         best_arima_model = ARIMA(
             window_data + 1e-5, order=final_order, missing='drop').fit()
@@ -183,9 +184,10 @@ def predict_next_return(arima_result, garch_result):
     if not isinstance(arima_pred, np.ndarray):
         pred = arima_pred.values[0]
     else:
-        pred =  arima_pred[0]
+        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.
@@ -206,156 +208,420 @@ def get_prediction(window_data:  Union[pd.Series, np.ndarray]):
     return prediction
 
 
-# *********************************************
-# STATS TEST (Cointegration , Mean Reverting)*
-# *********************************************
-def get_corr(tickers: Union[List[str], Tuple[str, ...]], start: str, end: str) -> None:
+class ArimaGarchModel():
     """
-    Calculates and prints the correlation matrix of the adjusted closing prices 
-    for a given list of stock tickers within a specified date range.
+    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. 
 
-    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.
+    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.
 
-    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)['Adj Close']
+    Exemple:
+        >>> import yfinance as yf
+        >>> from bbstrader.strategies import ArimaGarchModel
+        >>> from bbstrader.tseries import load_and_prepare_data
 
-    # Calculate correlation matrix
-    correlation_matrix = data.corr()
+        >>> if __name__ == '__main__':
+        >>>     # ARCH SPY Vectorize Backtest
+        >>>     k = 252
+        >>>     data = yf.download("SPY", start="2004-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()
+    """
 
-    # Display the matrix
-    print(correlation_matrix)
+    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
 
-def plot_price_series(df: pd.DataFrame, ts1: str, ts2: str):
-    """
-    Plot both time series on the same line graph for
-    the specified date range.
+    # 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 DataFrame containing prices for each series 
-        ts1 (str): The first time series column name
-        ts2 (str): The second time series column name
-    """
-    fig, ax = plt.subplots()
-    ax.plot(df.index, df[ts1], label=ts1)
-    ax.plot(df.index, df[ts2], label=ts2)
+        Args:
+            df (pd.DataFrame): `The raw dataset containing at least the 'Close' prices`.
 
-    fig.autofmt_xdate()
-    plt.xlabel('Month/Year')
-    plt.ylabel('Price ($)')
-    plt.title(f'{ts1} and {ts2} Daily Prices ')
-    plt.legend()
-    plt.show()
+        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.
 
-def plot_scatter_series(df: pd.DataFrame, ts1: str, ts2: str):
-    """
-    Plot a scatter plot of both time series for
-    via the provided DataFrame.
+        Args:
+            window_data (np.array): The dataset for a specific window period.
 
-    Args:
-        df (pd.DataFrame):
-            The DataFrame containing prices for each series 
-        ts1 (str): The first time series column name
-        ts2 (str): The second time series column name
-    """
-    plt.xlabel(f'{ts1} Price ($)')
-    plt.ylabel(f'{ts2} Price ($)')
-    plt.title(f'{ts1} and {ts2} Price Scatterplot')
-    plt.scatter(df[ts1], df[ts2])
+        Returns:
+            ARIMA model: The best fitted ARIMA model based on AIC.
+        """
+        return fit_best_arima(window_data)
 
-    # Plot the regression line
-    plt.plot(df[ts1], results.fittedvalues,
-             linestyle='--', color='red', linewidth=2,
-             label='Regression Line'
-             )
-    plt.legend()
-    plt.show()
+    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.
 
-def plot_residuals(df: pd.DataFrame):
-    """
-    Plot the residuals of OLS procedure for both
-    time series.
+        Returns:
+            tuple: Contains the ARIMA result and GARCH result.
+        """
+        return fit_garch(window_data)
 
-    Args:
-        df (pd.DataFrame): 
-            The DataFrame containing prices for each series 
-    """
-    fig, ax = plt.subplots()
-    ax.plot(df.index, df["res"], label="Residuals")
+    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.
 
-    fig.autofmt_xdate()
-    plt.xlabel('Month/Year')
-    plt.ylabel('Price ($)')
-    plt.title('Residual Plot')
-    plt.legend()
-    plt.show()
+        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
 
-def run_cadf_test(pair: Union[List[str], Tuple[str, ...]], start: str, end: str) -> None:
-    """
-    Performs the Cointegration Augmented Dickey-Fuller (CADF) test on a pair of stock tickers 
-    over a specified date range to check for cointegration.
+        # 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)
 
-    The function downloads historical adjusted closing prices for the specified pair of stock tickers,
-    calculates the optimal hedge ratio (beta) using Ordinary Least Squares (OLS) regression, plots the 
-    time series and their residuals, and finally performs the CADF test on the residuals.
+            # 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)
 
-    Args:
-        pair (List[str] or Tuple[str, ...]): 
-            A list or tuple containing two valid stock tickers (e.g., ['AAPL', 'MSFT']).
-        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.
+            # Plot the figure
+            plt.tight_layout()
+            plt.show()
 
-    Example:
-        >>> from bbstrader.tseries import run_cadf_test
-        >>> run_cadf_test(['AAPL', 'MSFT'], '2023-01-01', '2023-12-31')
-        >>> Regression Metrics:
-        >>> Optimal Hedge Ratio (Beta): 2.2485845594120333
-        >>> Result Parmas: 
+        # 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)
 
-        >>> const   -74.418034
-        >>> AAPL      2.248585
-        >>> dtype: float64
+    # 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.
 
-        >>> Regression Summary:
-        >>>                              OLS Regression Results
-        >>> ==============================================================================
-        >>> Dep. Variable:                   MSFT   R-squared:                       0.900
-        >>> Model:                            OLS   Adj. R-squared:                  0.900
-        >>> Method:                 Least Squares   F-statistic:                     2244.
-        >>> Date:                Sat, 20 Jul 2024   Prob (F-statistic):          2.95e-126
-        >>> Time:                        13:36:58   Log-Likelihood:                -996.45
-        >>> No. Observations:                 250   AIC:                             1997.
-        >>> Df Residuals:                     248   BIC:                             2004.
-        >>> Df Model:                           1
-        >>> Covariance Type:            nonrobust
-        >>> ==============================================================================
-        >>>                  coef    std err          t      P>|t|      [0.025      0.975]
-        >>> ------------------------------------------------------------------------------
-        >>> const        -74.4180      8.191     -9.085      0.000     -90.551     -58.286
-        >>> AAPL           2.2486      0.047     47.369      0.000       2.155       2.342
-        >>> ==============================================================================
-        >>> Omnibus:                        4.923   Durbin-Watson:                   0.121
-        >>> Prob(Omnibus):                  0.085   Jarque-Bera (JB):                4.862
-        >>> Skew:                           0.342   Prob(JB):                       0.0879
-        >>> Kurtosis:                       2.993   Cond. No.                     1.71e+03
-        >>> ==============================================================================
+        Args:
+            arima_result (ARIMA model): The ARIMA model result.
+            garch_result (GARCH model): The GARCH model result.
 
-        >>> Notes:
-        >>> [1] Standard Errors assume that the covariance matrix of the errors is correctly specified.
-        >>> [2] The condition number is large, 1.71e+03. This might indicate that there are
-        >>> strong multicollinearity or other numerical problems.
+        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")
+        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)['Adj Close']
+
+    # Calculate correlation matrix
+    correlation_matrix = data.corr()
+
+    # Display the matrix
+    print(correlation_matrix)
+
+
+def plot_price_series(df: pd.DataFrame, ts1: str, ts2: str):
+    """
+    Plot both time series on the same line graph for
+    the specified date range.
+
+    Args:
+        df (pd.DataFrame): 
+            The DataFrame containing prices for each series 
+        ts1 (str): The first time series column name
+        ts2 (str): The second time series column name
+    """
+    fig, ax = plt.subplots()
+    ax.plot(df.index, df[ts1], label=ts1)
+    ax.plot(df.index, df[ts2], label=ts2)
+
+    fig.autofmt_xdate()
+    plt.xlabel('Month/Year')
+    plt.ylabel('Price ($)')
+    plt.title(f'{ts1} and {ts2} Daily Prices ')
+    plt.legend()
+    plt.show()
+
+
+def plot_scatter_series(df: pd.DataFrame, ts1: str, ts2: str):
+    """
+    Plot a scatter plot of both time series for
+    via the provided DataFrame.
+
+    Args:
+        df (pd.DataFrame):
+            The DataFrame containing prices for each series 
+        ts1 (str): The first time series column name
+        ts2 (str): The second time series column name
+    """
+    plt.xlabel(f'{ts1} Price ($)')
+    plt.ylabel(f'{ts2} Price ($)')
+    plt.title(f'{ts1} and {ts2} Price Scatterplot')
+    plt.scatter(df[ts1], df[ts2])
+
+    # Plot the regression line
+    plt.plot(df[ts1], results.fittedvalues,
+             linestyle='--', color='red', linewidth=2,
+             label='Regression Line'
+             )
+    plt.legend()
+    plt.show()
+
+
+def plot_residuals(df: pd.DataFrame):
+    """
+    Plot the residuals of OLS procedure for both
+    time series.
+
+    Args:
+        df (pd.DataFrame): 
+            The DataFrame containing prices for each series 
+    """
+    fig, ax = plt.subplots()
+    ax.plot(df.index, df["res"], label="Residuals")
+
+    fig.autofmt_xdate()
+    plt.xlabel('Month/Year')
+    plt.ylabel('Price ($)')
+    plt.title('Residual Plot')
+    plt.legend()
+    plt.show()
+
+
+def run_cadf_test(pair: Union[List[str], Tuple[str, ...]], start: str, end: str) -> None:
+    """
+    Performs the Cointegration Augmented Dickey-Fuller (CADF) test on a pair of stock tickers 
+    over a specified date range to check for cointegration.
+
+    The function downloads historical adjusted closing prices for the specified pair of stock tickers,
+    calculates the optimal hedge ratio (beta) using Ordinary Least Squares (OLS) regression, plots the 
+    time series and their residuals, and finally performs the CADF test on the residuals.
+
+    Args:
+        pair (List[str] or Tuple[str, ...]): 
+            A list or tuple containing two valid stock tickers (e.g., ['AAPL', 'MSFT']).
+        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_cadf_test
+        >>> run_cadf_test(['AAPL', 'MSFT'], '2023-01-01', '2023-12-31')
+        >>> Regression Metrics:
+        >>> Optimal Hedge Ratio (Beta): 2.2485845594120333
+        >>> Result Parmas: 
+
+        >>> const   -74.418034
+        >>> AAPL      2.248585
+        >>> dtype: float64
+
+        >>> Regression Summary:
+        >>>                              OLS Regression Results
+        >>> ==============================================================================
+        >>> Dep. Variable:                   MSFT   R-squared:                       0.900
+        >>> Model:                            OLS   Adj. R-squared:                  0.900
+        >>> Method:                 Least Squares   F-statistic:                     2244.
+        >>> Date:                Sat, 20 Jul 2024   Prob (F-statistic):          2.95e-126
+        >>> Time:                        13:36:58   Log-Likelihood:                -996.45
+        >>> No. Observations:                 250   AIC:                             1997.
+        >>> Df Residuals:                     248   BIC:                             2004.
+        >>> Df Model:                           1
+        >>> Covariance Type:            nonrobust
+        >>> ==============================================================================
+        >>>                  coef    std err          t      P>|t|      [0.025      0.975]
+        >>> ------------------------------------------------------------------------------
+        >>> const        -74.4180      8.191     -9.085      0.000     -90.551     -58.286
+        >>> AAPL           2.2486      0.047     47.369      0.000       2.155       2.342
+        >>> ==============================================================================
+        >>> Omnibus:                        4.923   Durbin-Watson:                   0.121
+        >>> Prob(Omnibus):                  0.085   Jarque-Bera (JB):                4.862
+        >>> Skew:                           0.342   Prob(JB):                       0.0879
+        >>> Kurtosis:                       2.993   Cond. No.                     1.71e+03
+        >>> ==============================================================================
+
+        >>> Notes:
+        >>> [1] Standard Errors assume that the covariance matrix of the errors is correctly specified.
+        >>> [2] The condition number is large, 1.71e+03. This might indicate that there are
+        >>> strong multicollinearity or other numerical problems.
 
         >>> Cointegration TEST Results:
         >>> (np.float64(-3.204126144947765),
@@ -621,268 +887,138 @@ def run_kalman_filter(
     draw_slope_intercept_changes(prices, state_means)
 
 
-class ArimaGarchModel():
+class KalmanFilterModel():
     """
-    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.strategies import ArimaGarchModel
-        >>> from bbstrader.tseries import load_and_prepare_data
+    Implements a Kalman Filter model a recursive algorithm used for estimating 
+    the state of a linear dynamic system from a series of noisy measurements. 
+    It's designed to process market data, estimate dynamic parameters such as 
+    the slope and intercept of price relationships, 
+    forecast error and standard deviation of the predictions
 
-        >>> if __name__ == '__main__':
-        >>>     # ARCH SPY Vectorize Backtest
-        >>>     k = 252
-        >>>     data = yf.download("SPY", start="2004-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()
+    You can learn more here https://en.wikipedia.org/wiki/Kalman_filter
     """
 
-    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):
+    def __init__(self, tickers: list | tuple, **kwargs):
         """
-        Displays the ARIMA and GARCH model results, including plotting 
-        ACF of residuals and conducting , Box-Pierce and Ljung-Box tests.
+        Initializes the Kalman Filter strategy.
 
         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)
+            tickers : 
+            A list or tuple of ticker symbols representing financial instruments.
 
-    # Step 3: Prediction
-    def predict_next_return(self, arima_result, garch_result):
+            kwargs : Keyword arguments for additional parameters,
+             specifically `delta` and `vt`
         """
-        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.
+        self.tickers = tickers
+        assert self.tickers is not None
+        self.latest_prices = np.array([-1.0, -1.0])
+        self.delta = kwargs.get("delta", 1e-4)
+        self.wt = self.delta/(1-self.delta) * np.eye(2)
+        self.vt = kwargs.get("vt", 1e-3)
+        self.theta = np.zeros(2)
+        self.P = np.zeros((2, 2))
+        self.R = None
+        self.kf = self._init_kalman()
 
-        Returns:
-            float: The predicted next return.
+    def _init_kalman(self):
         """
-        return predict_next_return(arima_result, garch_result)
-
-    def get_prediction(self, window_data):
+        Initializes and returns a Kalman Filter configured 
+        for the trading strategy. The filter is set up with initial 
+        state and covariance, state transition matrix, process noise
+        and measurement noise covariances.
         """
-        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.
+        kf = KalmanFilter(dim_x=2, dim_z=1)
+        kf.x = np.zeros((2, 1))  # Initial state
+        kf.P = self.P  # Initial covariance
+        kf.F = np.eye(2)  # State transition matrix
+        kf.Q = self.wt  # Process noise covariance
+        kf.R = 1.  # Scalar measurement noise covariance
 
-        Returns:
-            float: The predicted next return.
-        """
-        return get_prediction(window_data)
+        return kf
 
-    def calculate_signals(self, window_data):
+    def calc_slope_intercep(self, prices: np.ndarray):
         """
-        Calculates the trading signal based on the prediction.
+        Calculates and returns the slope and intercept 
+        of the relationship between the provided prices using the Kalman Filter. 
+        This method updates the filter with the latest price and returns 
+        the estimated slope and intercept.
 
         Args:
-            window_data (np.array): The dataset for a specific window period.
+            prices : A numpy array of prices for two financial instruments.
 
-        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
+        Returns:
+            A tuple containing the slope and intercept of the relationship
+        """
+        kf = self.kf
+        kf.H = np.array([[prices[1], 1.0]])
+        kf.predict()
+        kf.update(prices[0])
+        slope = kf.x.copy().flatten()[0]
+        intercept = kf.x.copy().flatten()[1]
 
-    # Step 4: Trading Strategy
+        return slope, intercept
 
-    def execute_trading_strategy(self, predictions):
+    def calculate_etqt(self, prices: np.ndarray):
         """
-        Executes the trading strategy based on a list 
-        of predictions, determining positions to take.
+        Calculates the forecast error and standard deviation of the predictions
+        using the Kalman Filter.
 
         Args:
-            predictions (list): A list of predicted returns.
+            prices : A numpy array of prices for two financial instruments.
 
         Returns:
-            list: A list of positions (1 for 'LONG', -1 for 'SHORT', 0 for 'HOLD').
+            A tuple containing the forecast error and standard deviation of the predictions.
         """
-        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
+        self.latest_prices[0] = prices[0]
+        self.latest_prices[1] = prices[1]
 
-    # 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
+        if all(self.latest_prices > -1.0):
+            slope, intercept = self.calc_slope_intercep(self.latest_prices)
 
-    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")
-        predictions_generator = self.generate_predictions()
+            self.theta[0] = slope
+            self.theta[1] = intercept
 
-        positions = self.execute_trading_strategy(predictions_generator)
+            # Create the observation matrix of the latest prices
+            # of Y and the intercept value (1.0) as well as the
+            # scalar value of the latest price from X
+            F = np.asarray([self.latest_prices[0], 1.0]).reshape((1, 2))
+            y = self.latest_prices[1]
 
-        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)
+            # The prior value of the states {\theta_t} is
+            # distributed as a multivariate Gaussian with
+            # mean a_t and variance-covariance {R_t}
+            if self.R is not None:
+                self.R = self.C + self.wt
+            else:
+                self.R = np.zeros((2, 2))
 
-        print("\nBacktesting completed !!")
+            # Calculate the Kalman Filter update
+            # ---------------------------------
+            # Calculate prediction of new observation
+            # as well as forecast error of that prediction
+            yhat = F.dot(self.theta)
+            et = y - yhat
 
-    # 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.
+            # {Q_t} is the variance of the prediction of
+            # observations and hence sqrt_Qt is the
+            # standard deviation of the predictions
+            Qt = F.dot(self.R).dot(F.T) + self.vt
+            sqrt_Qt = np.sqrt(Qt)
 
-        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()
+            # The posterior value of the states {\theta_t} is
+            # distributed as a multivariate Gaussian with mean
+            # {m_t} and variance-covariance {C_t}
+            At = self.R.dot(F.T) / Qt
+            self.theta = self.theta + At.flatten() * et
+            self.C = self.R - At * F.dot(self.R)
+            return (et, sqrt_Qt)
+        else:
+            return None
+
+# ******************************************
+#         ORNSTEIN UHLENBECK PROCESS       *
+# ******************************************
 
 
 class OrnsteinUhlenbeck():
@@ -1044,133 +1180,3 @@ class OrnsteinUhlenbeck():
                 self.sigma_hat * dW_matrix[:, t]
             )
         return simulations_matrix
-
-
-class KalmanFilterModel():
-    """
-    Implements a Kalman Filter model a recursive algorithm used for estimating 
-    the state of a linear dynamic system from a series of noisy measurements. 
-    It's designed to process market data, estimate dynamic parameters such as 
-    the slope and intercept of price relationships, 
-    forecast error and standard deviation of the predictions
-
-    You can learn more here https://en.wikipedia.org/wiki/Kalman_filter
-    """
-
-    def __init__(self, tickers: list | tuple, **kwargs):
-        """
-        Initializes the Kalman Filter strategy.
-
-        Args:
-            tickers : 
-            A list or tuple of ticker symbols representing financial instruments.
-
-            kwargs : Keyword arguments for additional parameters,
-             specifically `delta` and `vt`
-        """
-        self.tickers = tickers
-        assert self.tickers is not None
-        self.latest_prices = np.array([-1.0, -1.0])
-        self.delta = kwargs.get("delta", 1e-4)
-        self.wt = self.delta/(1-self.delta) * np.eye(2)
-        self.vt = kwargs.get("vt", 1e-3)
-        self.theta = np.zeros(2)
-        self.P = np.zeros((2, 2))
-        self.R = None
-        self.kf = self._init_kalman()
-
-    def _init_kalman(self):
-        """
-        Initializes and returns a Kalman Filter configured 
-        for the trading strategy. The filter is set up with initial 
-        state and covariance, state transition matrix, process noise
-        and measurement noise covariances.
-        """
-        kf = KalmanFilter(dim_x=2, dim_z=1)
-        kf.x = np.zeros((2, 1))  # Initial state
-        kf.P = self.P  # Initial covariance
-        kf.F = np.eye(2)  # State transition matrix
-        kf.Q = self.wt  # Process noise covariance
-        kf.R = 1.  # Scalar measurement noise covariance
-
-        return kf
-
-    def calc_slope_intercep(self, prices: np.ndarray):
-        """
-        Calculates and returns the slope and intercept 
-        of the relationship between the provided prices using the Kalman Filter. 
-        This method updates the filter with the latest price and returns 
-        the estimated slope and intercept.
-
-        Args:
-            prices : A numpy array of prices for two financial instruments.
-
-        Returns:
-            A tuple containing the slope and intercept of the relationship
-        """
-        kf = self.kf
-        kf.H = np.array([[prices[1], 1.0]])
-        kf.predict()
-        kf.update(prices[0])
-        slope = kf.x.copy().flatten()[0]
-        intercept = kf.x.copy().flatten()[1]
-
-        return slope, intercept
-
-    def calculate_etqt(self, prices: np.ndarray):
-        """
-        Calculates the forecast error and standard deviation of the predictions
-        using the Kalman Filter.
-
-        Args:
-            prices : A numpy array of prices for two financial instruments.
-
-        Returns:
-            A tuple containing the forecast error and standard deviation of the predictions.
-        """
-
-        self.latest_prices[0] = prices[0]
-        self.latest_prices[1] = prices[1]
-
-        if all(self.latest_prices > -1.0):
-            slope, intercept = self.calc_slope_intercep(self.latest_prices)
-
-            self.theta[0] = slope
-            self.theta[1] = intercept
-
-            # Create the observation matrix of the latest prices
-            # of Y and the intercept value (1.0) as well as the
-            # scalar value of the latest price from X
-            F = np.asarray([self.latest_prices[0], 1.0]).reshape((1, 2))
-            y = self.latest_prices[1]
-
-            # The prior value of the states {\theta_t} is
-            # distributed as a multivariate Gaussian with
-            # mean a_t and variance-covariance {R_t}
-            if self.R is not None:
-                self.R = self.C + self.wt
-            else:
-                self.R = np.zeros((2, 2))
-
-            # Calculate the Kalman Filter update
-            # ---------------------------------
-            # Calculate prediction of new observation
-            # as well as forecast error of that prediction
-            yhat = F.dot(self.theta)
-            et = y - yhat
-
-            # {Q_t} is the variance of the prediction of
-            # observations and hence sqrt_Qt is the
-            # standard deviation of the predictions
-            Qt = F.dot(self.R).dot(F.T) + self.vt
-            sqrt_Qt = np.sqrt(Qt)
-
-            # The posterior value of the states {\theta_t} is
-            # distributed as a multivariate Gaussian with mean
-            # {m_t} and variance-covariance {C_t}
-            At = self.R.dot(F.T) / Qt
-            self.theta = self.theta + At.flatten() * et
-            self.C = self.R - At * F.dot(self.R)
-            return (et, sqrt_Qt)
-        else:
-            return None