single_gvkey_results_compiler.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {
    "scrolled": true
   },
   "source": [
    "## FUNCTION FOR DESCRIPTIVE STATISTICS: \n",
    "\n",
    "* This is the supporting single-firm / single-gvkey function for the main project found here:\n",
    "    * https://github.com/Jspano95/Jspano_MScQFin_Thesis\n",
    "    \n",
    "* The actual function is found in the above repository in (.py) format; this is a stylised notebook with an example at the bottom."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {
    "scrolled": true
   },
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\JasonSpano\\anaconda3\\lib\\site-packages\\patsy\\constraint.py:13: DeprecationWarning: Using or importing the ABCs from 'collections' instead of from 'collections.abc' is deprecated since Python 3.3, and in 3.9 it will stop working\n",
      "  from collections import Mapping\n"
     ]
    }
   ],
   "source": [
    "## import packages ## \n",
    "import warnings\n",
    "import sys\n",
    "if not sys.warnoptions:\n",
    "    warnings.filterwarnings(\"once\")  \n",
    "\n",
    "## graphing packages ## \n",
    "import matplotlib.pyplot as plt\n",
    "import seaborn as sns\n",
    "%matplotlib inline\n",
    "\n",
    "## date working / printing packages\n",
    "import datetime\n",
    "from datetime import date, timedelta, datetime\n",
    "from tabulate import tabulate\n",
    "\n",
    "## stats/math/econometrics packages \n",
    "import pandas as pd\n",
    "import numpy as np    \n",
    "import scipy as sp\n",
    "from scipy import stats, integrate, optimize\n",
    "from statsmodels.tsa.vector_ar import vecm\n",
    "from statsmodels.tsa.stattools import adfuller, zivot_andrews \n",
    "import statsmodels.formula.api as smf  #VAR package contained within \n",
    "import statsmodels.tsa.api as smt\n",
    "from arch.unitroot import DFGLS, ADF, ZivotAndrews, VarianceRatio\n",
    "\n",
    "## econometrics warning utilities\n",
    "from statsmodels.tools.sm_exceptions import ValueWarning\n",
    "from arch.utility.exceptions import (\n",
    "    InfeasibleTestException,\n",
    "    InvalidLengthWarning,\n",
    "    invalid_length_doc)\n",
    "warnings.filterwarnings(\"once\", category = ValueWarning)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "## pickle file (from the main project)\n",
    "sorted_alldata_df_final_adf_results = pd.read_pickle(\"./sorted_alldata_df_final_adf_results.pkl\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "class color:\n",
    "   #a simplified way to easily call different style elements for displaying outputs\n",
    "   RED = '\\033[91m'\n",
    "   BOLD = '\\033[1m'\n",
    "   UNDERLINE = '\\033[4m'\n",
    "   GREEN = '\\033[92m'\n",
    "   HEADER = '\\033[95m' \n",
    "   OKBLUE = '\\033[94m'\n",
    "   WARNING = '\\033[93m'\n",
    "   FAIL = '\\033[91m'\n",
    "   END = '\\033[0m'"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": [
    "def single_series_model_outcomes_and_summary_statistics(gvkey_selection, dataframe, data_series, graphs='yes', \n",
    "                                    unit_root_tests='yes', vr_ratio='yes',\n",
    "                                   za_test='yes', vecm_model='yes', **kwargs):\n",
    "    \"\"\" \n",
    "    Returns all the key statistical tests and regressions models conducted on the entire data sample in the main project.\n",
    "    This function will run identical test specifications but pertaining only to a single specified GVKEY. \n",
    "    \n",
    "    Parameters\n",
    "    ----------\n",
    "    gvkey_selection: int\n",
    "        The selected GVKEY (unique group identifier)\n",
    "    dataframe: \n",
    "        The DataFrame which contains the relevant GVKEY's CDS and PECDS data series\n",
    "    data_series: array_like\n",
    "        The chosen primary data series to display summary statistics for\n",
    "    graphs: bool, optional\n",
    "        Will display data series with known breakpoints in graphical form\n",
    "    unit_root_tests: bool, optional\n",
    "        Will return the ADF and DFGLS unit root test results on the selected [data_series]\n",
    "    vr_ratio: bool, optional\n",
    "        Will return the Variance Ratio test on the selected [data_series]\n",
    "    vr_ratio_increment: int, optional\n",
    "        The size of the Variance Ratio increments to conduct the joint variance tests on. Default is 2.5%\n",
    "    za_test: bool, optional\n",
    "        Will return the results of the Zivot Andrews Breakpoint test\n",
    "    vecm_model: bool, optional\n",
    "        Will return the results of the Vector Error Correction Model and Granger Causality Test Results within the VECM framework\n",
    "        Associated price discovery leadership methods (GG and HAS measures) are also included.\n",
    "        \n",
    "    \n",
    "    \"\"\"\n",
    "    data_series = str(data_series)\n",
    "    \n",
    "    ###  group/gvkey general identifiers \n",
    "    gvkey_group_df = dataframe.loc[dataframe.gvkey==gvkey_selection]\n",
    "    \n",
    "    print(color.BOLD + '\\n', \"--\"*38, '\\n', \"--\"*38, '\\n', color.OKBLUE + \"//\"*10, \n",
    "          \"<< SUMMARY MODEL OUTCOMES VIEWER >> \",  \"//\"*9, color.END, '\\n', \"--\"*38, '\\n', \"--\"*38, '\\n')\n",
    "   \n",
    "    ## print general overview items for the selected GVKEY\n",
    "    print(tabulate([['COMPANY NAME', gvkey_group_df.company_name.iloc[0]],\n",
    "                   ['COMPANY SECTOR', gvkey_group_df.sector.iloc[0]],\n",
    "                   ['BOND ID', gvkey_group_df.bond_sym_id.iloc[0]]],\n",
    "                   headers=[color.BOLD + 'SELECTED GVKEY: ', str(gvkey_selection) + color.END],\n",
    "                   tablefmt='pretty', numalign='center'))\n",
    "\n",
    "    ### extract just the relevant date elements from the trade_date timestamp \n",
    "    time_min_string = str(gvkey_group_df.loc[gvkey_group_df.gvkey==gvkey_selection]['trade_date'].min())\n",
    "    time_max_string = str(gvkey_group_df.loc[gvkey_group_df.gvkey==gvkey_selection]['trade_date'].max())\n",
    "\n",
    "    time_min_str_strip = datetime.strptime(time_min_string, '%Y-%m-%d %H:%M:%S')\n",
    "    time_max_str_strip = datetime.strptime(time_max_string, '%Y-%m-%d %H:%M:%S')\n",
    "\n",
    "    date_ymd_min = time_min_str_strip.strftime('%Y-%m-%d')\n",
    "    date_ymd_max = time_max_str_strip.strftime('%Y-%m-%d')\n",
    "\n",
    "    print(tabulate([['TOTAL OBS', gvkey_group_df.loc[gvkey_group_df.gvkey==gvkey_selection][data_series].count()],\n",
    "                   ['FIRST OBS', date_ymd_min],\n",
    "                   ['LAST OBS', date_ymd_max],\n",
    "                   ['TIME HORIZON (DAYS)', (gvkey_group_df.loc[gvkey_group_df.gvkey==gvkey_selection]['trade_date'].max() - \n",
    "                                     gvkey_group_df.loc[gvkey_group_df.gvkey==gvkey_selection]['trade_date'].min()).days]],\n",
    "                   headers=[color.BOLD + 'SELECTED SERIES: ', data_series.upper() + color.END],\n",
    "                   tablefmt='pretty', numalign='center'))\n",
    "    \n",
    "    print(color.BOLD, \"// SUMMARY SERIES STATISTICS // \", color.END)\n",
    "    \n",
    "    \n",
    "    #### print general descriptive statistics pertaining to the selected series on the GVKEY\n",
    "    quartiles = np.quantile(gvkey_group_df.loc[gvkey_group_df.gvkey==gvkey_selection]['market_cds_spread'], [0.25, 0.75])\n",
    "    \n",
    "    print(tabulate([['MEAN', np.round(gvkey_group_df.loc[gvkey_group_df.gvkey==gvkey_selection][data_series].mean(), 2)],\n",
    "                    ['MIN VALUE', gvkey_group_df.loc[gvkey_group_df.gvkey==gvkey_selection][data_series].min()],\n",
    "                    ['MAX VALUE', gvkey_group_df.loc[gvkey_group_df.gvkey==gvkey_selection][data_series].max()],\n",
    "                    ['VALUE RANGE', np.round(np.ptp(gvkey_group_df.loc[gvkey_group_df.gvkey==gvkey_selection][data_series]),4)],\n",
    "                    ['25% QUANTILE', np.round(quartiles[0],2)],\n",
    "                    ['75% QUANTILE', np.round(quartiles[1],2)],\n",
    "                    ['INT-Q RANGE', np.round((quartiles[1] - quartiles[0]),2)],\n",
    "                    ['STD DEVIATION', np.round(gvkey_group_df.loc[gvkey_group_df.gvkey==gvkey_selection][data_series].std(), 2)],\n",
    "                    ['NORMALISED STDDEV', np.round(gvkey_group_df.loc[gvkey_group_df.gvkey==gvkey_selection][data_series].std() / \n",
    "                        gvkey_group_df.loc[gvkey_group_df.gvkey==gvkey_selection][data_series].mean(), 2)],\n",
    "                    ['SKEW', np.round(gvkey_group_df.loc[gvkey_group_df.gvkey==gvkey_selection][data_series].skew(),2)],\n",
    "                    ['KURTOSIS', np.round(gvkey_group_df.loc[gvkey_group_df.gvkey==gvkey_selection][data_series].kurtosis(),2)]],\n",
    "                    headers=[color.BOLD + 'DATA ITEM', 'VALUE' + color.END],\n",
    "                    tablefmt='pretty', numalign='center'))\n",
    "    \n",
    "    ## overlay skew/kurtosis with KDE of market CDS spread\n",
    "    if graphs=='yes':\n",
    "        try:\n",
    "            fig_cds_skew = plt.figure(figsize=(6, 4))\n",
    "\n",
    "            cds_skew_overlay_graph = fig_cds_skew.add_subplot(sns.distplot(gvkey_group_df[data_series],  \n",
    "                                                                           kde=True, fit=stats.norm))\n",
    "        \n",
    "            plt.title(\"{} SKEW AND KURTOSIS OVERLAID BY ~N(0,1) KDE\".format(\n",
    "                data_series.upper()), loc='center', fontsize=10)\n",
    "            \n",
    "            plt.show()\n",
    "            \n",
    "        except Exception: \n",
    "            print('\\n', color.BOLD + color.RED, \"Error Fitting KDE graph to selected series\", color.END, '\\n')\n",
    "\n",
    "    \n",
    "    ##### UNIT ROOT TESTS #####\n",
    "    ##### ADF TEST \n",
    "    \n",
    "    if unit_root_tests=='yes':\n",
    "        try:\n",
    "            print('\\n', '--'*38, '\\n', color.BOLD + \"UNIT ROOT TESTS\" + color.END)\n",
    "            \n",
    "            ADF_model = ADF(gvkey_group_df.loc[gvkey_group_df.gvkey==gvkey_selection][data_series], lags=10)\n",
    "            \n",
    "            dfgls_model = DFGLS(gvkey_group_df.loc[gvkey_group_df.gvkey==gvkey_selection][data_series], \n",
    "                               max_lags=10, method='BIC')\n",
    "        \n",
    "            if ADF_model.stat <= ADF_model.critical_values['5%']:\n",
    "                adf_model_outcome = ADF_model.alternative_hypothesis\n",
    "            else:\n",
    "                adf_model_outcome = ADF_model.null_hypothesis   \n",
    "        \n",
    "            if dfgls_model.stat <= dfgls_model.critical_values['5%']:\n",
    "                dfgls_model_outcome = dfgls_model.alternative_hypothesis\n",
    "            else:\n",
    "                dfgls_model_outcome = dfgls_model.null_hypothesis\n",
    "        \n",
    "            print(tabulate([['ADF TEST', np.round(ADF_model.stat, 4), \n",
    "                             np.round(ADF_model.critical_values['5%'],4), adf_model_outcome],\n",
    "               ['DFGLS TEST', np.round(dfgls_model.stat, 4), \n",
    "               np.round(dfgls_model.critical_values['5%'],4), dfgls_model_outcome]],\n",
    "               headers=[color.BOLD + 'TEST TYPE', 'TEST STAT', 'TEST 5% CV', 'TEST OUTCOME' + color.END],\n",
    "                           tablefmt='pretty', numalign='center'))\n",
    "        \n",
    "        except IndexError as unitroot_ie:\n",
    "            print(\"DFGLS/ADF MODEL ERROR //\", unitroot_ie.args)  \n",
    "            \n",
    "        except AssertionError as unitroot_ae:\n",
    "            print(\"ADF MODEL ERROR //\", unitroot_ae.args)\n",
    "        \n",
    "    else:\n",
    "        print(\"UNIT ROOT TESTING NOT SELECTED\")\n",
    "        \n",
    "    \n",
    "    ## VARIANCE RATIO\n",
    "    \n",
    "    if vr_ratio=='yes':\n",
    "        try:\n",
    "            print('\\n', color.BOLD + \"--\"*38 + '\\n', \"VARIANCE RATIO\" + color.END)\n",
    "\n",
    "            ## check if optional parameter is passed in for VR ratio increment\n",
    "            vr_ratio_increment = kwargs.get('vr_ratio_increment')\n",
    "            \n",
    "            ## if no optional argument is passed in for the Variance Ratio Test: Default is 2.5% (40 equal increments)\n",
    "            if vr_ratio_increment is None:\n",
    "                lag_length_vr_test = 0.025\n",
    "            else: \n",
    "                lag_length_vr_test = vr_ratio_increment\n",
    "\n",
    "            ## take the floor (lowest closest interger of the increment (lag-size) length)) & run model instance\n",
    "            variance_ratio_increment_size = np.floor(\n",
    "            lag_length_vr_test * len(gvkey_group_df.loc[gvkey_group_df.gvkey==gvkey_selection][data_series]))    \n",
    "\n",
    "            variance_ratio_model = VarianceRatio(gvkey_group_df.loc[gvkey_group_df.gvkey==gvkey_selection][data_series],\n",
    "                                                trend='c', robust=True, lags=int(variance_ratio_increment_size))\n",
    "\n",
    "            ## tabulate results of the variance ratio from the above specified test parameters:\n",
    "            print(tabulate([['VARIANCE RATIO', np.round(variance_ratio_model.vr, 2)],\n",
    "                           ['VR TEST STAT', np.round(variance_ratio_model.stat, 2)],\n",
    "                           ['VR P-VALUE', np.round(variance_ratio_model.pvalue, 4)],\n",
    "                           ['VR LAGS USED', np.round(variance_ratio_model.lags, 2)]],\n",
    "                           tablefmt='pretty', numalign='center'))\n",
    "\n",
    "            if variance_ratio_model.stat >= variance_ratio_model.critical_values['95%']:\n",
    "                print(color.BOLD + \"VR TEST-STATISTIC CONCLUSION:\", color.END + \"{}\".format(\n",
    "                    variance_ratio_model.alternative_hypothesis), '\\n', \"--\"*38)\n",
    "            else:\n",
    "                print(color.BOLD + \"VR TEST-STATISTIC CONCLUSION: \", color.END + \"{}\".format(\n",
    "                    variance_ratio_model.null_hypothesis), '\\n', \"--\"*38)\n",
    "                \n",
    "        except RuntimeWarning as vr_rtw:\n",
    "            print(vr_rtw.args)\n",
    "\n",
    "       \n",
    "    #### ZA BREAKPOINT TEST ####\n",
    "    if za_test=='yes':\n",
    "        print('\\n', color.BOLD + \"--\"*38 + '\\n', \"ZIVOT ANDREWS BREAKPOINT TEST\" + color.END)\n",
    "        \n",
    "        try:\n",
    "            statsmodels_za = zivot_andrews(gvkey_group_df.loc[gvkey_group_df.gvkey==gvkey_selection][data_series],\n",
    "                                            trim=0.2, maxlag=10, regression='c', autolag='t-stat')\n",
    "\n",
    "            ## assign an outcome to the ZA test based off the test statistic\n",
    "            if statsmodels_za[1] <= statsmodels_za[2]['5%']:\n",
    "                za_outcome_str = 'process is trend/break stationary'\n",
    "            else:\n",
    "                za_outcome_str = 'process is UR with structural break'\n",
    "            \n",
    "            print(tabulate([['ZA TEST STAT', np.round(statsmodels_za[1],2)], \n",
    "            ['5% ZA CRIT VALUE ', np.round(statsmodels_za[2]['5%'],4)],\n",
    "            ['ZA PVALUE ', np.round(statsmodels_za[3], 4)],\n",
    "            ['ZA OUTCOME ', za_outcome_str]],\n",
    "            headers=[color.BOLD + 'ZA TEST ITEM', 'VALUE' + color.END], \n",
    "            tablefmt='pretty', numalign='center'))             \n",
    "            \n",
    "            #### determine the real data associated with the breakpoint ####\n",
    "            #### [this occurs where the ADF unit root t-stat is minimised (most negative)]\n",
    "            ## define the date series from the original DF:\n",
    "            date_series = gvkey_group_df['trade_date']\n",
    "\n",
    "            ## find the corressponding date to the ZA breakpoint\n",
    "            index_location_za_bpoint = statsmodels_za[4]\n",
    "            \n",
    "            date_location_za = str(date_series.iloc[index_location_za_bpoint])\n",
    "            \n",
    "            date_location_za_strp = datetime.strptime(date_location_za, '%Y-%m-%d %H:%M:%S')\n",
    "            \n",
    "            date_location_za_clean = date_location_za_strp.strftime('%Y-%m-%d')\n",
    "\n",
    "            print(color.BOLD + \"CALCULATED BREAKPOINT DATE: \" + color.END + \"{}\".format(date_location_za_clean), '\\n',  \"--\"*38, '\\n')    \n",
    "\n",
    "        except (InfeasibleTestException, UnboundLocalError) as za_model_errors:\n",
    "             print(\"Unable to calculate ZivotAndrews Breakpoint Test - Reason: {}\".format(za_model_errors.args))\n",
    "    \n",
    "    else:\n",
    "        print('\\n', \"ZIVOT ANDREWS BREAKPOINT NOT CALCULATED. THIS MAY AFFECT PROPER CONSTRUCTION OF LINE-GRAPHS\", '\\n')                    \n",
    "\n",
    "    \n",
    "    ##### VECM ITEMS & PRICE DISCOVERY MEASURES #####\n",
    "    if vecm_model=='yes':\n",
    "        try:\n",
    "            print('\\n', \"--\"*38, '\\n', color.BOLD + \"VECM MODEL & PRICE DISCOVERY MEASURES\", color.END)\n",
    "\n",
    "            ## VECM MODEL CONSTRUCTION -- only valid on the two series: CDS + PECDS\n",
    "            vecm_data_df = pd.DataFrame(data=(gvkey_group_df['market_cds_spread'], gvkey_group_df['pecds'])).T\n",
    "\n",
    "            optimal_bic_lags = vecm.select_order(vecm_data_df, maxlags=10)\n",
    "\n",
    "            vecm_cointegration_rank = vecm.select_coint_rank(vecm_data_df, det_order=1, k_ar_diff = optimal_bic_lags.bic,\n",
    "                                                           method='trace',signif=0.05)\n",
    "\n",
    "            ## limit max cointegrating relationships to one as it's a dual-variable system.\n",
    "            if vecm_cointegration_rank.rank >=1:\n",
    "                cointegrating_rels = int(1)\n",
    "            else:\n",
    "                cointegrating_rels = int(0)\n",
    "                \n",
    "            print(color.BOLD + \" COINTEGRATION RANK: \" + color.END, \"{}\".format(cointegrating_rels),\n",
    "                 '\\n','--'*38)\n",
    "\n",
    "            vecm_model_fitted = vecm.VECM(vecm_data_df, k_ar_diff = optimal_bic_lags.bic, coint_rank=cointegrating_rels,\n",
    "                          deterministic='co').fit()\n",
    "\n",
    "            cholesky_decomp = np.linalg.cholesky(vecm_model_fitted.sigma_u)\n",
    "            sig_1 = cholesky_decomp[0, 0]\n",
    "            sig_12 = cholesky_decomp[1, 0]\n",
    "            sig_2 = cholesky_decomp[1, 1]\n",
    "\n",
    "            x_1 = vecm_model_fitted.alpha[0,0]\n",
    "            x_2 = vecm_model_fitted.alpha[1,0]\n",
    "\n",
    "            gg_val = np.round(vecm_model_fitted.alpha[1,0] / vecm_model_fitted.alpha[1,0] - vecm_model_fitted.pvalues_alpha[0,0], 2)\n",
    "\n",
    "            HAS_1 = np.round(( x_2**2 * (sig_1**2 - sig_12**2 / sig_2**2) )  / ( x_2**2 * sig_1**2 - 2*x_1*x_2*sig_12 + x_1**2 * sig_2**2 ),4)\n",
    "            HAS_2 = np.round(( (x_2 * sig_1 - x_1 * sig_12 / sig_1)**2 ) / ( x_2**2 * sig_1**2 - 2*x_1*x_2*sig_12 + x_1**2 * sig_2**2 ),4)\n",
    "            HAS_mid = np.round((HAS_2 + HAS_1) / 2,4)\n",
    "\n",
    "            print(tabulate([['GG VALUE', gg_val],\n",
    "                   ['HAS LOWER', HAS_1],\n",
    "                   ['HAS MID', HAS_mid],\n",
    "                   ['HAS UPPER', HAS_2]],\n",
    "                   headers=[color.BOLD + 'PRICE DISCOVERY', 'VALUE' + color.END], tablefmt='pretty', numalign='center'),\n",
    "                 '\\n', color.GREEN, \"[ VALUES > 0.5 FAVOUR CDS |&| VALUES < 0.5 FAVOUR BONDS ]\", color.END)\n",
    "\n",
    "            print(tabulate([['EQ(1) | Alpha(1) ', np.round(vecm_model_fitted.alpha[0,0], 5), np.round(vecm_model_fitted.pvalues_alpha[0,0], 4)],\n",
    "                   ['EQ(2) | Alpha(1)', np.round(vecm_model_fitted.alpha[1,0], 5), np.round(vecm_model_fitted.pvalues_alpha[1,0], 4)]],\n",
    "                   headers=[color.BOLD + 'VECM MODEL', 'TEST STAT','P-VALUE' + color.END],\n",
    "                   tablefmt='pretty', numalign='center'))\n",
    "\n",
    "            print('\\n', color.BOLD + \"// GRANGER CAUSALITY TESTS // \" + color.END)\n",
    "            print(tabulate([['PECDS CAUSES CDS',np.round(vecm_model_fitted.test_granger_causality(caused=0).test_statistic, 4),\n",
    "                           vecm_model_fitted.test_granger_causality(caused=0).conclusion_str[11:]],\n",
    "                           ['CDS CAUSES PECDS', np.round(vecm_model_fitted.test_granger_causality(caused=1).test_statistic, 4),\n",
    "                           vecm_model_fitted.test_granger_causality(caused=1).conclusion_str[11: ]]],\n",
    "                           headers=[color.BOLD + 'GRANGER TEST', 'TEST STAT',\n",
    "                          'TEST CONCLUSION' + color.END], tablefmt='pretty', numalign='center'))\n",
    "\n",
    "        except ValueError as vecm_ve:\n",
    "            print(vecm_ve.args)\n",
    "            \n",
    "        except InfeasibleTestException as vecm_ite:\n",
    "            print(vecm_ite.args)\n",
    "            \n",
    "        except IndexError as vecm_ie:\n",
    "            print('\\n', \"Highly probable no significant cointegrating relationship was found\", '\\n', vecm_ie.args)\n",
    "            \n",
    "            \n",
    "   \n",
    "    \n",
    "    \n",
    "    ## <OPTIONAL> show graphs by year for the CDS series\n",
    "    print(\"--\"*38, '\\n')\n",
    "    if graphs=='yes':\n",
    "        try:\n",
    "            print(color.BOLD + \"SELECTED VISUAL REPRESENTATIONS OF GVKEY [{}] |&| FOCUSED SERIES: [{}]\".format(\n",
    "                gvkey_selection, data_series.upper()) + color.END)\n",
    "\n",
    "            ## define a new DF with trade_date as the index for plotting the ZA breakdate\n",
    "            ## note: this graph calls the ZA breakdate from the DF (not from the above calculation)\n",
    "            ## this is to allow the graphs to display the supposed ZA breakdate while maintaining printing results as optional\n",
    "            gvkey_group_df_timeind = gvkey_group_df.set_index(['trade_date'])\n",
    "            za_bp_date_raw = str(gvkey_group_df.ZA_BREAKDATE.iloc[0])\n",
    "            za_bp_date_strp = datetime.strptime(za_bp_date_raw, '%Y-%m-%d %H:%M:%S')\n",
    "\n",
    "            fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))\n",
    "            fig.suptitle('GVKEY [{}] CDS & PECDS LINE GRAPHS WITH ZA-BREAKPOINT'.format(gvkey_selection))\n",
    "\n",
    "            ## PLOT CDS \n",
    "            sns.lineplot(x=gvkey_group_df_timeind.index, \n",
    "                         y='market_cds_spread', \n",
    "                         data=gvkey_group_df_timeind,  \n",
    "                         palette='winter',\n",
    "                         markers=True,\n",
    "                         dashes=False,\n",
    "                         legend='full',\n",
    "                         ax=ax1)\n",
    "\n",
    "            ## AFFIX THE ZIVOT-ANDREWS BREAKDPOINT \n",
    "            ax1.set_ylabel(\"DAILY CDS VALUES\", fontsize=12)\n",
    "            ax1.axvline(za_bp_date_strp, 0, color='r', linestyle='--', label='ZA BREAKPOINT')\n",
    "            ax1_labels=['ZA BREAKPOINT']\n",
    "            handles_1, _ = ax1.get_legend_handles_labels()\n",
    "            ax1.legend(handles=handles_1, labels=ax1_labels)\n",
    "\n",
    "            ## PLOT PECDS\n",
    "            sns.lineplot(x=gvkey_group_df_timeind.index, \n",
    "                         y=gvkey_group_df_timeind['pecds'], \n",
    "                         data=gvkey_group_df_timeind,  \n",
    "                         palette='RdGy_r',\n",
    "                         legend='full',\n",
    "                         ax=ax2)\n",
    "\n",
    "            ## AFFIX THE ZIVOT-ANDREWS BREAKDPOINT \n",
    "            ax2.set_ylabel(\"DAILY PECDS VALUES\",  fontsize=12)\n",
    "            ax2.axvline(za_bp_date_strp, 0, color='r', linestyle='--', label='ZA BREAKPOINT')\n",
    "            ax2_labels=['ZA BREAKPOINT']\n",
    "            handles_2, _ = ax2.get_legend_handles_labels()\n",
    "            ax2.legend(handles=handles_2, labels=ax2_labels)\n",
    "\n",
    "            plt.show()\n",
    "            \n",
    "        except ValueError as ve_graphs:\n",
    "            print(\"Zivot Andrews BP Error -- Full Graph Unavailable\", '\\n',\"--\"*38, '\\n', \"// SHOWING SIMPLIFIED VERSION // \")\n",
    "            \n",
    "            gvkey_group_df_timeind = gvkey_group_df.set_index(['trade_date'])\n",
    "            \n",
    "            fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))\n",
    "            fig.suptitle('GVKEY [{}] CDS & PECDS SIMPLE GRAPHS'.format(gvkey_selection))            \n",
    "            \n",
    "            ## plot just a simple line graph of both the: CDS and PECDS series \n",
    "            sns.lineplot(x=gvkey_group_df_timeind.index, \n",
    "                         y='market_cds_spread', \n",
    "                         data=gvkey_group_df_timeind,  \n",
    "                         palette='winter',\n",
    "                         markers=True,\n",
    "                         dashes=False,\n",
    "                         legend='full',\n",
    "                         ax=ax1)\n",
    "            \n",
    "            ax1.set_ylabel(\"DAILY CDS VALUES\", fontsize=12)\n",
    "\n",
    "            sns.lineplot(x=gvkey_group_df_timeind.index, \n",
    "                         y=gvkey_group_df_timeind['pecds'], \n",
    "                         data=gvkey_group_df_timeind,  \n",
    "                         palette='RdGy_r',\n",
    "                         legend='full',\n",
    "                         ax=ax2)\n",
    "\n",
    "            ax2.set_ylabel(\"DAILY PECDS VALUES\",  fontsize=12)            \n",
    "            \n",
    "    \n",
    "    else:\n",
    "        print('\\n', \"GRAPHS SET TO NO-SHOW\", '\\n', \"--\"*38)\n",
    "        pass\n",
    "\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {
    "scrolled": false
   },
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\u001b[1m\n",
      " ---------------------------------------------------------------------------- \n",
      " ---------------------------------------------------------------------------- \n",
      " \u001b[94m//////////////////// << SUMMARY MODEL OUTCOMES VIEWER >>  ////////////////// \u001b[0m \n",
      " ---------------------------------------------------------------------------- \n",
      " ---------------------------------------------------------------------------- \n",
      "\n",
      "+------------------+-----------------------------+\n",
      "| \u001b[1mSELECTED GVKEY:  |            1045\u001b[0m             |\n",
      "+------------------+-----------------------------+\n",
      "|   COMPANY NAME   | AMERICAN AIRLINES GROUP INC |\n",
      "|  COMPANY SECTOR  |        Transporation        |\n",
      "|     BOND ID      |           AMR.UY            |\n",
      "+------------------+-----------------------------+\n",
      "+---------------------+-------------------+\n",
      "|  \u001b[1mSELECTED SERIES:   | MARKET_CDS_SPREAD\u001b[0m |\n",
      "+---------------------+-------------------+\n",
      "|      TOTAL OBS      |        546        |\n",
      "|      FIRST OBS      |    2009-09-24     |\n",
      "|      LAST OBS       |    2014-05-30     |\n",
      "| TIME HORIZON (DAYS) |       1709        |\n",
      "+---------------------+-------------------+\n",
      "\u001b[1m // SUMMARY SERIES STATISTICS //  \u001b[0m\n",
      "+-------------------+---------+\n",
      "|     \u001b[1mDATA ITEM     |  VALUE\u001b[0m  |\n",
      "+-------------------+---------+\n",
      "|       MEAN        | 3430.22 |\n",
      "|     MIN VALUE     |  907.6  |\n",
      "|     MAX VALUE     | 5456.22 |\n",
      "|    VALUE RANGE    | 4548.62 |\n",
      "|   25% QUANTILE    | 1436.47 |\n",
      "|   75% QUANTILE    | 5456.22 |\n",
      "|    INT-Q RANGE    | 4019.75 |\n",
      "|   STD DEVIATION   | 2014.14 |\n",
      "| NORMALISED STDDEV |  0.59   |\n",
      "|       SKEW        |  -0.02  |\n",
      "|     KURTOSIS      |  -1.95  |\n",
      "+-------------------+---------+\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      " ---------------------------------------------------------------------------- \n",
      " \u001b[1mUNIT ROOT TESTS\u001b[0m\n",
      "+------------+-----------+------------+-----------------------------------+\n",
      "| \u001b[1mTEST TYPE  | TEST STAT | TEST 5% CV |           TEST OUTCOME\u001b[0m            |\n",
      "+------------+-----------+------------+-----------------------------------+\n",
      "|  ADF TEST  |  -1.0259  |   -2.867   | The process contains a unit root. |\n",
      "| DFGLS TEST |  -0.2413  |  -1.9826   | The process contains a unit root. |\n",
      "+------------+-----------+------------+-----------------------------------+\n",
      "\n",
      " \u001b[1m----------------------------------------------------------------------------\n",
      " VARIANCE RATIO\u001b[0m\n",
      "+----------------+--------+\n",
      "| VARIANCE RATIO |  1.02  |\n",
      "|  VR TEST STAT  |  0.96  |\n",
      "|   VR P-VALUE   | 0.3392 |\n",
      "|  VR LAGS USED  |   13   |\n",
      "+----------------+--------+\n",
      "\u001b[1mVR TEST-STATISTIC CONCLUSION:  \u001b[0mThe process is a random walk. \n",
      " ----------------------------------------------------------------------------\n",
      "\n",
      " \u001b[1m----------------------------------------------------------------------------\n",
      " ZIVOT ANDREWS BREAKPOINT TEST\u001b[0m\n",
      "+------------------+-------------------------------------+\n",
      "|   \u001b[1mZA TEST ITEM   |                VALUE\u001b[0m                |\n",
      "+------------------+-------------------------------------+\n",
      "|   ZA TEST STAT   |                 0.0                 |\n",
      "| 5% ZA CRIT VALUE |               -4.8107               |\n",
      "|    ZA PVALUE     |                  0                  |\n",
      "|    ZA OUTCOME    | process is UR with structural break |\n",
      "+------------------+-------------------------------------+\n",
      "\u001b[1mCALCULATED BREAKPOINT DATE: \u001b[0m2010-10-15 \n",
      " ---------------------------------------------------------------------------- \n",
      "\n",
      "\n",
      " ---------------------------------------------------------------------------- \n",
      " \u001b[1mVECM MODEL & PRICE DISCOVERY MEASURES \u001b[0m\n",
      "\u001b[1m COINTEGRATION RANK: \u001b[0m 1 \n",
      " ----------------------------------------------------------------------------\n",
      "+-----------------+--------+\n",
      "| \u001b[1mPRICE DISCOVERY | VALUE\u001b[0m  |\n",
      "+-----------------+--------+\n",
      "|    GG VALUE     |  0.49  |\n",
      "|    HAS LOWER    |  0.98  |\n",
      "|     HAS MID     | 0.9804 |\n",
      "|    HAS UPPER    | 0.9807 |\n",
      "+-----------------+--------+ \n",
      " \u001b[92m [ VALUES > 0.5 FAVOUR CDS |&| VALUES < 0.5 FAVOUR BONDS ] \u001b[0m\n",
      "+------------------+-----------+---------+\n",
      "|    \u001b[1mVECM MODEL    | TEST STAT | P-VALUE\u001b[0m |\n",
      "+------------------+-----------+---------+\n",
      "| EQ(1) | Alpha(1) |  0.00086  | 0.5083  |\n",
      "| EQ(2) | Alpha(1) |   3e-05   |   0.0   |\n",
      "+------------------+-----------+---------+\n",
      "\n",
      " \u001b[1m// GRANGER CAUSALITY TESTS // \u001b[0m\n",
      "+------------------+-----------+--------------------+\n",
      "|   \u001b[1mGRANGER TEST   | TEST STAT |  TEST CONCLUSION\u001b[0m   |\n",
      "+------------------+-----------+--------------------+\n",
      "| PECDS CAUSES CDS |   0.038   | fail to reject H_0 |\n",
      "| CDS CAUSES PECDS |  33.4838  |     reject H_0     |\n",
      "+------------------+-----------+--------------------+"
     ]
    },
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "C:\\Users\\JasonSpano\\anaconda3\\lib\\site-packages\\numpy\\matrixlib\\defmatrix.py:1111: PendingDeprecationWarning: the matrix subclass is not the recommended way to represent matrices or deal with linear algebra (see https://docs.scipy.org/doc/numpy/user/numpy-for-matlab-users.html). Please adjust your code to use regular ndarray.\n",
      "  return matrix(concatenate(arr_rows, axis=0))\n"
     ]
    },
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "\n",
      "---------------------------------------------------------------------------- \n",
      "\n",
      "\u001b[1mSELECTED VISUAL REPRESENTATIONS OF GVKEY [1045] |&| FOCUSED SERIES: [MARKET_CDS_SPREAD]\u001b[0m\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 1008x432 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "#E.G. \n",
    "single_series_model_outcomes_and_summary_statistics(gvkey_selection=1045, dataframe=sorted_alldata_df_final_adf_results,\n",
    "                                data_series='market_cds_spread', graphs='yes', vr_ratio_increment=0.025,\n",
    "                                unit_root_tests='yes', vr_ratio='yes', \n",
    "                               za_test='yes', vecm_model='yes')\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {
    "scrolled": true
   },
   "outputs": [],
   "source": []
  }
 ],
 "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.8.5"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}