ols_test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "df = pd.DataFrame(index=ticker_data_1.index)\n",
    "df[ticker1] = ticker_data_1[\"Close\"]\n",
    "df[ticker2] = ticker_data_2[\"Close\"]\n",
    "\n",
    "model = sm.OLS(df[ticker1], df[ticker2]) \n",
    "res = model.fit()\n",
    "beta_hr = res.params[0]\n",
    "\n",
    "# Calculate the residuals of the linear combination\n",
    "df[\"res\"] = df[ticker1] - beta_hr * df[ticker2]\n",
    "\n",
    "# Calculate and output the CADF test on the residuals\n",
    "cadf = ts.adfuller(df[\"res\"])\n",
    "\n",
    "zscore = ((df[\"res\"] - df[\"res\"].mean())/ df[\"res\"].std())[-1]\n",
    "df[\"z-s\"] = ((df[\"res\"] - df[\"res\"].mean())/ df[\"res\"].std())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "import statsmodels.api as sm\n",
    "import numpy as np\n",
    "\n",
    "x = rw.get_window(group[0].symbol)\n",
    "y = rw.get_window(group[1].symbol)\n",
    "\n",
    "last_2_prices_x = x[-2:]\n",
    "last_2_prices_y = y[-2:]\n",
    "\n",
    "time_indices_x = np.arange(len(x)-2, len(x))\n",
    "time_indices_y = np.arange(len(y)-2, len(y))\n",
    "\n",
    "model_x = LinearRegression()\n",
    "model_y = LinearRegression()\n",
    "model_x.fit(time_indices_x.reshape(-1, 1), last_2_prices_x)\n",
    "model_y.fit(time_indices_y.reshape(-1, 1), last_2_prices_y)\n",
    "\n",
    "slope_x = model_x.coef_[0]\n",
    "slope_y = model_y.coef_[0]\n",
    "\n",
    "signs_opposite = np.all(slope_x == -slope_y)\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 57,
   "metadata": {},
   "outputs": [
    {
     "ename": "SyntaxError",
     "evalue": "invalid syntax (1279104706.py, line 421)",
     "output_type": "error",
     "traceback": [
      "\u001b[0;36m  Cell \u001b[0;32mIn [57], line 421\u001b[0;36m\u001b[0m\n\u001b[0;31m    type(x) <class 'pandas.core.series.Series'>\u001b[0m\n\u001b[0m             ^\u001b[0m\n\u001b[0;31mSyntaxError\u001b[0m\u001b[0;31m:\u001b[0m invalid syntax\n"
     ]
    }
   ],
   "source": [
    "from sklearn.linear_model import LinearRegression\n",
    "import statsmodels.tsa.stattools as ts\n",
    "import matplotlib.pyplot as plt\n",
    "import statsmodels.api as sm\n",
    "import yfinance as yf\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "def normalize_start(df, start):\n",
    "    # Subtract the 'open' value at 'start' index from all 'open' values\n",
    "    df['Close'] = df['Close'] - df['Close'].iloc[start]\n",
    "    return df\n",
    "\n",
    "def normalize_minmax(df):\n",
    "    # start does nothing here, just more work to rearrange code everytime i switch\n",
    "    df['Close'] = (df['Close'] - df['Close'].min()) / (df['Close'].max() - df['Close'].min())\n",
    "    return df\n",
    "\n",
    "def read_and_normalize(filename, start):\n",
    "    # Read CSV\n",
    "    df = pd.read_csv(filename, parse_dates=['Date'])\n",
    "    df_copy = df.copy()\n",
    "    df1_copy = df.copy()\n",
    "    df2_copy = df.copy()\n",
    "    # df = pd.read_csv(filename, parse_dates=['timestamp'])\n",
    "    # Normalize\n",
    "    df_n_start = normalize_start(df1_copy, start)\n",
    "    df_n_minmax = normalize_minmax(df2_copy)\n",
    "    return df_n_start, df_n_minmax, df_copy\n",
    "\n",
    "def filter_by_index(df_normalized, df_n_minmax, df, start, end):\n",
    "    return df_normalized.iloc[start:end], df_n_minmax.iloc[start:end], df.iloc[start:end]\n",
    "\n",
    "def check_opposite_signs_fixed(x, y, idx):\n",
    "    # Using the last two days to check the signs.\n",
    "    last_2_prices_x = x.iloc[idx-2:idx]\n",
    "    last_2_prices_y = y.iloc[idx-2:idx]\n",
    "\n",
    "    time_indices_x = pd.Series(range(2))  # two points, so just [0, 1]\n",
    "    time_indices_y = pd.Series(range(2))\n",
    "\n",
    "    model_x = LinearRegression()\n",
    "    model_y = LinearRegression()\n",
    "    model_x.fit(time_indices_x.values.reshape(-1, 1), last_2_prices_x.values)\n",
    "    model_y.fit(time_indices_y.values.reshape(-1, 1), last_2_prices_y.values)\n",
    "\n",
    "    slope_x = model_x.coef_[0]\n",
    "    slope_y = model_y.coef_[0]\n",
    "\n",
    "    return slope_x == -slope_y\n",
    "\n",
    "def divide_stocks(stock_data_1, stock_data_2):\n",
    "    return stock_data_1 / stock_data_2\n",
    "\n",
    "def OlsBetahrRes(stock_data_1, stock_data_2):\n",
    "    model = sm.OLS(stock_data_1, stock_data_2) \n",
    "    res = model.fit()\n",
    "    beta_hr = res.params[0]\n",
    "    residuals = stock_data_1 - beta_hr * stock_data_2\n",
    "    return residuals\n",
    "\n",
    "def lin_reg_xy(padas_date_price_x, padas_date_price_y):\n",
    "    lin_reg_x = []\n",
    "    lin_reg_y = []\n",
    "    if len(padas_date_price_x) == len(padas_date_price_y):\n",
    "        for itr in range(2, len(padas_date_price_x)):\n",
    "            last_2_prices_x = padas_date_price_x[itr-2:itr]\n",
    "            last_2_prices_y = padas_date_price_y[itr-2:itr]\n",
    "\n",
    "            print(\"type(last_2_prices_x)\", type(last_2_prices_x))\n",
    "\n",
    "            time_indices_x = np.arange(len(padas_date_price_x)-2, len(padas_date_price_x))\n",
    "            time_indices_y = np.arange(len(padas_date_price_y)-2, len(padas_date_price_y))\n",
    "\n",
    "            print(\"type(time_indices_x)\", type(time_indices_x))\n",
    "\n",
    "            model_x = LinearRegression()\n",
    "            model_y = LinearRegression()\n",
    "            model_x.fit(time_indices_x.reshape(-1, 1), last_2_prices_x)\n",
    "            model_y.fit(time_indices_y.reshape(-1, 1), last_2_prices_y)\n",
    "\n",
    "            slope_x = model_x.coef_[0]\n",
    "            slope_y = model_y.coef_[0]\n",
    "\n",
    "            print(\"type(slope_x)\", type(slope_x))\n",
    "            print(\"slope_x\", slope_x)\n",
    "            \n",
    "            lin_reg_x.append(slope_x)\n",
    "            lin_reg_y.append(slope_y)\n",
    "    return lin_reg_x, lin_reg_y\n",
    "\n",
    "def find_combos_ab_res_zero(res_data, zd, x_or_y, above_below:bool):\n",
    "        gxy = np.full(len(res_data), np.nan)\n",
    "        index = 0\n",
    "        if above_below == True:\n",
    "            for i in zd.index:\n",
    "                if zd[i] > 0:\n",
    "                    gxy[index] = i\n",
    "                index += 1\n",
    "        else:\n",
    "            for i in res_data.index:\n",
    "                if res_data[i] < 0:\n",
    "                    gxy[index] = i\n",
    "                index += 1\n",
    "        wombo_combo = pd.Series(x_or_y, gxy)\n",
    "        return wombo_combo\n",
    "\n",
    "def lin_reg_above_below(lst, aboveT_belowF:bool):\n",
    "        gxy = np.full(len(lst), np.nan)\n",
    "        index = 0\n",
    "        if aboveT_belowF == True:\n",
    "            for i in lst:\n",
    "                if i > 0:\n",
    "                    gxy[index] = i\n",
    "                index += 1\n",
    "        else:\n",
    "            for i in lst:\n",
    "                if i < 0:\n",
    "                    gxy[index] = i\n",
    "                index += 1\n",
    "        return gxy\n",
    "\n",
    "def compute_sma(data, window_size=50):\n",
    "    return data.rolling(window=window_size).mean()\n",
    "\n",
    "def compute_ema(data, span=20):\n",
    "    return data.ewm(span=span, adjust=False).mean()\n",
    "\n",
    "def entire_zscore(x_val,y_val):\n",
    "    residuals_func = OlsBetahrRes(x_val, y_val)\n",
    "    cadf = ts.adfuller(residuals_func)\n",
    "    print(cadf)\n",
    "    zscore = ((residuals_func - residuals_func.mean())/ residuals_func.std())\n",
    "    return zscore, cadf\n",
    "\n",
    "\n",
    "def plot(df1_start, df1_n_minmax, df1_copy, df2_start, df2_n_minmax, df2_copy, start):\n",
    "\n",
    "    fig, axs = plt.subplots(12, figsize=(18,30))\n",
    "\n",
    "    zscore, cadf = entire_zscore(df1_copy['Close'], df2_copy['Close'])\n",
    "    zscore_s, cadf_s = entire_zscore(df1_start['Close'], df2_start['Close'])\n",
    "    zscore_m, cadf_m = entire_zscore(df1_n_minmax['Close'], df2_n_minmax['Close'])\n",
    "\n",
    "    # dividing the two stocks\n",
    "    div_stk = df1_copy['Close'] / df2_copy['Close']\n",
    "    div_stk_s = df1_start['Close'] / df2_start['Close']\n",
    "    div_stk_m = df1_n_minmax['Close'] / df2_n_minmax['Close']\n",
    "\n",
    "    # res via division\n",
    "    ratio_data = divide_stocks(df1_copy['Close'], df2_copy['Close'])\n",
    "    ratio_data_s = divide_stocks(df1_start['Close'], df2_start['Close'])\n",
    "    ratio_data_m = divide_stocks(df1_n_minmax['Close'], df2_n_minmax['Close'])\n",
    "\n",
    "    # residuals via ols -> betahr ->  res\n",
    "    res_data = OlsBetahrRes(df1_copy['Close'], df2_copy['Close'])\n",
    "    res_data_s = OlsBetahrRes(df1_start['Close'], df2_start['Close'])\n",
    "    res_data_m = OlsBetahrRes(df1_n_minmax['Close'], df2_n_minmax['Close'])\n",
    "\n",
    "    # ema of residuals\n",
    "    res_ema = compute_ema(res_data)\n",
    "    res_ema_s = compute_ema(res_data_s)\n",
    "    res_ema_m = compute_ema(res_data_m)\n",
    "\n",
    "    combo_dates_x = find_combos_ab_res_zero(\n",
    "                                            res_data=res_data,\n",
    "                                            zd=res_data, \n",
    "                                            x_or_y=df1_copy['Close'],\n",
    "                                            above_below=False\n",
    "    )\n",
    "    combo_dates_x_s = find_combos_ab_res_zero(\n",
    "                                            res_data=res_data_s,\n",
    "                                            zd=res_data_s, \n",
    "                                            x_or_y=df1_copy['Close'],\n",
    "                                            above_below=False\n",
    "    )\n",
    "    combo_dates_x_m = find_combos_ab_res_zero(\n",
    "                                            res_data=res_data_m,\n",
    "                                            zd=res_data_m, \n",
    "                                            x_or_y=df1_copy['Close'],\n",
    "                                            above_below=False\n",
    "    )\n",
    "\n",
    "\n",
    "    combo_dates_y = find_combos_ab_res_zero(\n",
    "                                            res_data=res_data,\n",
    "                                            zd=res_data, \n",
    "                                            x_or_y=df2_copy['Close'],\n",
    "                                            above_below=True\n",
    "    )\n",
    "    combo_dates_y_s = find_combos_ab_res_zero(\n",
    "                                            res_data=res_data_s,\n",
    "                                            zd=res_data_s, \n",
    "                                            x_or_y=df2_copy['Close'],\n",
    "                                            above_below=True\n",
    "    )\n",
    "    combo_dates_y_m = find_combos_ab_res_zero(\n",
    "                                            res_data=res_data_m,\n",
    "                                            zd=res_data_m, \n",
    "                                            x_or_y=df2_copy['Close'],\n",
    "                                            above_below=True\n",
    "    )\n",
    "\n",
    "\n",
    "    lin_reg_x, lin_reg_y = lin_reg_xy(df1_copy[\"Close\"], df2_copy[\"Close\"])\n",
    "    lin_reg_x_s, lin_reg_y_s = lin_reg_xy(df1_start[\"Close\"], df2_start[\"Close\"])\n",
    "    lin_reg_x_m, lin_reg_y_m = lin_reg_xy(df2_n_minmax[\"Close\"], df2_n_minmax[\"Close\"])\n",
    "\n",
    "    buy_x_below_lin_reg = lin_reg_above_below(lin_reg_x,False)\n",
    "    buy_y_above_lin_reg = lin_reg_above_below(lin_reg_y,True)\n",
    "    buy_x_below_lin_reg_s = lin_reg_above_below(lin_reg_x_s,False)\n",
    "    buy_y_above_lin_reg_s = lin_reg_above_below(lin_reg_x_s,True)\n",
    "    buy_x_below_lin_reg_m = lin_reg_above_below(lin_reg_x_m,False)\n",
    "    buy_y_above_lin_reg_m = lin_reg_above_below(lin_reg_x_m,True)\n",
    "\n",
    "    pd_date_lin_reg_x = pd.Series(lin_reg_x, df1_copy.index[2:])\n",
    "    pd_date_lin_reg_y = pd.Series(lin_reg_y, df2_copy.index[2:])\n",
    "    pd_date_lin_reg_x = pd.Series(lin_reg_x_s, df1_copy.index[2:])\n",
    "    pd_date_lin_reg_y = pd.Series(lin_reg_y_s, df2_copy.index[2:])\n",
    "    pd_date_lin_reg_x = pd.Series(lin_reg_x_m, df1_copy.index[2:])\n",
    "    pd_date_lin_reg_y = pd.Series(lin_reg_y_m, df2_copy.index[2:])\n",
    "\n",
    "    pd_buy_x_below_lin_reg = pd.Series(buy_x_below_lin_reg, df1_copy.index[2:])\n",
    "    pd_buy_y_above_lin_reg = pd.Series(buy_y_above_lin_reg, df2_copy.index[2:])\n",
    "    pd_buy_x_below_lin_reg_s = pd.Series(buy_x_below_lin_reg_s, df1_copy.index[2:])\n",
    "    pd_buy_y_above_lin_reg_s = pd.Series(buy_y_above_lin_reg_s, df2_copy.index[2:])\n",
    "    pd_buy_x_below_lin_reg_m = pd.Series(buy_x_below_lin_reg_m, df1_copy.index[2:])\n",
    "    pd_buy_y_above_lin_reg_m = pd.Series(buy_y_above_lin_reg_m, df2_copy.index[2:])\n",
    "\n",
    "\n",
    "    dfzs = ( ( res_data - res_data.mean() ) / res_data.std() )\n",
    "    dfzs_s = ( ( res_data_s - res_data_s.mean() ) / res_data_s.std() )\n",
    "    dfzs_m = ( ( res_data_m - res_data_m.mean() ) / res_data_m.std() )\n",
    "\n",
    "    # opposite_date_index = []\n",
    "    # for idx in range(6, (len(x)-6) + 1):  \n",
    "    #     idx2 = idx + start\n",
    "    #     if check_opposite_signs_fixed(x, y, idx2):\n",
    "    #         opposite_date_index.append(idx2)\n",
    "    # print(opposite_date_index)\n",
    "    # for idx in range(6, (len(x)-6) + 1):  # Start from 3 to ensure we have at least 2 previous days.\n",
    "    #     idx2 = idx + start\n",
    "    #     # print(idx2)\n",
    "    #     # print(x[idx2])\n",
    "    #     if check_opposite_signs(x, y, idx2):\n",
    "    #         # opposite_dates.append(df1.iloc[idx-1]['Date'])\n",
    "    #         opposite_date_index.append(idx2)\n",
    "    #         print(idx2)\n",
    "\n",
    "    # Filter dataframes for opposite_dates\n",
    "    # df1_opposite = x[df1['Date'].isin(opposite_dates)]\n",
    "    # df2_opposite = y[df2['Date'].isin(opposite_dates)]\n",
    "    # print(len(df1_opposite))\n",
    "\n",
    "    # df1_normalized_filtered, df2_normalized_filtered \n",
    "    # df1_n_minmax_filtered,   df2_n_minmax_filtered\n",
    "    # df1_filtered,            df2_filtered\n",
    "\n",
    "    # Main plot\n",
    "    axs[0].plot(df1_copy['Close'], label='Intraday F')\n",
    "    axs[0].plot(df2_copy['Close'], label='Intraday GM')\n",
    "    axs[0].legend()\n",
    "\n",
    "    axs[1].plot(df1_start['Close'], label='F normalized start')\n",
    "    axs[1].plot(df2_start['Close'], label='GM normalized start')\n",
    "    axs[1].legend()\n",
    "\n",
    "    axs[2].plot(df1_n_minmax['Close'], label='F minmax')\n",
    "    axs[2].plot(df2_n_minmax['Close'], label='GM minmax')\n",
    "    axs[2].legend()\n",
    "\n",
    "    # axs[3].plot(res_data, label='res_data')\n",
    "    # axs[3].plot(res_ema, label='res_ema')\n",
    "    # axs[3].axhline(0, color='red') # Add horizontal line at y=0 for reference \n",
    "    # axs[3].axhline(1, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[3].axhline(-1, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[3].axhline(2, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[3].axhline(-2, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[3].legend()\n",
    "\n",
    "    # axs[4].plot(res_data_s, label='res_data_s')\n",
    "    # axs[4].plot(res_ema_s, label='res_ema_s')\n",
    "    # axs[4].axhline(0, color='red') # Add horizontal line at y=0 for reference \n",
    "    # axs[4].axhline(1, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[4].axhline(-1, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[4].axhline(2, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[4].axhline(-2, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[4].legend()\n",
    "\n",
    "    # axs[5].plot(res_data_m, label='res_data_m')\n",
    "    # axs[5].plot(res_ema_m, label='res_ema_m')\n",
    "    # axs[5].axhline(0, color='red') # Add horizontal line at y=0 for reference \n",
    "    # axs[5].legend()\n",
    "\n",
    "    # axs[6].plot(zscore, label='zscore')\n",
    "    # axs[6].axhline(0, color='red') # Add horizontal line at y=0 for reference\n",
    "    # axs[6].axhline(1, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[6].axhline(-1, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[6].axhline(2, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[6].axhline(-2, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[6].legend()\n",
    "\n",
    "    # axs[7].plot(zscore_s, label='zscore_s ')\n",
    "    # axs[7].axhline(0, color='red') # Add horizontal line at y=0 for reference\n",
    "    # axs[7].axhline(1, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[7].axhline(-1, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[7].axhline(2, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[7].axhline(-2, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[7].legend()\n",
    "\n",
    "    # axs[8].plot(zscore_m, label='zscore_m')\n",
    "    # axs[8].axhline(0, color='red') # Add horizontal line at y=0 for reference\n",
    "    # axs[8].legend()\n",
    "\n",
    "    # axs[9].plot(dfzs, label='dfzs')\n",
    "    # axs[9].axhline(0, color='red') # Add horizontal line at y=0 for reference\n",
    "    # axs[9].axhline(1, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[9].axhline(-1, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[9].axhline(2, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[9].axhline(-2, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[9].legend()\n",
    "\n",
    "    # axs[10].plot(dfzs_s, label='dfzs_s')\n",
    "    # axs[10].axhline(0, color='red') # Add horizontal line at y=0 for reference\n",
    "    # axs[10].axhline(1, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[10].axhline(-1, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[10].axhline(2, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[10].axhline(-2, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[10].legend()\n",
    "\n",
    "    # axs[11].plot(dfzs_m, label='dfzs_m')\n",
    "    # axs[11].axhline(0, color='red') # Add horizontal line at y=0 for reference\n",
    "    # axs[11].axhline(1, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[11].axhline(-1, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[11].axhline(2, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[11].axhline(-2, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[11].legend()\n",
    "\n",
    "    # axs[9].plot(res_ema, label='res_ema')\n",
    "    # axs[9].axhline(0, color='red') # Add horizontal line at y=0 for reference\n",
    "    # axs[9].axhline(1, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[9].axhline(-1, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[9].axhline(2, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[9].axhline(-2, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[9].legend()\n",
    "\n",
    "    # axs[10].plot(res_ema_s, label='res_ema_s')\n",
    "    # axs[10].axhline(0, color='red') # Add horizontal line at y=0 for reference\n",
    "    # axs[10].axhline(1, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[10].axhline(-1, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[10].axhline(2, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[10].axhline(-2, linestyle='--', color='gray') # Add horizontal line at y=0 for reference \n",
    "    # axs[10].legend()\n",
    "\n",
    "    # axs[11].plot(res_ema_m, label='res_ema_m')\n",
    "    # axs[11].axhline(0, color='red') # Add horizontal line at y=0 for reference\n",
    "    # axs[11].legend()\n",
    "\n",
    "\n",
    "\n",
    "    # axs[5].plot(df1_copy['Close'], color='red', label='Intraday F')\n",
    "    # axs[5].plot(df2_copy['Close'], color='red', label='Intraday GM')\n",
    "    # axs[5].axhline(0, color='green') # Add horizontal line at y=0 for reference\n",
    "    # axs[5].plot(combo_dates_x, color='green')\n",
    "    # axs[5].plot(combo_dates_y, color='green')\n",
    "    # # axs[0].scatter(x_points, y_points, color='red', marker='o', label='Points')\n",
    "    # axs[3].legend()\n",
    "\n",
    "    # axs[6].axhline(0, color='red') # Add horizontal line at y=0 for reference\n",
    "    # axs[6].plot(df1_copy['Close'], color='black', label='Intraday F')\n",
    "    # axs[6].plot(combo_dates_x, color='green', label='Intraday GM')\n",
    "    # axs[6].plot(pd_date_lin_reg_x, label='F (lin_reg_x)')\n",
    "    # axs[6].legend()\n",
    "\n",
    "    # axs[7].axhline(0, color='red') # Add horizontal line at y=0 for reference\n",
    "    # axs[7].plot(df2_copy['Close'], color='black', label='Intraday GM')\n",
    "    # axs[7].plot(combo_dates_y, color='red', label='Intraday GM')\n",
    "    # axs[7].plot(pd_date_lin_reg_y, label='GM (lin_reg_y)')\n",
    "    # axs[7].legend()\n",
    "\n",
    "    # # pd_buy_x_below_lin_reg = pd.Series(buy_x_below_lin_reg, df1.index[2:])\n",
    "    # # pd_buy_y_above_lin_reg = pd.Series(buy_y_above_lin_reg, df2.index[2:])\n",
    "    # axs[8].scatter(pd_buy_x_below_lin_reg.index, pd_buy_x_below_lin_reg.values, label='res < 0 BUY F SELL GM')\n",
    "    # axs[8].axhline(0, color='red') # Add horizontal line at y=0 for reference\n",
    "    # axs[8].legend()\n",
    "\n",
    "    # # print(\"len(pd_buy_y_above_lin_reg.keys)\", len(pd_buy_y_above_lin_reg.keys))\n",
    "    # axs[9].scatter(pd_buy_y_above_lin_reg.index,pd_buy_y_above_lin_reg.values, label='res > 0 SELL F BUY GM')\n",
    "    # axs[9].axhline(0, color='red') # Add horizontal line at y=0 for reference\n",
    "    # axs[9].legend()\n",
    "\n",
    "    plt.show()\n",
    "\n",
    "def main():\n",
    "\n",
    "    # stock_symbol_1 = 'F'\n",
    "    # stock_symbol_2 = 'GM'\n",
    "    # start_date = '2013-01-01'\n",
    "    # end_date = '2014-06-01'\n",
    "    # stock_data_1 = yf.download(ticker=stock_symbol_1, start=start_date, end=end_date)\n",
    "    # stock_data_2 = yf.download(ticker=stock_symbol_2, start=start_date, end=end_date)\n",
    "    # df1 = read_and_normalize(stock_data_1, start_date)\n",
    "    # df2 = read_and_normalize(stock_data_2, end_date)\n",
    "\n",
    "    start = 1000   # change these to the values you want\n",
    "    end = 2000   # change these to the values you want\n",
    "\n",
    "    # Read and normalize data at start\n",
    "    df1_normalized, df1_n_minmax, df1 = read_and_normalize('/Users/walkerhutchinson/Desktop/ThunderFund/meteor_code/F_2014_15min.csv', start)\n",
    "    df2_normalized, df2_n_minmax, df2 = read_and_normalize('/Users/walkerhutchinson/Desktop/ThunderFund/meteor_code/GM_2014_15min.csv', start)\n",
    "    \n",
    "    # Filter by index\n",
    "    df1_start, df1_n_minmax, df1_copy = filter_by_index(df1_normalized, df1_n_minmax, df1, start, end)\n",
    "    df2_start, df2_n_minmax, df2_copy = filter_by_index(df2_normalized, df2_n_minmax, df2, start, end)\n",
    "\n",
    "    # Plot\n",
    "    plot(df1_start, df1_n_minmax, df1_copy, df2_start, df2_n_minmax, df2_copy, start)\n",
    "\n",
    "if __name__ == \"__main__\":\n",
    "    main()\n"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['n', 'windows'])\n",
      "\n",
      "dict_values([10, {'AAPL': array([nan, nan, nan, nan, nan, nan, nan, nan, nan, nan]), 'SPY': array([nan, nan, nan, nan, nan, nan, nan, nan, nan, nan]), 'GME': array([nan, nan, nan, nan, nan, nan, nan, nan, nan, nan]), 'AMC': array([nan, nan, nan, nan, nan, nan, nan, nan, nan, nan]), 'F': array([nan, nan, nan, nan, nan, nan, nan, nan, nan, nan]), 'GM': array([nan, nan, nan, nan, nan, nan, nan, nan, nan, nan])}])\n",
      "\n",
      "[ nan  nan  nan  nan  nan  nan  nan  nan  nan 100.]\n"
     ]
    }
   ],
   "source": [
    "from ibapi.wrapper import EWrapper\n",
    "from ibapi.client import EClient\n",
    "from ibapi.contract import Contract\n",
    "from ibapi.order import Order\n",
    "\n",
    "import numpy as np\n",
    "\n",
    "ticker_groups = [ ['AAPL','SPY'], [\"GME\",\"AMC\"], [\"F\",\"GM\"] ]    \n",
    "\n",
    "def create_contract(symbol):\n",
    "    contract = Contract()\n",
    "    contract.symbol = symbol\n",
    "    contract.secType = 'STK' \n",
    "    contract.exchange = 'SMART'\n",
    "    contract.currency = 'USD'\n",
    "    return contract\n",
    "\n",
    "class RollingWindow:\n",
    "    def __init__(self, tickers, n):\n",
    "        self.n = n\n",
    "        self.windows = {ticker: np.full(n, np.nan) for ticker in tickers}\n",
    "\n",
    "    def update(self, ticker, price):\n",
    "        if ticker in self.windows:\n",
    "            self.windows[ticker] = np.roll(self.windows[ticker], shift=-1)\n",
    "            self.windows[ticker][-1] = price\n",
    "\n",
    "    def get_window(self, ticker):\n",
    "        return self.windows.get(ticker)\n",
    "\n",
    "contracts_groups = [[create_contract(ticker) for ticker in group] for group in ticker_groups]\n",
    "all_tickers = [ticker for group in ticker_groups for ticker in group]\n",
    "rw = RollingWindow(all_tickers, 10)\n",
    "\n",
    "print(vars(rw).keys())\n",
    "print()\n",
    "print(vars(rw).values())\n",
    "print()\n",
    "\n",
    "rw.update(\"AAPL\", 100)  \n",
    "print(rw.get_window(ticker='AAPL'))\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "dict_keys(['n', 'windows'])\n",
      "\n",
      "dict_values([10,    AAPL  SPY  GME  AMC   F  GM\n",
      "0   NaN  NaN  NaN  NaN NaN NaN\n",
      "1   NaN  NaN  NaN  NaN NaN NaN\n",
      "2   NaN  NaN  NaN  NaN NaN NaN\n",
      "3   NaN  NaN  NaN  NaN NaN NaN\n",
      "4   NaN  NaN  NaN  NaN NaN NaN\n",
      "5   NaN  NaN  NaN  NaN NaN NaN\n",
      "6   NaN  NaN  NaN  NaN NaN NaN\n",
      "7   NaN  NaN  NaN  NaN NaN NaN\n",
      "8   NaN  NaN  NaN  NaN NaN NaN\n",
      "9   NaN  NaN  NaN  NaN NaN NaN])\n",
      "\n",
      "0      NaN\n",
      "1      NaN\n",
      "2      NaN\n",
      "3      NaN\n",
      "4      NaN\n",
      "5      NaN\n",
      "6      NaN\n",
      "7      NaN\n",
      "8      NaN\n",
      "9    100.0\n",
      "Name: SPY, dtype: float64\n",
      "0   NaN\n",
      "1   NaN\n",
      "2   NaN\n",
      "3   NaN\n",
      "4   NaN\n",
      "5   NaN\n",
      "6   NaN\n",
      "7   NaN\n",
      "8   NaN\n",
      "9   NaN\n",
      "Name: AAPL, dtype: float64\n"
     ]
    }
   ],
   "source": [
    "from ibapi.wrapper import EWrapper\n",
    "from ibapi.client import EClient\n",
    "from ibapi.contract import Contract\n",
    "from ibapi.order import Order\n",
    "\n",
    "import pandas as pd\n",
    "import numpy as np\n",
    "\n",
    "ticker_groups = [ ['AAPL','SPY'], [\"GME\",\"AMC\"], [\"F\",\"GM\"] ]    \n",
    "\n",
    "def create_contract(symbol):\n",
    "    contract = Contract()\n",
    "    contract.symbol = symbol\n",
    "    contract.secType = 'STK' \n",
    "    contract.exchange = 'SMART'\n",
    "    contract.currency = 'USD'\n",
    "    return contract\n",
    "\n",
    "class RollingWindow:\n",
    "    def __init__(self, tickers, n):\n",
    "        self.n = n\n",
    "        self.windows = pd.DataFrame({ticker: pd.Series([np.nan] * n) for ticker in tickers})\n",
    "        # self.windows = pd.DataFrame({ticker: pd.Series([pd.NA] * n) for ticker in tickers})\n",
    "\n",
    "    def update(self, ticker, price):\n",
    "        if ticker in self.windows:\n",
    "            self.windows[ticker] = self.windows[ticker].shift(-1)\n",
    "            self.windows.at[self.n - 1, ticker] = price\n",
    "\n",
    "    def get_window(self, ticker):\n",
    "        return self.windows.get(ticker)\n",
    "\n",
    "contracts_groups = [[create_contract(ticker) for ticker in group] for group in ticker_groups]\n",
    "all_tickers = [ticker for group in ticker_groups for ticker in group]\n",
    "rw = RollingWindow(all_tickers, 10)\n",
    "\n",
    "print(vars(rw).keys())\n",
    "print()\n",
    "print(vars(rw).values())\n",
    "print()\n",
    "\n",
    "rw.update(\"SPY\", 100)  \n",
    "print(rw.get_window(ticker='SPY'))\n",
    "print(rw.get_window(ticker='AAPL'))\n"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.10.4"
  },
  "orig_nbformat": 4
 },
 "nbformat": 4,
 "nbformat_minor": 2
}