From 6a4cca930528379de61ef8852ff36b2708bfcde9 Mon Sep 17 00:00:00 2001 From: Doug Ransom Date: Fri, 2 Feb 2024 09:56:22 -0800 Subject: [PATCH] Squashed commit of the following: commit 0f7a7e8afed6af53f0c5503703e589a168b75a7b Author: Doug Ransom Date: Fri Feb 2 09:33:50 2024 -0800 Fixed logging intialization in sample_plots deleted extraneous and incorrect powershell script test.ps1 Changed from 'flit build' to 'build' to build the package. commit 52f0c2dc8276b3b9005945cdd5825fc737a53696 Author: Doug Ransom Date: Sat Jul 22 12:10:45 2023 -0700 add vix1d commit 4e32d478abcfb96a143b32144730715aeac56602 Author: Doug Ransom Date: Wed Jul 19 14:03:43 2023 -0700 fixed gaps in 2013 futures. commit c9719120cb09017112b95b8dcf410fc567758abd Author: Doug Ransom Date: Tue Jul 18 09:24:22 2023 -0700 added a test to check for same dates on SHORTVOL and futures trade dates. commit 54bac5db9f39e910f81f0e4fbd93dea62829aa95 Author: Doug Ransom Date: Sat Jul 15 13:47:48 2023 -0700 checkpoint commit cd86c99cf6f4b53c2f167148483eb18bee133590 Author: Doug Ransom Date: Sat Jul 15 10:49:49 2023 -0700 checkpoint commit 81737eeb31b71fcbc99f87cc8da7b1b28050ae3a Author: Doug Ransom Date: Sat Jul 15 10:20:45 2023 -0700 checkpoint commit c66298783b9c52be09c9707ccb7a37ace034d8a2 Author: Doug Ransom Date: Sat Jul 15 10:03:23 2023 -0700 checkpiont commit c1ea6653142139e0bd8430987967c0f31233c592 Author: Doug Ransom Date: Sat Jul 15 10:02:11 2023 -0700 checkpoint commit 00435ccaf5b4683acdc7e69b9a4b2c6e1ba3a275 Author: Doug Ransom Date: Sat Jul 15 09:24:16 2023 -0700 checkpoint commit b956c7f00f79920a0672caf0bdf868d1105fb1f0 Author: Doug Ransom Date: Sat Jul 15 06:23:23 2023 -0700 basis prototype commit 7210b0c43da75526961aa4be26be23d8006079ce Author: Doug Ransom Date: Wed Jul 5 16:38:15 2023 -0700 updating commit 8cf936c91521ade045dbb542320b95f024a5221e Author: Doug Ransom Date: Wed Jul 5 14:02:47 2023 -0700 updating commit 9d3577fc9da84ef7477e88bee8c0ac7a2c39da4a Author: Doug Ransom Date: Wed Jul 5 13:59:35 2023 -0700 updating from main commit c62789c3fe913862a4d4938fadbbefc84c5459a0 Author: Doug Ransom Date: Wed Jul 5 13:57:35 2023 -0700 updating from main commit e4258d6c1f9ec6836334c3a5ab7064af6ec42677 Author: Doug Ransom Date: Wed Jul 5 13:09:27 2023 -0700 python_publish.yml commit 198d93bb7f8a571284040fddbe58bb7782533e8e Author: Doug Ransom Date: Wed Jul 5 10:54:07 2023 -0700 Renamed function to be more appropriate. commit fe724b2ba88def4acf825a9ca305c6917a286a77 Author: Doug Ransom Date: Wed Jul 5 10:51:21 2023 -0700 The monthly interpolation of expiry date is close to working. Same with the weighted front two months. A couple unit tests might reveal some subtly bugs. commit 481454418d1b0c6991fcef47661fd189b18bb5af Author: Doug Ransom Date: Wed Jul 5 07:02:34 2023 -0700 checkpoint commit f6988a6b5a8c3888beed43f4cfc3c160f284eaa7 Author: Doug Ransom Date: Wed Jul 5 06:04:14 2023 -0700 checkpoint. commit 7a8746c460692a0db3c66d7a77f3f1fb8c71d69d Author: Doug Ransom Date: Tue Jul 4 16:41:03 2023 -0700 removed unused test file commit 60d0183cdf10754326fc61f4b4c33e382a77feef Author: Doug Ransom Date: Tue Jul 4 16:38:02 2023 -0700 corrected weight calculations commit 43ca57663452820ea97212f97f438b7fac1bdd53 Author: Doug Ransom Date: Tue Jul 4 14:24:27 2023 -0700 added ovx commit 1d0a8f570faa6213cb097a399faf0534ed18a2c7 Author: Doug Ransom Date: Tue Jul 4 14:12:04 2023 -0700 added shortvol, longvol commit fe4eafbf833c428ce8a5a42ff74c171dd1829135 Author: Doug Ransom Date: Tue Jul 4 14:06:18 2023 -0700 added vvix and VXTLT, GVZ to sample plot. commit 073fd8844a69a95ac1470af1a2806a29af37563e Author: Doug Ransom Date: Tue Jul 4 13:38:07 2023 -0700 . commit 78531b6ee9fe2b00877b57b4581d5853d4462b0e Author: Doug Ransom Date: Tue Jul 4 13:21:58 2023 -0700 checkpoint, tests work when pandas_market_calendars work. commit 70233bec75a950ff223c3cd7a48c118fffc7450a Author: Doug Ransom Date: Tue Jul 4 13:18:07 2023 -0700 checkpoint. commit 7f080d51d1ab3d4f6afb5eecd53c1e32ba0c1974 Author: Doug Ransom Date: Tue Jul 4 12:24:02 2023 -0700 checkpoint --- .github/workflows/python_publish.yml | 24 +- README.md | 10 + pyproject.toml | 5 +- src/vix_utils/__init__.py | 4 +- src/vix_utils/continuous_maturity.py | 6 +- src/vix_utils/download_vix_futures.py | 28 +- src/vix_utils/examples/a_t.ipynb | 43 + src/vix_utils/examples/hello_x.py | 7 + src/vix_utils/examples/sample_load_data.py | 66 +- src/vix_utils/examples/sample_plots.py | 32 +- src/vix_utils/examples/sample_utils.py | 0 .../examples/vix_utils use in Jupyter.ipynb | 159 - src/vix_utils/examples/vix_utils xarray.ipynb | 1387 +++++++++ src/vix_utils/examples/vix_utils.ipynb | 2585 +++++++++++++++++ src/vix_utils/vix_cash_term_structure.py | 30 +- src/vix_utils/vixutil.py | 16 +- test.ps1 | 11 - test/test_read_vix_futures_history.py | 23 +- 18 files changed, 4191 insertions(+), 245 deletions(-) create mode 100644 src/vix_utils/examples/a_t.ipynb create mode 100644 src/vix_utils/examples/hello_x.py delete mode 100644 src/vix_utils/examples/sample_utils.py delete mode 100644 src/vix_utils/examples/vix_utils use in Jupyter.ipynb create mode 100644 src/vix_utils/examples/vix_utils xarray.ipynb create mode 100644 src/vix_utils/examples/vix_utils.ipynb delete mode 100644 test.ps1 diff --git a/.github/workflows/python_publish.yml b/.github/workflows/python_publish.yml index 1c7c11d..9110a34 100644 --- a/.github/workflows/python_publish.yml +++ b/.github/workflows/python_publish.yml @@ -1,14 +1,14 @@ -name: Publish Package 📦 to Test PyPI +name: Publish Package 📦 to PyPI on: release: types: [published] # with prerelease and release permissions: contents: read - + id-token: write # IMPORTANT: this permission is mandatory for trusted publishing jobs: - publish: - # Set up the environment `CI` references the secret `TEST_PYPI_API_TOKEN` in repository settings + build_and_publish: + # Set up the environment `CI` references the secret `PYPI_API_TOKEN` in repository settings # https://docs.github.com/en/actions/deployment/targeting-different-environments/using-environments-for-deployment#referencing-an-environment environment: CI runs-on: ubuntu-latest @@ -16,14 +16,10 @@ jobs: - uses: actions/checkout@v2 - name: Installing build Dependencies run: | - python -m pip install --upgrade pip - python -m pip install flit - - name: Building package with flit - run: | - flit build - - name: Publishing 📦 to PyPI - # Regarding building artifacts within Platform specific environment see https://github.com/pypa/gh-action-pypi-publish#non-goals + python -m pip install --upgrade pip + pip install build + - name: Build package + run: python -m build + - name: Publish package uses: pypa/gh-action-pypi-publish@release/v1 - with: - password: ${{ secrets.PYPI_API_TOKEN }} - repository-url: https://upload.pypi.org/legacy/ + diff --git a/README.md b/README.md index c4be471..119e7a7 100644 --- a/README.md +++ b/README.md @@ -13,6 +13,7 @@ Vix Cash Data are downloaded from [CBOE Historical Volatility Indexes](https://w There is an API for Python to load the data into Pandas DataFrames. If you do your analysis in Python, use the API. Since there is no documentation yet, look at the examples in the src/vix_utils/examples folder. +There is a Jupyter Notebook vix_utils.ipynb in that folder. *Important note for Juypter notebooks.* You must use async_get_vix_index_histories and async_load_vix_term_structure @@ -69,6 +70,15 @@ However, new features and bug fixes should be developed with [Test Driven Develo ## Examples Source is in `src/vix_utils/examples` +~~~ +## Data Notes +These dates appear to be missing from the CBOE Data. +At some point they need to be patched in if they exist. +``` +[Timestamp('2006-11-10 00:00:00'), Timestamp('2007-01-03 00:00:00'), Timestamp('2021-04-02 00:00:00'), Timestamp('2021-12-24 00:00:00')] +``` +There seem to be a few dates where spot indexes are missing, you will have to workaround by using fill feature of Pandas datafame, or skip those days, in any analysis. ~~~ ## Developing https://numpydoc.readthedocs.io/en/latest/format.html + diff --git a/pyproject.toml b/pyproject.toml index 9b2e360..33a8d20 100644 --- a/pyproject.toml +++ b/pyproject.toml @@ -13,7 +13,7 @@ classifiers = ["License :: OSI Approved :: MIT License", "Topic :: Office/Business :: Financial :: Investment"] readme="README.md" -requires-python=">=3.11" +requires-python=">=3.10" dynamic=["version"] @@ -23,7 +23,8 @@ dependencies= [ "aiofiles", "aiohttp[speedups]", "openpyxl", - "appdirs"] + "appdirs", + "more_itertools"] [project.optional-dependencies] diff --git a/src/vix_utils/__init__.py b/src/vix_utils/__init__.py index f2ff9ef..301b1d9 100644 --- a/src/vix_utils/__init__.py +++ b/src/vix_utils/__init__.py @@ -2,7 +2,7 @@ A library for preparing VIX Futures and Cash Term Structures for analysis, including a continuous maturity VIX Futures term structure. """ -__version__ = '0.1.4' +__version__ = '0.1.5' from .download_vix_futures import \ pivot_futures_on_monthly_tenor,select_monthly_futures,async_load_vix_term_structure,load_vix_term_structure @@ -10,7 +10,7 @@ from .vix_cash_term_structure import \ async_get_vix_index_histories, \ get_vix_index_histories, \ - pivot_cash_term_structure_on_symbol + pivot_spot_term_structure_on_symbol from .vix_futures_dates import vix_futures_expiry_date_monthly, \ vix_futures_expiry_date_from_trade_date, \ diff --git a/src/vix_utils/continuous_maturity.py b/src/vix_utils/continuous_maturity.py index 0a6e9c5..e4e1d39 100644 --- a/src/vix_utils/continuous_maturity.py +++ b/src/vix_utils/continuous_maturity.py @@ -61,7 +61,7 @@ def do_weighting_front_two_months(trades_df : pd.DataFrame,weight_df : pd.DataFr def append_continuous_maturity_one_month(monthly_wide_records : pd.DataFrame)->pd.DataFrame: """ produces a weighted mean of the two nearest monthly futures (using continous_maturity_30day) - appends it to the monthly_wide_records. + appends it to the monthly_wide_records, with Monthly_Tenor of 1.5 (for ease of sorting) There will be fewer columns as the result of continous_maturity_30day has fewer columns for a tenor than monthly_wide_records. parameters: @@ -81,11 +81,11 @@ def append_continuous_maturity_one_month(monthly_wide_records : pd.DataFrame)->p new_df2=new_df1.swaplevel(axis=1) #add a level to new_cm d={} - d["30 Day Continuous"]=new_cm + d[1.5]=new_cm e=pd.concat(d,axis=1) #concatenate new_cm (after adding the level of idexing) - new_df3=pd.concat([new_df2,e],axis=1) + new_df3=pd.concat([new_df2,e],axis=1).sort_index(axis=1) return new_df3 diff --git a/src/vix_utils/download_vix_futures.py b/src/vix_utils/download_vix_futures.py index 4dd9ad2..1a7db2d 100644 --- a/src/vix_utils/download_vix_futures.py +++ b/src/vix_utils/download_vix_futures.py @@ -116,10 +116,9 @@ def years_and_months(): def archived_years_and_months(): "For data from https://www.cboe.com/us/futures/market_statistics/historical_data/archive/" - #specifically avoid 2013 since the data is dirty and duplicated with the - #weekly and monthly data from the current download source. + - return list(itertools.product(range(2004,2013),range(1,13))) + return list(itertools.product(range(2004,2014),range(1,13))) def years_and_weeks(): now = dt.datetime.now() @@ -320,7 +319,8 @@ def downloaded_file_paths(data_dir:Path)->tuple[Path,Path,Path]: folders_contents=tuple( list(the_dir.glob("*.csv")) for the_dir in (a,b,c)) return folders_contents - +_header_match_str="Trade Date," +_head_match_len=len(_header_match_str) async def download(vixutil_path:Path): """ Download the vix futures historis we don't have up todate. @@ -338,14 +338,20 @@ async def download(vixutil_path:Path): #need to find lines with a trailing "," and remove it. There are a bunch in the - #archived data + #archived data. + #we also need to throw away lines before the line that starts with Trade Date. _,_,amfns=downloaded_file_paths(vixutil_path) + + def unmatched_header_row(a_line): + return a_line[0:_head_match_len]!=_header_match_str + for fn in amfns: with open(fn,'r') as fin: data=fin.read().splitlines(True) + filtered_preamble=itertools.dropwhile(unmatched_header_row,data) with open(fn,'w') as fout: - for line in data: + for line in filtered_preamble: updated_line=",".join(line.split(",")[0:11]).strip() print(updated_line,file=fout) @@ -400,8 +406,9 @@ def read_csv_future_file(future_path:Path,monthly_expiry_date_strings:frozenset) try: df = pd.read_csv(future_path,parse_dates=[0]) except Exception as e: - logging.warn(f"\n {e}\n reading\n{future_path} ") - raise + logging.warn(f"\n{e}\n reading\n{future_path}, skipping ") + return pd.DataFrame(columns=[["Trade Date"]]) + fn=future_path.name expiry_date_str=settlement_date_str_from_fn(fn) #week_number TODO FIGURE THIS OUT @@ -551,8 +558,9 @@ def load_vix_term_structure(forceReload=False): last call, if one exists. """ - with asyncio.Runner() as runner: - return runner.run(async_load_vix_term_structure(forceReload)) + return asyncio.run(async_load_vix_term_structure(forceReload)) +# with asyncio.Runner() as runner: +# return runner.run(async_load_vix_term_structure(forceReload)) @timeit() async def async_load_vix_term_structure(forceReload=False)->pd.DataFrame: diff --git a/src/vix_utils/examples/a_t.ipynb b/src/vix_utils/examples/a_t.ipynb new file mode 100644 index 0000000..f742746 --- /dev/null +++ b/src/vix_utils/examples/a_t.ipynb @@ -0,0 +1,43 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 3, + "id": "1631065c", + "metadata": {}, + "outputs": [], + "source": [ + "import xarray as xa, numpy as np" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f612f82b", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/vix_utils/examples/hello_x.py b/src/vix_utils/examples/hello_x.py new file mode 100644 index 0000000..58a0aff --- /dev/null +++ b/src/vix_utils/examples/hello_x.py @@ -0,0 +1,7 @@ +import xarray as xr, pandas as pd, numpy as np + +data = xr.DataArray(np.random.randn(2, 3), dims=("x", "y"), coords={"x": [10, 20]}) +print(f"data{data}") +a = xr.DataArray(np.random.randn(3), [data.coords["y"]]) +b = xr.DataArray(np.random.randn(4), dims="z") +3 diff --git a/src/vix_utils/examples/sample_load_data.py b/src/vix_utils/examples/sample_load_data.py index 5c01d13..fbf5304 100644 --- a/src/vix_utils/examples/sample_load_data.py +++ b/src/vix_utils/examples/sample_load_data.py @@ -5,10 +5,11 @@ import logging import sys +from itertools import chain stars='*'*80 -def pstars(): +def pstars(toprint=""): """Print a line of '*' """ - print(stars) + print(f"\n{stars}\n{toprint}") def main(): logging.basicConfig(stream=sys.stdout, level=logging.DEBUG) @@ -33,7 +34,7 @@ async def do_load(): vix_futures_history=v.load_vix_term_structure() pstars() - wide_cash=v.pivot_cash_term_structure_on_symbol(vix_cash_history) + wide_cash=v.pivot_spot_term_structure_on_symbol(vix_cash_history) print(f"Wide Vix Cash history\n{wide_cash}\nWide Cash History Index\n{wide_cash.columns}") pstars() @@ -51,23 +52,68 @@ async def do_load(): pstars() pivoted= v.pivot_futures_on_monthly_tenor(monthly) print(f"\npivoted {pivoted}") + + pstars() + indexed_by_tenor=vix_futures_history.set_index(["Trade Date","Tenor_Monthly"]) + print(f"indexed by tenor:\n{indexed_by_tenor}") + + pivoted_swapped=pivoted.swaplevel(0,1,axis=1) pivoted_two_cols=pivoted_swapped[['Close','File']] - print(f"The monthlys, with a tenor column index, levels swapped, just a few columns:\n{pivoted_two_cols}\ncolumn_index{pivoted_two_cols.columns}") + olhc=["Open","High","Low","Close"] + pivoted_ohlc=pivoted_swapped[olhc] + vix_ohlc=wide_cash.swaplevel(0,1,axis=1)[["VIX"]].swaplevel(0,1,axis=1) + #get the columns correspondenting to futures tenors - pstars() + #replicate in the spot prices + + + + m1m2_weighted=v.continuous_maturity_one_month(pivoted) - print(f"\nm1m2 weighted:\n{m1m2_weighted}\ncolumns:\n{m1m2_weighted.columns}") + pstars(f"\nm1m2 weighted:\n{m1m2_weighted}\ncolumns:\n{m1m2_weighted.columns}") appended_m1m2=v.append_continuous_maturity_one_month(pivoted) - appended_m1m2_close=appended_m1m2[[1,'30 Day Continuous',2]].swaplevel(axis=1)[['Close','Tenor_Days','Expiry']] - pstars() + appended_m1m2_close=appended_m1m2[[1,1.5,2]].swaplevel(axis=1)[['Close','Tenor_Days','Expiry']] + pstars(f"\nappended_m1m2:\n{appended_m1m2}") + + closes=appended_m1m2.swaplevel(axis=1)["Close"] + + pstars(f"\ncloses\n{closes}") print(f"\nappended m1m2 to wide (close):\n{appended_m1m2_close}") - pstars() + + + vix_cash_history_closes=wide_cash["Close"] + spot_symbols=["VIX9D","VIX","VIX3M","GVZ"] #some symbols to compare with the VIX futures for a basis. + #the basis that makes sense of course is on the VIX, since the vix futures + #are for the VIX spot settlement. + #there reasonably should be a relationship with the various + #vix spot indexes and probably a weaker one with GVZ. + + + + def add_column_level(df:pd.DataFrame,var_name): + df2=pd.DataFrame(df) + idx=df2.columns.to_frame() + idx.insert(0,"Variable",var_name) + df2.columns=pd.MultiIndex.from_frame(idx) + return df2 + + vix_basis_by_index=[add_column_level(closes.sub(vix_cash_history_closes[spot_symbol],axis=0),spot_symbol+"_Basis") for spot_symbol in ["VIX9D","VIX","VIX3M","GVZ"]] + + closes=add_column_level(closes,"Futures") + + vix_basis=pd.concat(chain([closes],vix_basis_by_index),axis=1,join="inner") + + pstars(f"vix_basis{vix_basis}") + + + with pd.option_context("display.max_rows",None,"display.max_columns",None): - df2021_02=appended_m1m2.loc['2021-02'][[1,'30 Day Continuous',2]].swaplevel(axis=1)[['Close','Tenor_Days','Expiry']] + df2021_02=appended_m1m2.loc['2021-02'][[1,1.5,2]].swaplevel(axis=1)[['Close','Tenor_Days','Expiry']] print(f"\nappended (2021-02)\n{df2021_02}") + if __name__=="__main__": main() \ No newline at end of file diff --git a/src/vix_utils/examples/sample_plots.py b/src/vix_utils/examples/sample_plots.py index 329f27c..da32128 100644 --- a/src/vix_utils/examples/sample_plots.py +++ b/src/vix_utils/examples/sample_plots.py @@ -39,8 +39,8 @@ def plotDF(df): vix_futures_skinny = vix_utils.load_vix_term_structure() vix_futures_monthly_skinny=vix_utils.select_monthly_futures(vix_futures_skinny) vix_futures_wide=vix_utils.pivot_futures_on_monthly_tenor(vix_futures_monthly_skinny) - vix_cash=vix_utils.get_vix_index_histories() - vix_cash_wide=vix_utils.pivot_cash_term_structure_on_symbol(vix_cash) + vix_spot=vix_utils.get_vix_index_histories() + vix_spot_wide=vix_utils.pivot_spot_term_structure_on_symbol(vix_spot) sep_lines = "_"*25+"\n" @@ -68,31 +68,31 @@ def plotDF(df): wide_with_continuous_futures=vix_utils.append_continuous_maturity_one_month(original_vix_futures_wide) #front two months wide_with_continuous_futures_f2m=\ - wide_with_continuous_futures[[1,2,"30 Day Continuous"]].swaplevel(axis=1)[["Close"]].swaplevel(axis=1) + wide_with_continuous_futures[[1,2,1.5]].swaplevel(axis=1)[["Close"]].swaplevel(axis=1) plotDF(wide_with_continuous_futures_f2m) - logging.getLogger().debug(f"{stars}\nCash vix\n{vix_cash_wide}") - b=vix_cash_wide['Close'][['VIX3M','VIX','VIX9D']] + logging.getLogger().debug(f"{stars}\nSpot vix\n{vix_spot_wide}") + b=vix_spot_wide['Close'][['VIX3M','VIX','VIX9D','VIX1D']] plotDF(b) - c=vix_cash_wide['Close'][['VXTLT','GVZ','VVIX','OVX']] + c=vix_spot_wide['Close'][['VXTLT','GVZ','VVIX','OVX']] plotDF(c) - d=vix_cash_wide['Close'][['SHORTVOL']] + d=vix_spot_wide['Close'][['SHORTVOL']] plotDF(d) - e=vix_cash_wide['Close'][['LONGVOL']] + e=vix_spot_wide['Close'][['LONGVOL']] plotDF(e) #plot the term structure for Feb 16, 2021 day_of_interest = '2023-07-05' df_day_of_interest =wide_with_continuous_futures.loc[[day_of_interest]] - cols_to_plot=[1] + ["30 Day Continuous"] + list(range(2,10)) + cols_to_plot=[1,1.5] + list(range(2,10)) df_day_of_interest_to_plot=df_day_of_interest.swaplevel(axis=1)[['Close',"Tenor_Days"]].swaplevel(axis=1)[cols_to_plot].swaplevel(axis=1) - df_debug=wide_with_continuous_futures[[1,"30 Day Continuous",2]].swaplevel(axis=1)[['Close','Tenor_Days','Expiry']] + df_debug=wide_with_continuous_futures[[1,1.5,2]].swaplevel(axis=1)[['Close','Tenor_Days','Expiry']] with pd.option_context("display.max_columns",None,"display.max_rows",None): print(f"df_day_of_interest{stars}\ndf_day_of_interest") @@ -105,6 +105,18 @@ def plotDF(df): if not skipPlot: df_day_of_interest_to_plot.plot(x="Tenor_Days", y="Close", kind = 'scatter', use_index=True) plt.show() + df_s=df_day_of_interest_to_plot.stack(1) + df_s.plot.line(x="Tenor_Days", y="Close") + plt.show() + spot_di=vix_spot_wide.loc[day_of_interest]["Close"][["VIX9D","VIX","VIX3M","VIX6M"]] + + print(f"\nspot\n{spot_di}") + spot_df_di=pd.DataFrame(index=[9,30,60,180],data=spot_di.values,columns=['Close']) + print(f"\nspot df di\n{spot_df_di}") + spot_df_di.plot.line(y='Close') + plt.show() +import logging if __name__=="__main__": + logging.getLogger("vix_utils") main() diff --git a/src/vix_utils/examples/sample_utils.py b/src/vix_utils/examples/sample_utils.py deleted file mode 100644 index e69de29..0000000 diff --git a/src/vix_utils/examples/vix_utils use in Jupyter.ipynb b/src/vix_utils/examples/vix_utils use in Jupyter.ipynb deleted file mode 100644 index b2c6c2c..0000000 --- a/src/vix_utils/examples/vix_utils use in Jupyter.ipynb +++ /dev/null @@ -1,159 +0,0 @@ -{ - "cells": [ - { - "cell_type": "code", - "execution_count": 64, - "id": "f009923a", - "metadata": {}, - "outputs": [ - { - "name": "stdout", - "output_type": "stream", - "text": [ - "Loading vix_utils into a jupyter notebook, and plotting some term structures\n" - ] - } - ], - "source": [ - "print(\"Loading vix_utils into a jupyter notebook, and plotting some term structures\")" - ] - }, - { - "cell_type": "code", - "execution_count": 27, - "id": "4eb4c0c1", - "metadata": {}, - "outputs": [], - "source": [ - "import vix_utils, pandas as pd, logging, asyncio,sys,matplotlib.pyplot as plt, scipy.stats as bc" - ] - }, - { - "cell_type": "code", - "execution_count": 65, - "id": "263f03df", - "metadata": {}, - "outputs": [], - "source": [ - "#in Jupyter, use the vix_utils asynchronous functions to the load the data\n", - "#here we read the futures and cash term structure\n", - "\n", - "vix_futures,vix_cash=await asyncio.gather(vix_utils.async_load_vix_term_structure(),vix_utils.async_get_vix_index_histories())\n" - ] - }, - { - "cell_type": "code", - "execution_count": 51, - "id": "4aac48ae", - "metadata": {}, - "outputs": [], - "source": [ - "#another way, reading the futures, then the cash structure, in sequence instead of concurrently\n", - "vix_futures_skinny_2 = await vix_utils.async_load_vix_term_structure()\n", - "vix_cash_2=await vix_utils.async_get_vix_index_histories()" - ] - }, - { - "cell_type": "code", - "execution_count": 61, - "id": "7bb42143", - "metadata": {}, - "outputs": [], - "source": [ - " #manipulate the data to get what we want to display\n", - " vix_cash_wide=vix_utils.pivot_cash_term_structure_on_symbol(vix_cash)\n", - " vix_futures_monthly_skinny=vix_utils.select_monthly_futures(vix_futures)\n", - " vix_futures_wide=vix_utils.pivot_futures_on_monthly_tenor(vix_futures_monthly_skinny)\n", - " #we just want 9 tenors for now\n", - " selected_tenors=list(range(1,10))\n", - " original_vix_futures_wide=pd.DataFrame(vix_futures_wide)\n", - " vix_futures_wide=vix_futures_wide[selected_tenors]\n", - " close=vix_futures_wide.swaplevel(0,1,axis=1)[[\"Close\"]]\n" - ] - }, - { - "cell_type": "code", - "execution_count": 66, - "id": "62eca16d", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 66, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "#plot futures\n", - "close.plot()" - ] - }, - { - "cell_type": "code", - "execution_count": 63, - "id": "3ef185e2", - "metadata": {}, - "outputs": [ - { - "data": { - "text/plain": [ - "" - ] - }, - "execution_count": 63, - "metadata": {}, - "output_type": "execute_result" - }, - { - "data": { - "image/png": "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", - "text/plain": [ - "
" - ] - }, - "metadata": {}, - "output_type": "display_data" - } - ], - "source": [ - "vix_cash_wide.plot()" - ] - } - ], - "metadata": { - "kernelspec": { - "display_name": "Python 3 (ipykernel)", - "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.11.2" - } - }, - "nbformat": 4, - "nbformat_minor": 5 -} diff --git a/src/vix_utils/examples/vix_utils xarray.ipynb b/src/vix_utils/examples/vix_utils xarray.ipynb new file mode 100644 index 0000000..91965b0 --- /dev/null +++ b/src/vix_utils/examples/vix_utils xarray.ipynb @@ -0,0 +1,1387 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 28, + "id": "f009923a", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Xarray Loading vix_utils into a jupyter notebook, and plotting some term structures\n" + ] + } + ], + "source": [ + "print(\"Xarray Loading vix_utils into a jupyter notebook, and plotting some term structures\")" + ] + }, + { + "cell_type": "code", + "execution_count": 29, + "id": "4eb4c0c1", + "metadata": {}, + "outputs": [], + "source": [ + "import vix_utils, pandas as pd, logging, asyncio,sys,matplotlib.pyplot as plt, scipy.stats as bc" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "d77a33ed", + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": 30, + "id": "263f03df", + "metadata": {}, + "outputs": [], + "source": [ + "#in Jupyter, use the vix_utils asynchronous functions to the load the data\n", + "#here we read the futures and cash term structure\n", + "\n", + "vix_futures,vix_cash=await asyncio.gather(vix_utils.async_load_vix_term_structure(),vix_utils.async_get_vix_index_histories())\n" + ] + }, + { + "cell_type": "code", + "execution_count": 31, + "id": "4aac48ae", + "metadata": {}, + "outputs": [], + "source": [ + "#another way, reading the futures, then the cash structure, in sequence instead of concurrently\n", + "vix_futures_skinny_2 = await vix_utils.async_load_vix_term_structure()\n", + "vix_cash_2=await vix_utils.async_get_vix_index_histories()" + ] + }, + { + "cell_type": "code", + "execution_count": 32, + "id": "7bb42143", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:\n", + "******************************Duplicates detected for Trade Date and Tenor\n", + "\n" + ] + } + ], + "source": [ + " #manipulate the data to get what we want to display\n", + " vix_cash_wide=vix_utils.pivot_cash_term_structure_on_symbol(vix_cash)\n", + " vix_futures_monthly_skinny=vix_utils.select_monthly_futures(vix_futures)\n", + " vix_futures_wide=vix_utils.pivot_futures_on_monthly_tenor(vix_futures_monthly_skinny)\n", + " #we just want 9 tenors for now\n", + " selected_tenors=list(range(1,10))\n", + " original_vix_futures_wide=pd.DataFrame(vix_futures_wide)\n", + " vix_futures_wide=vix_futures_wide[selected_tenors]\n", + " close=vix_futures_wide.swaplevel(0,1,axis=1)[[\"Close\"]]\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 33, + "id": "beead8c2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Trade DateCloseSymbolOpenHighLow
02006-03-0671.73VVIXNaNNaNNaN
12006-03-1515.71VVIXNaNNaNNaN
22006-03-1627.94VVIXNaNNaNNaN
32006-03-1728.60VVIXNaNNaNNaN
42006-03-2037.93VVIXNaNNaNNaN
.....................
39042023-07-0719.31VIX6M19.7119.7219.03
39052023-07-1019.21VIX6M19.4119.5219.14
39062023-07-1118.97VIX6M19.0519.1618.91
39072023-07-1218.26VIX6M18.4718.5118.17
39082023-07-1318.24VIX6M18.1618.2417.97
\n", + "

43995 rows × 6 columns

\n", + "
" + ], + "text/plain": [ + " Trade Date Close Symbol Open High Low\n", + "0 2006-03-06 71.73 VVIX NaN NaN NaN\n", + "1 2006-03-15 15.71 VVIX NaN NaN NaN\n", + "2 2006-03-16 27.94 VVIX NaN NaN NaN\n", + "3 2006-03-17 28.60 VVIX NaN NaN NaN\n", + "4 2006-03-20 37.93 VVIX NaN NaN NaN\n", + "... ... ... ... ... ... ...\n", + "3904 2023-07-07 19.31 VIX6M 19.71 19.72 19.03\n", + "3905 2023-07-10 19.21 VIX6M 19.41 19.52 19.14\n", + "3906 2023-07-11 18.97 VIX6M 19.05 19.16 18.91\n", + "3907 2023-07-12 18.26 VIX6M 18.47 18.51 18.17\n", + "3908 2023-07-13 18.24 VIX6M 18.16 18.24 17.97\n", + "\n", + "[43995 rows x 6 columns]" + ] + }, + "execution_count": 33, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vix_cash" + ] + }, + { + "cell_type": "code", + "execution_count": 34, + "id": "ae0a3aba", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Close
Tenor_Monthly1.02.03.04.05.06.07.08.09.0
Trade Date
2004-03-26NaN20.2720.20NaN20.06NaNNaN20.89NaN
2004-03-29NaN19.7719.76NaN19.76NaNNaN20.97NaN
2004-03-30NaN19.6119.73NaN19.92NaNNaN21.00NaN
2004-03-31NaN19.7219.90NaN20.18NaNNaN21.13NaN
2004-04-01NaN19.6519.94NaN20.28NaNNaN21.25NaN
..............................
2023-07-0715.8616.8917.9418.5719.0019.2520.3520.5020.77
2023-07-1015.7616.7517.7518.3718.8519.1020.1520.3220.60
2023-07-1115.4516.5517.6218.2218.6018.7519.8520.1020.55
2023-07-1214.3115.7817.0817.7718.1518.3819.4719.7520.00
2023-07-1314.1915.9117.1217.7518.1718.4219.5519.8020.09
\n", + "

4848 rows × 9 columns

\n", + "
" + ], + "text/plain": [ + " Close \n", + "Tenor_Monthly 1.0 2.0 3.0 4.0 5.0 6.0 7.0 8.0 9.0\n", + "Trade Date \n", + "2004-03-26 NaN 20.27 20.20 NaN 20.06 NaN NaN 20.89 NaN\n", + "2004-03-29 NaN 19.77 19.76 NaN 19.76 NaN NaN 20.97 NaN\n", + "2004-03-30 NaN 19.61 19.73 NaN 19.92 NaN NaN 21.00 NaN\n", + "2004-03-31 NaN 19.72 19.90 NaN 20.18 NaN NaN 21.13 NaN\n", + "2004-04-01 NaN 19.65 19.94 NaN 20.28 NaN NaN 21.25 NaN\n", + "... ... ... ... ... ... ... ... ... ...\n", + "2023-07-07 15.86 16.89 17.94 18.57 19.00 19.25 20.35 20.50 20.77\n", + "2023-07-10 15.76 16.75 17.75 18.37 18.85 19.10 20.15 20.32 20.60\n", + "2023-07-11 15.45 16.55 17.62 18.22 18.60 18.75 19.85 20.10 20.55\n", + "2023-07-12 14.31 15.78 17.08 17.77 18.15 18.38 19.47 19.75 20.00\n", + "2023-07-13 14.19 15.91 17.12 17.75 18.17 18.42 19.55 19.80 20.09\n", + "\n", + "[4848 rows x 9 columns]" + ] + }, + "execution_count": 34, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "close" + ] + }, + { + "cell_type": "code", + "execution_count": 35, + "id": "4cdda52f", + "metadata": {}, + "outputs": [], + "source": [ + "import xarray as xa\n" + ] + }, + { + "cell_type": "code", + "execution_count": 36, + "id": "8cb3cde4", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Trade DateTenor_MonthlyTenor_DaysTenor_Trade_DaysExpiryOpenHighLowCloseSettleChangeTotal VolumeEFPOpen InterestYearMonthOfYearFuturesFileExpired
02004-03-262.05237.02004-05-1821.2421.2520.2720.2720.32000.0000216014420045K (May 04)2004-05-18.m_5.CFE_VX_K2004.csvTrue
12004-03-262.05338.02004-05-1921.2421.2520.2720.2720.32000.0000216014420045K (May 04)2004-05-19.m_5.CFE_VX_K2004.csvTrue
22004-03-263.08055.02004-06-1520.3320.3720.1020.2020.16000.00002602620046M (Jun 04)2004-06-15.m_6.CFE_VX_M2004.csvTrue
32004-03-263.08156.02004-06-1620.3320.3720.1020.2020.16000.00002602620046M (Jun 04)2004-06-16.m_6.CFE_VX_M2004.csvTrue
42004-03-265.014399.02004-08-1720.0420.1320.0020.0620.11000.00003703720048Q (Aug 04)2004-08-17.m_8.CFE_VX_Q2004.csvTrue
............................................................
503062023-07-135.012589.02023-11-1518.1518.2517.8518.1718.20280.00295246021060202311X (Nov 2023)2023-11-15.w_.CFE_VX_2023.csvFalse
503812023-07-136.0160114.02023-12-2018.3518.4518.1218.4218.45000.01072905018571202312Z (Dec 2023)2023-12-20.w_.CFE_VX_2023.csvFalse
504372023-07-137.0188134.02024-01-1719.4519.6019.2319.5519.60000.0823234601041020241F (Jan 2024)2024-01-17.w_.CFE_VX_2024.csvFalse
504732023-07-138.0216154.02024-02-1419.6519.8519.5019.8019.85000.10005550258820242G (Feb 2024)2024-02-14.w_.CFE_VX_2024.csvFalse
504862023-07-139.0251179.02024-03-2019.9020.1019.8220.0920.12500.075023011420243H (Mar 2024)2024-03-20.w_.CFE_VX_2024.csvFalse
\n", + "

38577 rows × 19 columns

\n", + "
" + ], + "text/plain": [ + " Trade Date Tenor_Monthly Tenor_Days Tenor_Trade_Days Expiry \\\n", + "0 2004-03-26 2.0 52 37.0 2004-05-18 \n", + "1 2004-03-26 2.0 53 38.0 2004-05-19 \n", + "2 2004-03-26 3.0 80 55.0 2004-06-15 \n", + "3 2004-03-26 3.0 81 56.0 2004-06-16 \n", + "4 2004-03-26 5.0 143 99.0 2004-08-17 \n", + "... ... ... ... ... ... \n", + "50306 2023-07-13 5.0 125 89.0 2023-11-15 \n", + "50381 2023-07-13 6.0 160 114.0 2023-12-20 \n", + "50437 2023-07-13 7.0 188 134.0 2024-01-17 \n", + "50473 2023-07-13 8.0 216 154.0 2024-02-14 \n", + "50486 2023-07-13 9.0 251 179.0 2024-03-20 \n", + "\n", + " Open High Low Close Settle Change Total Volume EFP \\\n", + "0 21.24 21.25 20.27 20.27 20.3200 0.0000 216 0 \n", + "1 21.24 21.25 20.27 20.27 20.3200 0.0000 216 0 \n", + "2 20.33 20.37 20.10 20.20 20.1600 0.0000 26 0 \n", + "3 20.33 20.37 20.10 20.20 20.1600 0.0000 26 0 \n", + "4 20.04 20.13 20.00 20.06 20.1100 0.0000 37 0 \n", + "... ... ... ... ... ... ... ... ... \n", + "50306 18.15 18.25 17.85 18.17 18.2028 0.0029 5246 0 \n", + "50381 18.35 18.45 18.12 18.42 18.4500 0.0107 2905 0 \n", + "50437 19.45 19.60 19.23 19.55 19.6000 0.0823 2346 0 \n", + "50473 19.65 19.85 19.50 19.80 19.8500 0.1000 555 0 \n", + "50486 19.90 20.10 19.82 20.09 20.1250 0.0750 23 0 \n", + "\n", + " Open Interest Year MonthOfYear Futures \\\n", + "0 144 2004 5 K (May 04) \n", + "1 144 2004 5 K (May 04) \n", + "2 26 2004 6 M (Jun 04) \n", + "3 26 2004 6 M (Jun 04) \n", + "4 37 2004 8 Q (Aug 04) \n", + "... ... ... ... ... \n", + "50306 21060 2023 11 X (Nov 2023) \n", + "50381 18571 2023 12 Z (Dec 2023) \n", + "50437 10410 2024 1 F (Jan 2024) \n", + "50473 2588 2024 2 G (Feb 2024) \n", + "50486 114 2024 3 H (Mar 2024) \n", + "\n", + " File Expired \n", + "0 2004-05-18.m_5.CFE_VX_K2004.csv True \n", + "1 2004-05-19.m_5.CFE_VX_K2004.csv True \n", + "2 2004-06-15.m_6.CFE_VX_M2004.csv True \n", + "3 2004-06-16.m_6.CFE_VX_M2004.csv True \n", + "4 2004-08-17.m_8.CFE_VX_Q2004.csv True \n", + "... ... ... \n", + "50306 2023-11-15.w_.CFE_VX_2023.csv False \n", + "50381 2023-12-20.w_.CFE_VX_2023.csv False \n", + "50437 2024-01-17.w_.CFE_VX_2024.csv False \n", + "50473 2024-02-14.w_.CFE_VX_2024.csv False \n", + "50486 2024-03-20.w_.CFE_VX_2024.csv False \n", + "\n", + "[38577 rows x 19 columns]" + ] + }, + "execution_count": 36, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vix_futures_monthly_skinny" + ] + }, + { + "cell_type": "code", + "execution_count": 37, + "id": "e775d806", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['Trade Date', 'Tenor_Monthly', 'Tenor_Days', 'Tenor_Trade_Days',\n", + " 'Expiry', 'Open', 'High', 'Low', 'Close', 'Settle', 'Change',\n", + " 'Total Volume', 'EFP', 'Open Interest', 'Year', 'MonthOfYear',\n", + " 'Futures', 'File', 'Expired'],\n", + " dtype='object')" + ] + }, + "execution_count": 37, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vix_futures_monthly_skinny.columns\n" + ] + }, + { + "cell_type": "code", + "execution_count": 38, + "id": "9c3470a6", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index([ 0, 1, 2, 3, 4, 5, 6, 7, 8, 9,\n", + " ...\n", + " 50485, 49732, 49945, 50088, 50207, 50306, 50381, 50437, 50473, 50486],\n", + " dtype='int64', length=38577)" + ] + }, + "execution_count": 38, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vix_futures_monthly_skinny.index" + ] + }, + { + "cell_type": "code", + "execution_count": 39, + "id": "0cc84174", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Index(['Trade Date', 'Tenor_Monthly', 'Tenor_Days', 'Tenor_Trade_Days',\n", + " 'Expiry', 'Open', 'High', 'Low', 'Close', 'Settle', 'Change',\n", + " 'Total Volume', 'EFP', 'Open Interest', 'Year', 'MonthOfYear',\n", + " 'Futures', 'File', 'Expired'],\n", + " dtype='object')" + ] + }, + "execution_count": 39, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vix_futures_monthly_skinny.columns" + ] + }, + { + "cell_type": "code", + "execution_count": 40, + "id": "d0f8a187", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "19" + ] + }, + "execution_count": 40, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "len(vix_futures_monthly_skinny.columns)" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "id": "854cefcd", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Tenor_DaysTenor_Trade_DaysExpiryOpenHighLowCloseSettleChangeTotal VolumeEFPOpen InterestYearMonthOfYearFuturesFileExpired
Trade DateTenor_Monthly
2004-03-262.05237.02004-05-1821.2421.2520.2720.2720.32000.0000216014420045K (May 04)2004-05-18.m_5.CFE_VX_K2004.csvTrue
2.05338.02004-05-1921.2421.2520.2720.2720.32000.0000216014420045K (May 04)2004-05-19.m_5.CFE_VX_K2004.csvTrue
3.08055.02004-06-1520.3320.3720.1020.2020.16000.00002602620046M (Jun 04)2004-06-15.m_6.CFE_VX_M2004.csvTrue
3.08156.02004-06-1620.3320.3720.1020.2020.16000.00002602620046M (Jun 04)2004-06-16.m_6.CFE_VX_M2004.csvTrue
5.014399.02004-08-1720.0420.1320.0020.0620.11000.00003703720048Q (Aug 04)2004-08-17.m_8.CFE_VX_Q2004.csvTrue
.........................................................
2023-07-135.012589.02023-11-1518.1518.2517.8518.1718.20280.00295246021060202311X (Nov 2023)2023-11-15.w_.CFE_VX_2023.csvFalse
6.0160114.02023-12-2018.3518.4518.1218.4218.45000.01072905018571202312Z (Dec 2023)2023-12-20.w_.CFE_VX_2023.csvFalse
7.0188134.02024-01-1719.4519.6019.2319.5519.60000.0823234601041020241F (Jan 2024)2024-01-17.w_.CFE_VX_2024.csvFalse
8.0216154.02024-02-1419.6519.8519.5019.8019.85000.10005550258820242G (Feb 2024)2024-02-14.w_.CFE_VX_2024.csvFalse
9.0251179.02024-03-2019.9020.1019.8220.0920.12500.075023011420243H (Mar 2024)2024-03-20.w_.CFE_VX_2024.csvFalse
\n", + "

38577 rows × 17 columns

\n", + "
" + ], + "text/plain": [ + " Tenor_Days Tenor_Trade_Days Expiry Open \\\n", + "Trade Date Tenor_Monthly \n", + "2004-03-26 2.0 52 37.0 2004-05-18 21.24 \n", + " 2.0 53 38.0 2004-05-19 21.24 \n", + " 3.0 80 55.0 2004-06-15 20.33 \n", + " 3.0 81 56.0 2004-06-16 20.33 \n", + " 5.0 143 99.0 2004-08-17 20.04 \n", + "... ... ... ... ... \n", + "2023-07-13 5.0 125 89.0 2023-11-15 18.15 \n", + " 6.0 160 114.0 2023-12-20 18.35 \n", + " 7.0 188 134.0 2024-01-17 19.45 \n", + " 8.0 216 154.0 2024-02-14 19.65 \n", + " 9.0 251 179.0 2024-03-20 19.90 \n", + "\n", + " High Low Close Settle Change Total Volume \\\n", + "Trade Date Tenor_Monthly \n", + "2004-03-26 2.0 21.25 20.27 20.27 20.3200 0.0000 216 \n", + " 2.0 21.25 20.27 20.27 20.3200 0.0000 216 \n", + " 3.0 20.37 20.10 20.20 20.1600 0.0000 26 \n", + " 3.0 20.37 20.10 20.20 20.1600 0.0000 26 \n", + " 5.0 20.13 20.00 20.06 20.1100 0.0000 37 \n", + "... ... ... ... ... ... ... \n", + "2023-07-13 5.0 18.25 17.85 18.17 18.2028 0.0029 5246 \n", + " 6.0 18.45 18.12 18.42 18.4500 0.0107 2905 \n", + " 7.0 19.60 19.23 19.55 19.6000 0.0823 2346 \n", + " 8.0 19.85 19.50 19.80 19.8500 0.1000 555 \n", + " 9.0 20.10 19.82 20.09 20.1250 0.0750 23 \n", + "\n", + " EFP Open Interest Year MonthOfYear Futures \\\n", + "Trade Date Tenor_Monthly \n", + "2004-03-26 2.0 0 144 2004 5 K (May 04) \n", + " 2.0 0 144 2004 5 K (May 04) \n", + " 3.0 0 26 2004 6 M (Jun 04) \n", + " 3.0 0 26 2004 6 M (Jun 04) \n", + " 5.0 0 37 2004 8 Q (Aug 04) \n", + "... ... ... ... ... ... \n", + "2023-07-13 5.0 0 21060 2023 11 X (Nov 2023) \n", + " 6.0 0 18571 2023 12 Z (Dec 2023) \n", + " 7.0 0 10410 2024 1 F (Jan 2024) \n", + " 8.0 0 2588 2024 2 G (Feb 2024) \n", + " 9.0 0 114 2024 3 H (Mar 2024) \n", + "\n", + " File Expired \n", + "Trade Date Tenor_Monthly \n", + "2004-03-26 2.0 2004-05-18.m_5.CFE_VX_K2004.csv True \n", + " 2.0 2004-05-19.m_5.CFE_VX_K2004.csv True \n", + " 3.0 2004-06-15.m_6.CFE_VX_M2004.csv True \n", + " 3.0 2004-06-16.m_6.CFE_VX_M2004.csv True \n", + " 5.0 2004-08-17.m_8.CFE_VX_Q2004.csv True \n", + "... ... ... \n", + "2023-07-13 5.0 2023-11-15.w_.CFE_VX_2023.csv False \n", + " 6.0 2023-12-20.w_.CFE_VX_2023.csv False \n", + " 7.0 2024-01-17.w_.CFE_VX_2024.csv False \n", + " 8.0 2024-02-14.w_.CFE_VX_2024.csv False \n", + " 9.0 2024-03-20.w_.CFE_VX_2024.csv False \n", + "\n", + "[38577 rows x 17 columns]" + ] + }, + "execution_count": 55, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#we want to index by TradeDate, Tenor_Monthly\n", + "df=vix_futures_monthly_skinny.set_index([\"Trade Date\",\"Tenor_Monthly\"])\n", + "df\n", + " \n" + ] + }, + { + "cell_type": "code", + "execution_count": 60, + "id": "1e4c33e9", + "metadata": {}, + "outputs": [ + { + "ename": "ValueError", + "evalue": "cannot convert a DataFrame with a non-unique MultiIndex into xarray", + "output_type": "error", + "traceback": [ + "\u001b[1;31m---------------------------------------------------------------------------\u001b[0m", + "\u001b[1;31mValueError\u001b[0m Traceback (most recent call last)", + "Cell \u001b[1;32mIn[60], line 2\u001b[0m\n\u001b[0;32m 1\u001b[0m df\u001b[39m=\u001b[39mdf\u001b[39m.\u001b[39mdrop_duplicates()\n\u001b[1;32m----> 2\u001b[0m aaa\u001b[39m=\u001b[39mdf\u001b[39m.\u001b[39;49mto_xarray()\n", + "File \u001b[1;32mc:\\Users\\doug\\code\\vix_utils\\vix_utils\\.venv\\Lib\\site-packages\\pandas\\core\\generic.py:3118\u001b[0m, in \u001b[0;36mNDFrame.to_xarray\u001b[1;34m(self)\u001b[0m\n\u001b[0;32m 3116\u001b[0m \u001b[39mreturn\u001b[39;00m xarray\u001b[39m.\u001b[39mDataArray\u001b[39m.\u001b[39mfrom_series(\u001b[39mself\u001b[39m)\n\u001b[0;32m 3117\u001b[0m \u001b[39melse\u001b[39;00m:\n\u001b[1;32m-> 3118\u001b[0m \u001b[39mreturn\u001b[39;00m xarray\u001b[39m.\u001b[39;49mDataset\u001b[39m.\u001b[39;49mfrom_dataframe(\u001b[39mself\u001b[39;49m)\n", + "File \u001b[1;32mc:\\Users\\doug\\code\\vix_utils\\vix_utils\\.venv\\Lib\\site-packages\\xarray\\core\\dataset.py:6402\u001b[0m, in \u001b[0;36mDataset.from_dataframe\u001b[1;34m(cls, dataframe, sparse)\u001b[0m\n\u001b[0;32m 6399\u001b[0m idx \u001b[39m=\u001b[39m remove_unused_levels_categories(dataframe\u001b[39m.\u001b[39mindex)\n\u001b[0;32m 6401\u001b[0m \u001b[39mif\u001b[39;00m \u001b[39misinstance\u001b[39m(idx, pd\u001b[39m.\u001b[39mMultiIndex) \u001b[39mand\u001b[39;00m \u001b[39mnot\u001b[39;00m idx\u001b[39m.\u001b[39mis_unique:\n\u001b[1;32m-> 6402\u001b[0m \u001b[39mraise\u001b[39;00m \u001b[39mValueError\u001b[39;00m(\n\u001b[0;32m 6403\u001b[0m \u001b[39m\"\u001b[39m\u001b[39mcannot convert a DataFrame with a non-unique MultiIndex into xarray\u001b[39m\u001b[39m\"\u001b[39m\n\u001b[0;32m 6404\u001b[0m )\n\u001b[0;32m 6406\u001b[0m \u001b[39m# Cast to a NumPy array first, in case the Series is a pandas Extension\u001b[39;00m\n\u001b[0;32m 6407\u001b[0m \u001b[39m# array (which doesn't have a valid NumPy dtype)\u001b[39;00m\n\u001b[0;32m 6408\u001b[0m \u001b[39m# TODO: allow users to control how this casting happens, e.g., by\u001b[39;00m\n\u001b[0;32m 6409\u001b[0m \u001b[39m# forwarding arguments to pandas.Series.to_numpy?\u001b[39;00m\n\u001b[0;32m 6410\u001b[0m arrays \u001b[39m=\u001b[39m [(k, np\u001b[39m.\u001b[39masarray(v)) \u001b[39mfor\u001b[39;00m k, v \u001b[39min\u001b[39;00m dataframe\u001b[39m.\u001b[39mitems()]\n", + "\u001b[1;31mValueError\u001b[0m: cannot convert a DataFrame with a non-unique MultiIndex into xarray" + ] + } + ], + "source": [ + "\n", + "df=df.drop_duplicates()\n", + "aaa=df.to_xarray()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "62eca16d", + "metadata": {}, + "outputs": [], + "source": [ + "#plot futures\n", + "close.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "3ef185e2", + "metadata": {}, + "outputs": [], + "source": [ + "vix_cash_wide.plot()" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/vix_utils/examples/vix_utils.ipynb b/src/vix_utils/examples/vix_utils.ipynb new file mode 100644 index 0000000..645008a --- /dev/null +++ b/src/vix_utils/examples/vix_utils.ipynb @@ -0,0 +1,2585 @@ +{ + "cells": [ + { + "cell_type": "markdown", + "id": "69334115", + "metadata": {}, + "source": [ + "Examples of Loading Term Structure (futures and spot vix indexes)" + ] + }, + { + "cell_type": "code", + "execution_count": 1, + "id": "4eb4c0c1", + "metadata": {}, + "outputs": [], + "source": [ + "import vix_utils, pandas as pd, logging, asyncio,sys,matplotlib.pyplot as plt, scipy.stats as bc\n", + "from itertools import chain" + ] + }, + { + "cell_type": "markdown", + "id": "ec69b259", + "metadata": {}, + "source": [ + "In Jupyter, use the vix_utils asynchronous functions to the load the data\n", + "here we read the futures and spot term structure" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "id": "263f03df", + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "WARNING:root:\n", + "Duplicates detected\n", + " Trade Date Weekly Tenor_Monthly Tenor_Days \\\n", + "16401 2013-01-02 00:00:00-05:00 False 1.0 14 \n", + "16402 2013-01-02 00:00:00-05:00 False 1.0 14 \n", + "16403 2013-01-02 00:00:00-05:00 False 2.0 42 \n", + "16404 2013-01-02 00:00:00-05:00 False 2.0 42 \n", + "16405 2013-01-02 00:00:00-05:00 False 3.0 76 \n", + "... ... ... ... ... \n", + "19988 2013-12-17 00:00:00-05:00 False 1.0 1 \n", + "39859 2020-02-27 00:00:00-05:00 True 2.0 26 \n", + "39860 2020-02-27 00:00:00-05:00 True 2.0 26 \n", + "39874 2020-02-28 00:00:00-05:00 True 2.0 25 \n", + "39875 2020-02-28 00:00:00-05:00 True 2.0 25 \n", + "\n", + " Tenor_Trade_Days Expiry Open High Low Close \\\n", + "16401 10.0 2013-01-16 00:00:00-05:00 16.80 16.80 15.50 15.60 \n", + "16402 10.0 2013-01-16 00:00:00-05:00 16.80 16.80 15.50 15.60 \n", + "16403 30.0 2013-02-13 00:00:00-05:00 17.50 17.75 16.65 16.72 \n", + "16404 30.0 2013-02-13 00:00:00-05:00 17.50 17.75 16.65 16.72 \n", + "16405 55.0 2013-03-20 00:00:00-04:00 18.80 18.85 17.95 18.06 \n", + "... ... ... ... ... ... ... \n", + "19988 1.0 2013-12-18 00:00:00-05:00 15.88 16.40 15.73 16.23 \n", + "39859 19.0 2020-03-25 00:00:00-04:00 24.15 25.35 22.15 24.25 \n", + "39860 19.0 2020-03-25 00:00:00-04:00 24.15 25.35 22.15 24.25 \n", + "39874 18.0 2020-03-25 00:00:00-04:00 26.50 27.50 25.65 26.50 \n", + "39875 18.0 2020-03-25 00:00:00-04:00 26.50 27.50 25.65 26.50 \n", + "\n", + " Settle Change Total Volume EFP Open Interest Year MonthOfYear \\\n", + "16401 0.000 0.000 97535 3632 120663 2013 1 \n", + "16402 15.600 -2.100 97535 3632 120663 2013 1 \n", + "16403 0.000 0.000 62489 2946 69517 2013 2 \n", + "16404 16.750 -1.750 62489 2946 69517 2013 2 \n", + "16405 0.000 0.000 25310 0 45750 2013 3 \n", + "... ... ... ... ... ... ... ... \n", + "19988 16.250 0.350 56787 0 33108 2013 12 \n", + "39859 25.025 3.000 48 0 63 2020 3 \n", + "39860 25.025 3.000 48 0 63 2020 3 \n", + "39874 26.100 1.075 112 0 139 2020 3 \n", + "39875 26.100 1.075 112 0 139 2020 3 \n", + "\n", + " Futures File Expired \n", + "16401 F (Jan 2013) 2013-01-16.w_.CFE_VX_2013.csv True \n", + "16402 F (Jan 13) 2013-01-16.m_1.CFE_VX_F2013.csv True \n", + "16403 G (Feb 2013) 2013-02-13.w_.CFE_VX_2013.csv True \n", + "16404 G (Feb 13) 2013-02-13.m_2.CFE_VX_G2013.csv True \n", + "16405 H (Mar 2013) 2013-03-20.w_.CFE_VX_2013.csv True \n", + "... ... ... ... \n", + "19988 Z (Dec 13) 2013-12-18.m_12.CFE_VX_Z2013.csv True \n", + "39859 H (Mar 2020) 2020-03-25.w_.CFE_VX_2020.csv True \n", + "39860 H (Mar 2020) 2020-03-25.w_.CFE_VX_2020.csv True \n", + "39874 H (Mar 2020) 2020-03-25.w_.CFE_VX_2020.csv True \n", + "39875 H (Mar 2020) 2020-03-25.w_.CFE_VX_2020.csv True \n", + "\n", + "[2834 rows x 20 columns], cleaning them out\n" + ] + } + ], + "source": [ + "vix_futures,vix_spot=await asyncio.gather(vix_utils.async_load_vix_term_structure(),vix_utils.async_get_vix_index_histories())" + ] + }, + { + "cell_type": "markdown", + "id": "d08cf0b3", + "metadata": {}, + "source": [ + "Another way, reading the futures, then the spot structure, in sequence instead of concurrently" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "id": "4aac48ae", + "metadata": {}, + "outputs": [], + "source": [ + "vix_futures_skinny_2 = await vix_utils.async_load_vix_term_structure()\n", + "vix_spot_2=await vix_utils.async_get_vix_index_histories()" + ] + }, + { + "cell_type": "markdown", + "id": "b648822f", + "metadata": {}, + "source": [ + "Another way to load the data, it won't work if you have a running event loop, \n", + "like we do in Jupyter. If your project generally doesn't use asyncio, you can use these calls instead of the \n", + "async_ calls to load the data. Ignore the errors of the following cel." + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "id": "1388fd57", + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "use the api functions starting with async_ to load the term structure and vix index histories\n" + ] + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "C:\\Users\\doug\\AppData\\Local\\Temp\\ipykernel_31492\\3817485108.py:4: RuntimeWarning: coroutine 'async_load_vix_term_structure' was never awaited\n", + " print(\"use the api functions starting with async_ to load the term structure and vix index histories\")\n", + "RuntimeWarning: Enable tracemalloc to get the object allocation traceback\n" + ] + } + ], + "source": [ + "\n", + "try:\n", + " vix_futures_skinny_3,vix_spot_3 = vix_utils.load_vix_term_structure(),vix_utils.get_vix_index_histories()\n", + "except Exception as e:\n", + " print(\"use the api functions starting with async_ to load the term structure and vix index histories\")" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "id": "7bb42143", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
1.01.5...5.06.0
ChangeCloseExpiryFileHighLowOpenSettleTenor_DaysChange...Tenor_DaysChangeCloseExpiryFileHighLowOpenSettleTenor_Days
Trade Date
2004-03-26NaNNaNNaTNaNNaNNaNNaNNaNNaNNaN...144.0NaNNaNNaTNaNNaNNaNNaNNaNNaN
2004-03-29NaNNaNNaTNaNNaNNaNNaNNaNNaNNaN...141.0NaNNaNNaTNaNNaNNaNNaNNaNNaN
2004-03-30NaNNaNNaTNaNNaNNaNNaNNaNNaNNaN...140.0NaNNaNNaTNaNNaNNaNNaNNaNNaN
2004-03-31NaNNaNNaTNaNNaNNaNNaNNaNNaNNaN...139.0NaNNaNNaTNaNNaNNaNNaNNaNNaN
2004-04-01NaNNaNNaTNaNNaNNaNNaNNaNNaNNaN...138.0NaNNaNNaTNaNNaNNaNNaNNaNNaN
..................................................................
2024-01-26-0.108814.142024-02-142024-02-14.w_.CFE_VX_2024.csv14.4513.9014.2514.117319.0-0.120080...NaN-0.097817.032024-07-172024-07-17.w_.CFE_VX_2024.csv17.1516.9117.0816.9901172.0
2024-01-290.133514.202024-02-142024-02-14.w_.CFE_VX_2024.csv14.4514.0914.1514.250816.00.102352...NaN-0.039116.962024-07-172024-07-17.w_.CFE_VX_2024.csv17.1716.9217.0516.9510169.0
2024-01-30-0.257914.102024-02-142024-02-14.w_.CFE_VX_2024.csv14.3013.9514.2013.992915.0-0.229452...NaN0.076517.072024-07-172024-07-17.w_.CFE_VX_2024.csv17.1016.8517.0017.0275168.0
2024-01-310.880614.882024-02-142024-02-14.w_.CFE_VX_2024.csv15.0013.8414.1014.873514.00.731200...NaN0.455417.472024-07-172024-07-17.w_.CFE_VX_2024.csv17.5516.9317.1017.4829167.0
2024-02-01-0.175814.392024-02-142024-02-14.w_.CFE_VX_2024.csv15.0114.3514.8514.697713.0-0.141048...NaN-0.182317.192024-07-172024-07-17.w_.CFE_VX_2024.csv17.5517.1717.4517.3006166.0
\n", + "

4996 rows × 63 columns

\n", + "
" + ], + "text/plain": [ + " 1.0 \\\n", + " Change Close Expiry File High \n", + "Trade Date \n", + "2004-03-26 NaN NaN NaT NaN NaN \n", + "2004-03-29 NaN NaN NaT NaN NaN \n", + "2004-03-30 NaN NaN NaT NaN NaN \n", + "2004-03-31 NaN NaN NaT NaN NaN \n", + "2004-04-01 NaN NaN NaT NaN NaN \n", + "... ... ... ... ... ... \n", + "2024-01-26 -0.1088 14.14 2024-02-14 2024-02-14.w_.CFE_VX_2024.csv 14.45 \n", + "2024-01-29 0.1335 14.20 2024-02-14 2024-02-14.w_.CFE_VX_2024.csv 14.45 \n", + "2024-01-30 -0.2579 14.10 2024-02-14 2024-02-14.w_.CFE_VX_2024.csv 14.30 \n", + "2024-01-31 0.8806 14.88 2024-02-14 2024-02-14.w_.CFE_VX_2024.csv 15.00 \n", + "2024-02-01 -0.1758 14.39 2024-02-14 2024-02-14.w_.CFE_VX_2024.csv 15.01 \n", + "\n", + " 1.5 ... 5.0 \\\n", + " Low Open Settle Tenor_Days Change ... Tenor_Days \n", + "Trade Date ... \n", + "2004-03-26 NaN NaN NaN NaN NaN ... 144.0 \n", + "2004-03-29 NaN NaN NaN NaN NaN ... 141.0 \n", + "2004-03-30 NaN NaN NaN NaN NaN ... 140.0 \n", + "2004-03-31 NaN NaN NaN NaN NaN ... 139.0 \n", + "2004-04-01 NaN NaN NaN NaN NaN ... 138.0 \n", + "... ... ... ... ... ... ... ... \n", + "2024-01-26 13.90 14.25 14.1173 19.0 -0.120080 ... NaN \n", + "2024-01-29 14.09 14.15 14.2508 16.0 0.102352 ... NaN \n", + "2024-01-30 13.95 14.20 13.9929 15.0 -0.229452 ... NaN \n", + "2024-01-31 13.84 14.10 14.8735 14.0 0.731200 ... NaN \n", + "2024-02-01 14.35 14.85 14.6977 13.0 -0.141048 ... NaN \n", + "\n", + " 6.0 \\\n", + " Change Close Expiry File High \n", + "Trade Date \n", + "2004-03-26 NaN NaN NaT NaN NaN \n", + "2004-03-29 NaN NaN NaT NaN NaN \n", + "2004-03-30 NaN NaN NaT NaN NaN \n", + "2004-03-31 NaN NaN NaT NaN NaN \n", + "2004-04-01 NaN NaN NaT NaN NaN \n", + "... ... ... ... ... ... \n", + "2024-01-26 -0.0978 17.03 2024-07-17 2024-07-17.w_.CFE_VX_2024.csv 17.15 \n", + "2024-01-29 -0.0391 16.96 2024-07-17 2024-07-17.w_.CFE_VX_2024.csv 17.17 \n", + "2024-01-30 0.0765 17.07 2024-07-17 2024-07-17.w_.CFE_VX_2024.csv 17.10 \n", + "2024-01-31 0.4554 17.47 2024-07-17 2024-07-17.w_.CFE_VX_2024.csv 17.55 \n", + "2024-02-01 -0.1823 17.19 2024-07-17 2024-07-17.w_.CFE_VX_2024.csv 17.55 \n", + "\n", + " \n", + " Low Open Settle Tenor_Days \n", + "Trade Date \n", + "2004-03-26 NaN NaN NaN NaN \n", + "2004-03-29 NaN NaN NaN NaN \n", + "2004-03-30 NaN NaN NaN NaN \n", + "2004-03-31 NaN NaN NaN NaN \n", + "2004-04-01 NaN NaN NaN NaN \n", + "... ... ... ... ... \n", + "2024-01-26 16.91 17.08 16.9901 172.0 \n", + "2024-01-29 16.92 17.05 16.9510 169.0 \n", + "2024-01-30 16.85 17.00 17.0275 168.0 \n", + "2024-01-31 16.93 17.10 17.4829 167.0 \n", + "2024-02-01 17.17 17.45 17.3006 166.0 \n", + "\n", + "[4996 rows x 63 columns]" + ] + }, + "execution_count": 5, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "#manipulate the data to get what we want to display\n", + "vix_spot_wide=vix_utils.pivot_spot_term_structure_on_symbol(vix_spot)\n", + "vix_futures_monthly_skinny=vix_utils.select_monthly_futures(vix_futures)\n", + "vix_futures_wide=vix_utils.pivot_futures_on_monthly_tenor(vix_futures_monthly_skinny)\n", + "vix_futures_wide=vix_utils.append_continuous_maturity_one_month(vix_futures_wide)\n", + "selected_tenors=[1,1.5,2,3,4,5,6]\n", + "original_vix_futures_wide=pd.DataFrame(vix_futures_wide)\n", + "vix_futures_wide=vix_futures_wide[selected_tenors]\n", + "vix_futures_wide\n", + "\n", + "\n" + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "id": "5bb1b3a3", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
1.01.5...5.06.0
ChangeCloseExpiryFileHighLowOpenSettleTenor_DaysChange...Tenor_DaysChangeCloseExpiryFileHighLowOpenSettleTenor_Days
Trade Date
2004-03-26NaNNaNNaTNaNNaNNaNNaNNaNNaNNaN...144.0NaNNaNNaTNaNNaNNaNNaNNaNNaN
2004-03-29NaNNaNNaTNaNNaNNaNNaNNaNNaNNaN...141.0NaNNaNNaTNaNNaNNaNNaNNaNNaN
2004-03-30NaNNaNNaTNaNNaNNaNNaNNaNNaNNaN...140.0NaNNaNNaTNaNNaNNaNNaNNaNNaN
2004-03-31NaNNaNNaTNaNNaNNaNNaNNaNNaNNaN...139.0NaNNaNNaTNaNNaNNaNNaNNaNNaN
2004-04-01NaNNaNNaTNaNNaNNaNNaNNaNNaNNaN...138.0NaNNaNNaTNaNNaNNaNNaNNaNNaN
..................................................................
2024-01-26-0.108814.142024-02-142024-02-14.w_.CFE_VX_2024.csv14.4513.9014.2514.117319.0-0.120080...NaN-0.097817.032024-07-172024-07-17.w_.CFE_VX_2024.csv17.1516.9117.0816.9901172.0
2024-01-290.133514.202024-02-142024-02-14.w_.CFE_VX_2024.csv14.4514.0914.1514.250816.00.102352...NaN-0.039116.962024-07-172024-07-17.w_.CFE_VX_2024.csv17.1716.9217.0516.9510169.0
2024-01-30-0.257914.102024-02-142024-02-14.w_.CFE_VX_2024.csv14.3013.9514.2013.992915.0-0.229452...NaN0.076517.072024-07-172024-07-17.w_.CFE_VX_2024.csv17.1016.8517.0017.0275168.0
2024-01-310.880614.882024-02-142024-02-14.w_.CFE_VX_2024.csv15.0013.8414.1014.873514.00.731200...NaN0.455417.472024-07-172024-07-17.w_.CFE_VX_2024.csv17.5516.9317.1017.4829167.0
2024-02-01-0.175814.392024-02-142024-02-14.w_.CFE_VX_2024.csv15.0114.3514.8514.697713.0-0.141048...NaN-0.182317.192024-07-172024-07-17.w_.CFE_VX_2024.csv17.5517.1717.4517.3006166.0
\n", + "

4996 rows × 72 columns

\n", + "
" + ], + "text/plain": [ + " 1.0 \\\n", + " Change Close Expiry File High \n", + "Trade Date \n", + "2004-03-26 NaN NaN NaT NaN NaN \n", + "2004-03-29 NaN NaN NaT NaN NaN \n", + "2004-03-30 NaN NaN NaT NaN NaN \n", + "2004-03-31 NaN NaN NaT NaN NaN \n", + "2004-04-01 NaN NaN NaT NaN NaN \n", + "... ... ... ... ... ... \n", + "2024-01-26 -0.1088 14.14 2024-02-14 2024-02-14.w_.CFE_VX_2024.csv 14.45 \n", + "2024-01-29 0.1335 14.20 2024-02-14 2024-02-14.w_.CFE_VX_2024.csv 14.45 \n", + "2024-01-30 -0.2579 14.10 2024-02-14 2024-02-14.w_.CFE_VX_2024.csv 14.30 \n", + "2024-01-31 0.8806 14.88 2024-02-14 2024-02-14.w_.CFE_VX_2024.csv 15.00 \n", + "2024-02-01 -0.1758 14.39 2024-02-14 2024-02-14.w_.CFE_VX_2024.csv 15.01 \n", + "\n", + " 1.5 ... 5.0 \\\n", + " Low Open Settle Tenor_Days Change ... Tenor_Days \n", + "Trade Date ... \n", + "2004-03-26 NaN NaN NaN NaN NaN ... 144.0 \n", + "2004-03-29 NaN NaN NaN NaN NaN ... 141.0 \n", + "2004-03-30 NaN NaN NaN NaN NaN ... 140.0 \n", + "2004-03-31 NaN NaN NaN NaN NaN ... 139.0 \n", + "2004-04-01 NaN NaN NaN NaN NaN ... 138.0 \n", + "... ... ... ... ... ... ... ... \n", + "2024-01-26 13.90 14.25 14.1173 19.0 -0.120080 ... NaN \n", + "2024-01-29 14.09 14.15 14.2508 16.0 0.102352 ... NaN \n", + "2024-01-30 13.95 14.20 13.9929 15.0 -0.229452 ... NaN \n", + "2024-01-31 13.84 14.10 14.8735 14.0 0.731200 ... NaN \n", + "2024-02-01 14.35 14.85 14.6977 13.0 -0.141048 ... NaN \n", + "\n", + " 6.0 \\\n", + " Change Close Expiry File High \n", + "Trade Date \n", + "2004-03-26 NaN NaN NaT NaN NaN \n", + "2004-03-29 NaN NaN NaT NaN NaN \n", + "2004-03-30 NaN NaN NaT NaN NaN \n", + "2004-03-31 NaN NaN NaT NaN NaN \n", + "2004-04-01 NaN NaN NaT NaN NaN \n", + "... ... ... ... ... ... \n", + "2024-01-26 -0.0978 17.03 2024-07-17 2024-07-17.w_.CFE_VX_2024.csv 17.15 \n", + "2024-01-29 -0.0391 16.96 2024-07-17 2024-07-17.w_.CFE_VX_2024.csv 17.17 \n", + "2024-01-30 0.0765 17.07 2024-07-17 2024-07-17.w_.CFE_VX_2024.csv 17.10 \n", + "2024-01-31 0.4554 17.47 2024-07-17 2024-07-17.w_.CFE_VX_2024.csv 17.55 \n", + "2024-02-01 -0.1823 17.19 2024-07-17 2024-07-17.w_.CFE_VX_2024.csv 17.55 \n", + "\n", + " \n", + " Low Open Settle Tenor_Days \n", + "Trade Date \n", + "2004-03-26 NaN NaN NaN NaN \n", + "2004-03-29 NaN NaN NaN NaN \n", + "2004-03-30 NaN NaN NaN NaN \n", + "2004-03-31 NaN NaN NaN NaN \n", + "2004-04-01 NaN NaN NaN NaN \n", + "... ... ... ... ... \n", + "2024-01-26 16.91 17.08 16.9901 172.0 \n", + "2024-01-29 16.92 17.05 16.9510 169.0 \n", + "2024-01-30 16.85 17.00 17.0275 168.0 \n", + "2024-01-31 16.93 17.10 17.4829 167.0 \n", + "2024-02-01 17.17 17.45 17.3006 166.0 \n", + "\n", + "[4996 rows x 72 columns]" + ] + }, + "execution_count": 6, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "\n", + "vix_futures_wide=vix_utils.append_continuous_maturity_one_month(vix_futures_wide)\n", + "vix_futures_wide\n" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "id": "60a58d86", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
1.01.51.52.03.04.05.06.0
Trade Date
2004-03-26NaNNaNNaN20.2720.20NaN20.06NaN
2004-03-29NaNNaNNaN19.7719.76NaN19.76NaN
2004-03-30NaNNaNNaN19.6119.73NaN19.92NaN
2004-03-31NaNNaNNaN19.7219.90NaN20.18NaN
2004-04-01NaNNaNNaN19.6519.94NaN20.28NaN
...........................
2024-01-2614.1414.634414.634415.1715.8716.21NaN17.03
2024-01-2914.2014.735614.735615.2315.9116.25NaN16.96
2024-01-3014.1014.660014.660015.1015.8716.25NaN17.07
2024-01-3114.8815.384015.384015.7216.4116.71NaN17.47
2024-02-0114.3915.010815.010815.3616.1016.43NaN17.19
\n", + "

4996 rows × 8 columns

\n", + "
" + ], + "text/plain": [ + " 1.0 1.5 1.5 2.0 3.0 4.0 5.0 6.0\n", + "Trade Date \n", + "2004-03-26 NaN NaN NaN 20.27 20.20 NaN 20.06 NaN\n", + "2004-03-29 NaN NaN NaN 19.77 19.76 NaN 19.76 NaN\n", + "2004-03-30 NaN NaN NaN 19.61 19.73 NaN 19.92 NaN\n", + "2004-03-31 NaN NaN NaN 19.72 19.90 NaN 20.18 NaN\n", + "2004-04-01 NaN NaN NaN 19.65 19.94 NaN 20.28 NaN\n", + "... ... ... ... ... ... ... ... ...\n", + "2024-01-26 14.14 14.6344 14.6344 15.17 15.87 16.21 NaN 17.03\n", + "2024-01-29 14.20 14.7356 14.7356 15.23 15.91 16.25 NaN 16.96\n", + "2024-01-30 14.10 14.6600 14.6600 15.10 15.87 16.25 NaN 17.07\n", + "2024-01-31 14.88 15.3840 15.3840 15.72 16.41 16.71 NaN 17.47\n", + "2024-02-01 14.39 15.0108 15.0108 15.36 16.10 16.43 NaN 17.19\n", + "\n", + "[4996 rows x 8 columns]" + ] + }, + "execution_count": 7, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "close=vix_futures_wide.swaplevel(axis=1)[\"Close\"]\n", + "close" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "id": "62eca16d", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "#plot futures\n", + "close.plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "id": "00758a83", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
Close...Low
SymbolGVZLONGVOLOVXSHORTVOLVIXVIX1DVIX3MVIX6MVIX9DVVIX...LONGVOLOVXSHORTVOLVIXVIX1DVIX3MVIX6MVIX9DVVIXVXTLT
Trade Date
1990-01-02NaNNaNNaNNaN17.24NaNNaNNaNNaNNaN...NaNNaNNaN17.24NaNNaNNaNNaNNaNNaN
1990-01-03NaNNaNNaNNaN18.19NaNNaNNaNNaNNaN...NaNNaNNaN18.19NaNNaNNaNNaNNaNNaN
1990-01-04NaNNaNNaNNaN19.22NaNNaNNaNNaNNaN...NaNNaNNaN19.22NaNNaNNaNNaNNaNNaN
1990-01-05NaNNaNNaNNaN20.11NaNNaNNaNNaNNaN...NaNNaNNaN20.11NaNNaNNaNNaNNaNNaN
1990-01-08NaNNaNNaNNaN20.26NaNNaNNaNNaNNaN...NaNNaNNaN20.26NaNNaNNaNNaNNaNNaN
..................................................................
2024-01-2611.9115.836534.782551.521113.269.4715.0316.8613.0782.20...NaNNaNNaN13.208.2914.8916.7412.95NaNNaN
2024-01-2913.0815.952036.322532.907113.609.3315.2216.9713.9583.40...NaNNaNNaN13.597.0615.1916.9413.88NaNNaN
2024-01-3013.0515.704936.192572.145613.3114.5015.1416.9313.7282.24...NaNNaNNaN13.238.2115.0716.8613.62NaNNaN
2024-01-3113.1616.549137.252433.877214.3513.4715.9617.5814.5587.56...NaNNaNNaN13.1811.8015.1416.9713.51NaNNaN
2024-02-0113.7216.323535.382467.054913.8813.9115.5017.2213.2884.83...NaNNaNNaN13.879.8415.4517.2213.22NaNNaN
\n", + "

8602 rows × 44 columns

\n", + "
" + ], + "text/plain": [ + " Close \\\n", + "Symbol GVZ LONGVOL OVX SHORTVOL VIX VIX1D VIX3M VIX6M \n", + "Trade Date \n", + "1990-01-02 NaN NaN NaN NaN 17.24 NaN NaN NaN \n", + "1990-01-03 NaN NaN NaN NaN 18.19 NaN NaN NaN \n", + "1990-01-04 NaN NaN NaN NaN 19.22 NaN NaN NaN \n", + "1990-01-05 NaN NaN NaN NaN 20.11 NaN NaN NaN \n", + "1990-01-08 NaN NaN NaN NaN 20.26 NaN NaN NaN \n", + "... ... ... ... ... ... ... ... ... \n", + "2024-01-26 11.91 15.8365 34.78 2551.5211 13.26 9.47 15.03 16.86 \n", + "2024-01-29 13.08 15.9520 36.32 2532.9071 13.60 9.33 15.22 16.97 \n", + "2024-01-30 13.05 15.7049 36.19 2572.1456 13.31 14.50 15.14 16.93 \n", + "2024-01-31 13.16 16.5491 37.25 2433.8772 14.35 13.47 15.96 17.58 \n", + "2024-02-01 13.72 16.3235 35.38 2467.0549 13.88 13.91 15.50 17.22 \n", + "\n", + " ... Low \\\n", + "Symbol VIX9D VVIX ... LONGVOL OVX SHORTVOL VIX VIX1D VIX3M \n", + "Trade Date ... \n", + "1990-01-02 NaN NaN ... NaN NaN NaN 17.24 NaN NaN \n", + "1990-01-03 NaN NaN ... NaN NaN NaN 18.19 NaN NaN \n", + "1990-01-04 NaN NaN ... NaN NaN NaN 19.22 NaN NaN \n", + "1990-01-05 NaN NaN ... NaN NaN NaN 20.11 NaN NaN \n", + "1990-01-08 NaN NaN ... NaN NaN NaN 20.26 NaN NaN \n", + "... ... ... ... ... .. ... ... ... ... \n", + "2024-01-26 13.07 82.20 ... NaN NaN NaN 13.20 8.29 14.89 \n", + "2024-01-29 13.95 83.40 ... NaN NaN NaN 13.59 7.06 15.19 \n", + "2024-01-30 13.72 82.24 ... NaN NaN NaN 13.23 8.21 15.07 \n", + "2024-01-31 14.55 87.56 ... NaN NaN NaN 13.18 11.80 15.14 \n", + "2024-02-01 13.28 84.83 ... NaN NaN NaN 13.87 9.84 15.45 \n", + "\n", + " \n", + "Symbol VIX6M VIX9D VVIX VXTLT \n", + "Trade Date \n", + "1990-01-02 NaN NaN NaN NaN \n", + "1990-01-03 NaN NaN NaN NaN \n", + "1990-01-04 NaN NaN NaN NaN \n", + "1990-01-05 NaN NaN NaN NaN \n", + "1990-01-08 NaN NaN NaN NaN \n", + "... ... ... ... ... \n", + "2024-01-26 16.74 12.95 NaN NaN \n", + "2024-01-29 16.94 13.88 NaN NaN \n", + "2024-01-30 16.86 13.62 NaN NaN \n", + "2024-01-31 16.97 13.51 NaN NaN \n", + "2024-02-01 17.22 13.22 NaN NaN \n", + "\n", + "[8602 rows x 44 columns]" + ] + }, + "execution_count": 9, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vix_spot_wide" + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "id": "3ef185e2", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 10, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAigAAAGVCAYAAADUsQqzAAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjcuMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy88F64QAAAACXBIWXMAAA9hAAAPYQGoP6dpAAB/C0lEQVR4nO3ddXwT9/8H8NcldYdSKliLu8sKjOEwZPiAwXAZA76D2Q82bI7DBBnbsDGGDNlgo8AY7u6uRdoCdW+Tz++PNGnkklySS3NJ38/Hgwfp3eXyucjd+z7y/nCMMQZCCCGEEAmROboAhBBCCCH6KEAhhBBCiORQgEIIIYQQyaEAhRBCCCGSQwEKIYQQQiSHAhRCCCGESA4FKIQQQgiRHDdHF8AaSqUST58+hb+/PziOc3RxCCGEECIAYwxpaWmIiIiATGa6jsQpA5SnT5+iXLlyji4GIYQQQqwQGxuLsmXLmtzGKQMUf39/AKoDDAgIcHBpCCGEECJEamoqypUrp7mOm+KUAYq6WScgIIACFEIIIcTJCOmeQZ1kCSGEECI5FKAQQgghRHIoQCGEEEKI5DhlHxShFAoF8vLyHF0Ml+bu7g65XO7oYhBCCHExLhmgMMYQFxeH5ORkRxelWAgKCkJYWBjlpCGEECIalwxQ1MFJ6dKl4ePjQxdOO2GMITMzEwkJCQCA8PBwB5eIEEKIq3C5AEWhUGiCk+DgYEcXx+V5e3sDABISElC6dGlq7iGEECIKl+skq+5z4uPj4+CSFB/q95r6+xBCCBGLywUoatSsU3TovSaEECI2lw1QCCGEEOK8KECRuAMHDoDjOJtHJEVGRmLx4sWilIkQQgixNwpQLPD8+XOMGzcO5cuXh6enJ8LCwtCpUyccPXrU0UUjhBDiSFe3AdvfBfJzHF0Sl+Fyo3jsqU+fPsjNzcWaNWtQsWJFxMfHY9++fXj58qWji0YIIcSRNg9T/R9aG4h+16FFcRVUgyJQcnIyDh8+jDlz5qBNmzaoUKECmjZtiqlTp+KNN97AiBEj0K1bN53n5OXloXTp0vjll18AAK1bt8bEiRMxadIklChRAqGhofjpp5+QkZGB4cOHw9/fH5UrV8auXbsMXv/o0aOoW7cuvLy88Morr+DKlSs667ds2YJatWrB09MTkZGRWLBggf3eDEIIIfzS4x1dApdBAYpAfn5+8PPzw/bt25GTY1iFN2rUKMTExODZs2eaZTt37kRmZib69++vWbZmzRqUKlUKp06dwsSJEzFu3Dj069cPzZs3x7lz59CxY0e8/fbbyMzM1Nn/Rx99hAULFuD06dMICQlB9+7dNcN6z549izfffBMDBgzA5cuXMWvWLEyfPh2rV6+2z5tBCCGE2BkFKAK5ublh9erVWLNmDYKCgtCiRQt88sknuHTpEgCgefPmqFatGn799VfNc1atWoV+/frBz89Ps6xevXqYNm0aqlSpgqlTp8LLywulSpXC6NGjUaVKFcyYMQMvX77U7Fdt5syZ6NChA+rUqYM1a9YgPj4e27ZtAwAsXLgQ7dq1w/Tp01G1alUMGzYMEyZMwLx584rgnSGEEFKIOboALoMCFAv06dMHT58+xV9//YXOnTvjwIEDaNiwoaamYtSoUVi1ahUAID4+Hrt27cKIESN09lG3bl3NY7lcjuDgYNSpU0ezLDQ0FAA06ePVoqOjNY9LliyJatWq4fr16wCA69evo0WLFjrbt2jRArdv34ZCobDxqAkhhJCiRwGKhby8vNChQwdMnz4dx44dw7BhwzBz5kwAwJAhQ3Dv3j0cP34c69atQ1RUFF599VWd57u7u+v8zXGczjJ10jOlUmnnIyGEEEKkiwIUG9WsWRMZGRkAgODgYPTs2ROrVq3C6tWrMXz4cNFe58SJE5rHSUlJuHXrFmrUqAEAqFGjhsFQ56NHj6Jq1ao0Nw4hhBQlRk08YqFhxgK9fPkS/fr1w4gRI1C3bl34+/vjzJkzmDt3Lnr06KHZbtSoUejWrRsUCgWGDh0q2ut//vnnCA4ORmhoKD799FOUKlUKPXv2BAB88MEHaNKkCb744gv0798fx48fxw8//IClS5eK9vqEEEJIUaIARSA/Pz80a9YMixYtwt27d5GXl4dy5cph9OjR+OSTTzTbtW/fHuHh4ahVqxYiIiJEe/3Zs2fjvffew+3bt1G/fn3s2LEDHh4eAICGDRti06ZNmDFjBr744guEh4fj888/x7Bhw0R7fUIIIaQocYw5X31UamoqAgMDkZKSgoCAAJ112dnZuH//PqKiouDl5VXkZUtPT0eZMmWwatUq9O7du8hf3xEc/Z4TQojDzQpU/V+jO9B/nWPLImGmrt/6qAZFJEqlEi9evMCCBQsQFBSEN954w9FFIoQQUtRSn5nfhghCAYpIHj16hKioKJQtWxarV6+Gmxu9tYQQUvw4XaOEZNFVVCSRkZFwwtYyQgghRJJomDEhhBBCJIcCFEIIIUQsVJMuGgpQCCGEECI5Fgcohw4dQvfu3REREQGO47B9+3ad9YwxzJgxA+Hh4fD29kb79u1x+/ZtnW0SExMxaNAgBAQEICgoCCNHjkR6erpNB0IIIYQQ12FxgJKRkYF69ephyZIlvOvnzp2L7777DsuXL8fJkyfh6+uLTp06ITs7W7PNoEGDcPXqVezduxc7d+7EoUOHMGbMGOuPghBCCJEEauIRi8WjeF5//XW8/vrrvOsYY1i8eDGmTZumSf++du1ahIaGYvv27RgwYACuX7+OmJgYnD59Go0bNwYAfP/99+jSpQvmz58vavZVQgghhDgnUfug3L9/H3FxcWjfvr1mWWBgIJo1a4bjx48DAI4fP46goCBNcAKo0sPLZDKcPHmSd785OTlITU3V+UcIIYQQ1yVqgBIXFwcACA0N1VkeGhqqWRcXF4fSpUvrrHdzc0PJkiU12+j75ptvEBgYqPlXrlw5MYstCd27d0fnzp151x0+fBgcx+HSpUvgOA4XLlwAAPzzzz/w8PDAuXPndLZfsGABSpUqZfT9JIQQYic0ikc0TjGKZ+rUqUhJSdH8i42NdXSRRDdy5Ejs3bsXjx8/Nli3atUqNG7c2GDegi5dumDIkCEYMmQIcnJyAADXrl3DtGnTsGTJEoSFhRVJ2QkhhBCxiRqgqC+I8fHxOsvj4+M168LCwpCQkKCzPj8/H4mJiUYvqJ6enggICND552q6deuGkJAQrF69Wmd5eno6Nm/ejJEjR/I+b9GiRUhPT8fMmTORn5+PoUOHonv37ujfv38RlJoQQoguqkERi6ip7qOiohAWFoZ9+/ahfv36AFQzF548eRLjxo0DAERHRyM5ORlnz55Fo0aNAAD//fcflEolmjVrJmZxNBhjyMpT2GXfpni7y8FxnKBt3dzcMGTIEKxevRqffvqp5nmbN2+GQqHAwIEDkZSUZPA8f39/rFy5Ep06dcL9+/cRGxuLmJgYUY+DEEIIKWoWByjp6em4c+eO5u/79+/jwoULKFmyJMqXL49Jkybhyy+/RJUqVRAVFYXp06cjIiICPXv2BADUqFEDnTt3xujRo7F8+XLk5eVhwoQJGDBggN1G8GTlKVBzxm677NuUa593go+H8Ld4xIgRmDdvHg4ePIjWrVsDUDXv9OnTB4GBgbwBCgC0bdsWffv2xYYNG7Bx40YEBweLUXxCCCHEYSxu4jlz5gwaNGiABg0aAADef/99NGjQADNmzAAAfPzxx5g4cSLGjBmDJk2aID09HTExMfDy8tLs47fffkP16tXRrl07dOnSBS1btsSKFStEOiTnVb16dTRv3hwrV64EANy5cweHDx822ryj9uTJE8TExMDHxweHDx8uiqISQgjhQ51kRcMxJ5yCNzU1FYGBgUhJSTHoj5KdnY379+8jKipKExQ5QxOP2sqVKzFx4kTExcVh9uzZ2LhxI27fvg2O4/DgwQNERUXh/PnzmiY0QNVZNjc3F59++ik6dOiAffv24bXXXhP5aIzje88JIaRYmRWo+j+sDvDOEceWRcJMXb/1idoHRao4jrOoqcWR3nzzTbz33ntYv3491q5di3HjxpkMcn7++WccOXIEly9fRoUKFTBu3DiMGDECly5dgq+vbxGWnBBCCBGPUwwzLk78/PzQv39/TJ06Fc+ePcOwYcOMbvvw4UO8//77mD9/PipUqAAAmDNnDjiOw5QpU4qoxIQQQoj4KECRoJEjRyIpKQmdOnUy2nGYMYaRI0ciOjpaZx4jHx8frF69GsuWLcPBgweLqsiEEEIAGmUsIudo9yhmoqOjwdc1KDIyUmf5v//+y/v8li1bIj8/327lI4QQQuyNalAIIYQQ0VAVilgoQCGEEELE4nwDYyWLAhRCCCFENBSgiIUCFEIIIUQsVIMiGgpQCCGEECI5FKAQQgghoqEaFLFQgEIIIYSIhZp4REMBCiGEECIaClDEQgEKIYQQQiSHAhRCCCFELNTEIxoKUCSie/fu6Ny5M++6w4cPg+M4XLp0CRzH4cKFCwCAf/75Bx4eHjh37pzO9gsWLECpUqUQFxcHAEhLS8OkSZNQoUIFeHt7o3nz5jh9+rTOc1q3bg2O48BxHDw9PVGmTBl0794dW7duFf9gCSGEEDMoQJGIkSNHYu/evXj8+LHBulWrVqFx48YICAjQWd6lSxcMGTIEQ4YMQU5ODgDg2rVrmDZtGpYsWYKwsDAAwKhRo7B37178+uuvuHz5Mjp27Ij27dvjyZMnOvsbPXo0nj17hrt372LLli2oWbMmBgwYoDMZISGEEFOoBkUsFKBIRLdu3RASEoLVq1frLE9PT8fmzZsxcuRI3uctWrQI6enpmDlzJvLz8zF06FB0794d/fv3BwBkZWVhy5YtmDt3Llq1aoXKlStj1qxZqFy5MpYtW6azLx8fH4SFhaFs2bJ45ZVXMGfOHPz444/46aefjE5MSAghRAs18YimeAQojAG5GUX/z4IvqpubG4YMGYLVq1frzFi8efNmKBQKDBw4kPd5/v7+WLlyJRYsWIBBgwYhNjZWJ/DIz8+HQqGAl5eXzvO8vb1x5MgRs+UaOnQoSpQoQU09hBAiCAUoYnFzdAGKRF4m8HVE0b/uJ08BD1/Bm48YMQLz5s3DwYMH0bp1awCq5p0+ffogMDAQSUlJvM9r27Yt+vbtiw0bNmDjxo0IDg7WrPP390d0dDS++OIL1KhRA6Ghofj9999x/PhxVK5c2WyZZDIZqlatigcPHgg+DkIIKbaoBkU0xaMGxUlUr14dzZs3x8qVKwEAd+7cweHDh40276g9efIEMTEx8PHxweHDhw3W//rrr2CMoUyZMvD09MR3332HgQMHQiYT9vEzxsBxnOUHRAghxQ4FKGIpHjUo7j6q2gxHvK6FRo4ciYkTJ2LJkiVYtWoVKlWqhNdee83kc0aPHo1GjRrh008/RYcOHdC3b1+d51SqVAkHDx5ERkYGUlNTER4ejv79+6NixYpmy6NQKHD79m00adLE4mMhhBBCrFU8AhSOs6ipxZHefPNNvPfee1i/fj3Wrl2LcePGmay9+Pnnn3HkyBFcvnwZFSpUwLhx4zBixAhcunQJvr66x+zr6wtfX18kJSVh9+7dmDt3rtnyrFmzBklJSejTp4/Nx0YIIS6PmnhEQ008EuPn54f+/ftj6tSpePbsGYYNG2Z024cPH+L999/H/PnzUaFCBQDAnDlzwHEcpkyZotlu9+7diImJwf3797F37160adMG1atXx/Dhw3X2l5mZibi4ODx+/BgnTpzA//3f/+Gdd97BuHHj0KZNG7scLyGEuBYKUMRCAYoEjRw5EklJSejUqRMiIvg79zLGMHLkSERHR+vkKfHx8cHq1auxbNkyHDx4EACQkpKC8ePHo3r16hgyZAhatmyJ3bt3w93dXWefP/30E8LDw1GpUiX07t0b165dw8aNG7F06VL7HSwhhLgSik9EwzHmfPVRqampCAwMREpKikHysuzsbNy/fx9RUVEGQ2uJfdB7Tggp9mYFqv4PLA9MvuzYskiYqeu3PqpBIYQQQojkUIBCCCGEiMbpGiUkiwIUQgghRCzO12tCsihAIYQQQkRDAYpYKEAhhBBCxEI1KKJx2QBFqVQ6ugjFBr3XhBBCxOZymWQ9PDwgk8nw9OlThISEwMPDg+aRsRPGGHJzc/H8+XPIZDJ4eHg4ukiEEOJgVIMiFpcLUGQyGaKiovDs2TM8feqA+XeKIR8fH5QvX17w5IOEEEKIOS4XoACqWpTy5csjPz8fCoXC0cVxaXK5HG5ublRLRQghAPVBEZFLBigAwHEc3N3dDdK5E0IIIfZDAYpYqE6eEEIIIZJDAQohhBBCJIcCFEIIIUQs1AdFNBSgEEIIIaKhAEUsFKAQQgghYqEaFNFQgEIIIYSIhgIUsVCAQgghhIiFalBEQwEKIYQQIhoKUMRCAQohhBBCJIcCFEIIIUQk+Qqa3V0sFKAQQgghIslTUBOPWChAIYQQQkRDAYpYKEAhhBBCiORQgEIIIYSIxFuR5ugiuAzRAxSFQoHp06cjKioK3t7eqFSpEr744gswrbHhjDHMmDED4eHh8Pb2Rvv27XH79m2xi0IIIQbOPkxEv+XHcOVJiqOLQggxQfQAZc6cOVi2bBl++OEHXL9+HXPmzMHcuXPx/fffa7aZO3cuvvvuOyxfvhwnT56Er68vOnXqhOzsbLGLQwghOvosO47TD5Lw1k8nHF0UQogJbmLv8NixY+jRowe6du0KAIiMjMTvv/+OU6dOAVDVnixevBjTpk1Djx49AABr165FaGgotm/fjgEDBohdJEIIAQBk5yk0j1Oz8x1YEkKIOaLXoDRv3hz79u3DrVu3AAAXL17EkSNH8PrrrwMA7t+/j7i4OLRv317znMDAQDRr1gzHjx/n3WdOTg5SU1N1/hFCiKVm77rh6CIQQgQSvQZlypQpSE1NRfXq1SGXy6FQKPDVV19h0KBBAIC4uDgAQGhoqM7zQkNDNev0ffPNN/jss8/ELiohpJjZeemZo4tACBFI9BqUTZs24bfffsP69etx7tw5rFmzBvPnz8eaNWus3ufUqVORkpKi+RcbGytiiQkhxYV2Ew8hRNpEr0H56KOPMGXKFE1fkjp16uDhw4f45ptvMHToUISFhQEA4uPjER4ernlefHw86tevz7tPT09PeHp6il1UQkgxk5tPacgJcRai16BkZmZCJtPdrVwuh1KpOjFERUUhLCwM+/bt06xPTU3FyZMnER0dLXZxCCGEEOKERK9B6d69O7766iuUL18etWrVwvnz57Fw4UKMGDECAMBxHCZNmoQvv/wSVapUQVRUFKZPn46IiAj07NlT7OIQQgghxAmJHqB8//33mD59Ot59910kJCQgIiICY8eOxYwZMzTbfPzxx8jIyMCYMWOQnJyMli1bIiYmBl5eXmIXhxBCCCFOiGPaKV6dRGpqKgIDA5GSkoKAgABHF4cQ4iSqfroLuYrCfigPZnd1YGmIS5kVqPWYshQbY8n1m+biIYQUH5yjC0AIEYoCFEIIIYRIDgUohBBCCJEcClAIIcUGtfAQ4jwoQCGEEEKI5FCAQgghhBDJoQCFEEIIIZJDAQohhBBCJIcCFEJIscFRL1lCnAYFKIQQQgiRHApQCCGEECI5FKAQQgghRHIoQCGEEEKI5FCAQggpNjjKJUuI06AAhRBCCCGSQwEKIYQQQiSHAhRCSLFBeVAIcR4UoBBCCCFEcihAIYQQQojkUIBCCCk2qIWHEOdBAQohpNjIyFU4ugiEEIEoQCGEEEJskZ3i6BK4JApQCCHFQnYe1Z4QO8l44egSuCQKUAghxUJyZp6ji0BcFWOah/e48g4siGuhAIUQQggRSR7cHF0El0EBCiGEECISDsz8RkQQClAIIYQQkVCAIh4KUAghxJGSHgInlgO5mY4uCbEaBSX2QI1lhBDiSMuaA7npQNJ94PU5ji4NsQajAMUeqAaFEEIcKTdd9f/9Q44tBxEFNfGIhwIUQkixIPmZjOku3CVQgCIeClAIIYQQm1BQYg8UoBBCiBRIvoqHGKVT+0XBilgoQCGEECmgJh6XQGGmeChAIYQQQsRCgaZoKEAhhBBCbFIYlCiVSgeWw7VQgEIIIYTYQqvWhEbxiIcCFEIIkQLqJEuIDgpQCCHFguQv/9R3wYnRZ2cPFKAQQgghIqEmHvFQgEIIIYTYgvqg2AUFKISQYitPQSMuiLgk35ToRChAIYQUW0rq90FEQd8je6AAhRBSbFF8QkRBTTx2QQEKIYQQIhIZBSiioQCFEFJsUQ0KEQd9keyBAhRCSLFAlxBiN9pNPBx908RCAQohpNhikgpbpFQWYi3qgyIeuwQoT548weDBgxEcHAxvb2/UqVMHZ86c0axnjGHGjBkIDw+Ht7c32rdvj9u3b9ujKIQQAoC/OYeaeIgotKYpoD4o4hE9QElKSkKLFi3g7u6OXbt24dq1a1iwYAFKlCih2Wbu3Ln47rvvsHz5cpw8eRK+vr7o1KkTsrOzxS4OIYQA4K8toUsJEQWN4rELN7F3OGfOHJQrVw6rVq3SLIuKitI8Zoxh8eLFmDZtGnr06AEAWLt2LUJDQ7F9+3YMGDBA7CIRQggvRlUoRBQUoNiD6DUof/31Fxo3box+/fqhdOnSaNCgAX766SfN+vv37yMuLg7t27fXLAsMDESzZs1w/Phx3n3m5OQgNTVV5x8hhFiCt4mn6IthAuUgdQXUxCMe0QOUe/fuYdmyZahSpQp2796NcePG4X//+x/WrFkDAIiLiwMAhIaG6jwvNDRUs07fN998g8DAQM2/cuXKiV1sQkgxxCSV6Z4ubE5LJ/qlz1EsogcoSqUSDRs2xNdff40GDRpgzJgxGD16NJYvX271PqdOnYqUlBTNv9jYWBFLTAgpDvguG3lKSUUoREwPjgB/jgeykorgxbSbeIhYRA9QwsPDUbNmTZ1lNWrUwKNHjwAAYWFhAID4+HidbeLj4zXr9Hl6eiIgIEDnHyGE2IomC3Rhq7sC59cBe2cU6ctSHxTxiB6gtGjRAjdv3tRZduvWLVSoUAGAqsNsWFgY9u3bp1mfmpqKkydPIjo6WuziEEIIAP4OsacfFMXdNXGopAdF+nLUB0U8ogcokydPxokTJ/D111/jzp07WL9+PVasWIHx48cDADiOw6RJk/Dll1/ir7/+wuXLlzFkyBBERESgZ8+eYheHEEKMuhWX5ugiEFegFZNQDYp4RB9m3KRJE2zbtg1Tp07F559/jqioKCxevBiDBg3SbPPxxx8jIyMDY8aMQXJyMlq2bImYmBh4eXmJXRxCCAHAP4rntWohRV8Q4oJomLE9iB6gAEC3bt3QrVs3o+s5jsPnn3+Ozz//3B4vTwghgsioRyMRGQUo4qG5eAghxZaSriXFQBFEoVrVcxT0iocCFEJIscDXxKOkCKUYKILP2CtQ8zANvvZ/vWKCAhRCSLHANxdP/xUncPLeSweUhgel3XdeXOGlVEmXVdHQO0kIKRaMXf/7rzhRtAUhhAhCAQohpFiQfP0ER50XnJdWHxRQ8j+xUIBCCCkWaObi4ooCP2dFAQohpFig8ITYDaM8KPZAAQohpFiQfAWK5AvorIr2faUmHvFQgEIIKRaoiaeIHfseuBnj6FIUjVjqaG0PdskkSwghUiP58MSVOsk+PA7smaZ6PCvFsWUpij4of03UPJQxqkERC9WgEEKKBclXoEi+gBZIe+roEhAXQAEKIaRY4EvURojYqJOseChAIYQUC65UQUGkS0YBimgoQCGEFAsUoJCiQV80sVCAQggpFkw18URO+Rv5CurcKJpiHA1SDYp4KEAhhBQL5q6ZOy89K5qCEJdGfVDEQwEKIYQASMnKc3QRXIcrDZm2GAUoYqEAhRBSLBTjVoeiV4zfbGriEQ8FKISQYkFp5qJJmWZdVBHX5lATj3goQCGEFAvSv2xIv4ROqYgDz+LcuCU2ClAIIcWCuRoSCg+IGGiyQPFQgEIIKRaUZiIQuvMVUTHuJFt8j1x8FKAQQooJ0xEKV4wvqqIrxv15OKpBEQ0FKISQYsHcNfPa09SiKYhRFCDZRZF3kiVioQCFEFIsmLun33gmtkjKYZwL1TpIqTaqyDvJutDn6GAUoBBCigWluU4oRDzFuImH8qCIhwIUQkixIPnLxotbwNoeQOI9R5eE2EDGSf6b5jQoQCGEFAtOcVN/7wCwdYyjS+FaHNHc5BRfNumjAIUQUiw4TabYtHhHl4DYiu+79uI28O8sIONlkRfHWbk5ugCEEFIUnCQ8oWEgLoHn27asBaDIAZ7fAgauL/oiOSGqQSGEFAvmKlA85FI5HVKEIipH1JwxnlwoihzV/49PF21ZnJhUfpGEEGJXrOCutnqYP0a/GmWwvmvd8KIuEnFVJoMip6nLczgKUAghxcK+6wkAgBtxadLOGsvRaVlUDvislUoT2WT5alcIL/olEEKKhdXHHmge812yJNOJVsrBExHkaUqGo4vgEihAIS7teVqOdC48RDp4YoCDt55btavkzFycf5RkY4G0UYDi9EwlBaTzkWAUoBCXtf38EzT56l98tuOao4tCJIbjCQKSMvOsCmZbzz+AXkuP4cDNBDGKBkY1KE6Py882vpKaeASjAIW4pDsJ6Zi08QIA3ap9Z5WTr0B8qomTHrGIsRhg7zXLc5AkZ+ZZ/Vze/WXli7If4jjJv49ydBFcAgUoxCWN/+2co4sgmoycfFSbFoNmX+/DnYR0RxfHJdyO538fH77MLOKSGErJynN0EYiNaqUfN7GWmniEogCFuKSENNepbViy/47m8e6rcQ4siev497p0s7XyNT8RF0J9UASjAIW4pKRM17kLfZbiOsGWVFQN9XN0EYxSUoBCCAAKUAhxmNjETChM9fYvQKOQxDe+TWXe5UwK1e/USda15dIQZKEoQCHEAf6+9Ayvzt2Pib+7Tl8ZZ3IhNpl3uTSaV6RQBlcisfeTKRxdAqdBAQohDrDsoKpfyT+XqU+JI2Tl8l8kpFCD4oEcRxfBxTj+MyXWoQCFEImj06v4Br9SQfR9itUy48OozxEhAAUohDiEtU0Jh28/R5v5B3DqfqLIJSpegnzcHV0EozhQIi+HyExU/SOSQQEKIU7kxL1E3H+RgTd/NJVngZgjM1LdIYX+yHIKUEQm4GYgPxeYG6X6pxApUV5yrDj7KcYoQCFE4qRw0XQ1cpmRAKWIy8FPGqUoVrK0ak5y08TZ5+LawKXN4uyrmKIAhRAHsKS/Al2uxGfs/Rcy7NveJDbmxDpSGiqtEJATyV53AYfn8y9PjgW+awCcWG6f13URFKAQInFKqkIRndzIBVQpgQBFRpPJievhEQufIGJwZey3++9MIPEeEPN/4r2WC7J7gDJ79mxwHIdJkyZplmVnZ2P8+PEIDg6Gn58f+vTpg/h46aaeJkRslpwCpXDRdDXGmniux6VatJ+0bPEzFlMnWUewz2/M6F4VuXZ5PVdj1wDl9OnT+PHHH1G3bl2d5ZMnT8aOHTuwefNmHDx4EE+fPkXv3r3tWRRCnJYUmh1cDWekBsXSvDSrjz4QoTS6XCFAeZnhxBdgEZunEjOM5bSRUBOYhNktQElPT8egQYPw008/oUSJEprlKSkp+OWXX7Bw4UK0bdsWjRo1wqpVq3Ds2DGcOHHCXsUhxGlRE4/4jNWgWCo7X/ysoDIX+LwfvHDidO4ivv8ZOUZGBEmpj46E2S1AGT9+PLp27Yr27dvrLD979izy8vJ0llevXh3ly5fH8eP8QydzcnKQmpqq848Qp2bBCYpqUMRnrA+KNNDnXeR0ghLx3n/6JG3jZo+dbtiwAefOncPp06cN1sXFxcHDwwNBQUE6y0NDQxEXx1+9+s033+Czzz6zR1EJkTyKT8QnVnyinXBPrEBSyqFTsVAkNVj0KQsheg1KbGws3nvvPfz222/w8vISZZ9Tp05FSkqK5l9sLCXAIc7NktOTSK0RRIt+E09pf08AtgUu+QpxLmwyF+iD4nzXX/sEJZyx/Uq6Bk86RA9Qzp49i4SEBDRs2BBubm5wc3PDwYMH8d1338HNzQ2hoaHIzc1FcnKyzvPi4+MRFhbGu09PT08EBATo/COEEEv0alAGAFCltJ9OE8+CfvXQsLyqn5ylN8/a15l8kWpQ5JzzV5kxJqELcIkoy7Z3pj5AjAH7vwEubXJ0SexC9AClXbt2uHz5Mi5cuKD517hxYwwaNEjz2N3dHfv27dM85+bNm3j06BGio6PFLg4hTo+aeMQRHqiq0X21SghkWjUoGbn5yMgt7MxobVONWAHKLkUTUfZDCnj6m9/GTn1Q7OJmDLCuL5AWB8SeAg7OBraOdnSp7EL0Pij+/v6oXbu2zjJfX18EBwdrlo8cORLvv/8+SpYsiYCAAEycOBHR0dF45ZVXxC4OcSF/XXyK84+SML1rTZ0LjKujUTzi0H8Xvd3lyMpTILpiMA7efK5ZHpeajTJB3hbvP18hTtNMW9kFIP4qEFpLlP05gvO1YGh9O0T8vXFG92XDG/R7f9X//3wE1Bto/X6cgF06yZqzaNEiyGQy9OnTBzk5OejUqROWLl3qiKIQJ/K/388DAHw85PioU3UHl6boUHwiDvX7qL54nvy0HV6k5aBiiJ9O8LL22ANM7VJD0D61LzNidZL15PKAZc2BWSmi7I8IoP0jK4pMvmJEcHGXgNI1bd+PhBVJgHLgwAGdv728vLBkyRIsWbKkKF6euJgl++8WqwCFalDEwQrCEPWlIcDLHQFe7gCA/24kaLbLFakmhDgRnaBEwr+3+GuFj5MeqJp3XBjNxUOIA1hyA0UBikj0alCMbmbJ2621M/qUtEmnjScr10iyNB32aeIxJteaEV/JscCy4tVPkwIUQiSOOsmKy1iaezVGAaFLiU81lm5ei42dZJUWjlq6EZdu8Wsg7rLlz3FyFKBY6NCt59h67rGji0GcnCWnM7pgikPouxhuRQdZANh7jSY85eXg76+gV2e21aBsULSxaPvsPGumSCh+5wEKUCw0ZOUpvL/pIu49L4yA/7sRjwnrzyElU/yZTQmhGhRxqCf245sd2su98FRoyQge6TRkEJvY2Acl10h3Tjn4AxGr+sgWwxsVClAscPzuS83jhLTCasMRq89g56VnmLP7hiOKRVwc9UERh7rz664rhlNqfNixmuYxvd8ic/j7af71c/IL+6nk5AnpsyKMJ/hndWZWhbaOfh+LHgUoFhj4U+Fsy3y/uWfJWUVYGuLMzPWD0EY1KOJ6wvM71U59b0nKeufL91FUpPPGCPk007MKA4kcK5pfjKW092LZFu+LFKIARUSWXHQIUVt19L7J9dQHxf7skc+EqDnB+6ndxCPi781ogELXCkEoQBERfeWIvpx8BY7ffYncfOO5NT7bcc3oOsD0+ZIxhjsJabz9Kohw2jcXOZQHxbUI6yVr6RN0GDv3G59XyYqrhdDASakAMhMt378EUYAiIgqKib5Ptl7BwJ9O4LMdV3WWW/JVMdUn4of/7qD9wkP4YPNFK0tIAN3fbmaO8D4InN4n+dfFp2IVCVm51oz0kAjtt8UJRvFop6Q3np5eTHbog6Iu9/ZxwNwolxiWTAGKlbLy8g2qgqmJRxq2nJXOMPAtBUPSfzv5yOp93EkwnjNhwd5bAIBt558gKYO/Qx6xTJZVQ0BV1NMxiOHT7c5/gZECY/1DdNlag2LZc+wyiocxIC8LuLRR9feZlVa8iLRQgGKlEavPoNfSozrLKDyRhgV7bjq6CGZZcoLKMdI8FJei2759+M4LW4pUrGl/HKaa4wyeZ8cffdrd0/bbuZ3pvi3Sr0HR7oPC7DAXj039yPKygKXNgZ2TzbyIEji80PrXkSAKUGxw6TFN5iVFfDMdi9HRNCUrD7P+uorzj5Js3pc+a2bCfZGumyHzf7+ftzIBFOnRoIzm8dIDdx1YkkLv5q12dBFcg6AKlMKNrBlmbqoG5c8LT9Dkq30GzxDsxt9AwlUgy1y/EgbEX9H8lZot3nBpR6EARUTpFrRdE/uR8dzWKpQM+Qol0rKtT6Y3e9cNrD72AL2WHrOleLz233xu8XPkPIHYUapFsYp60kApCWcJ5jeSKJ1vphOMQtOuNWFKcWtQ3ttwweBmwqKaN6HvH1MCXOEl/fqzVAteRJooQBHRMa1EbsRxHiVmGiy7nZCOrt8dQZ1ZewxOFkLdNdEXxFL6nSstaVZQ4wtQ+IIzYrmENGH5K+z5boc5cYBi1PWdwB8jgJw0R5dEl1YQYE1tq6nvQQ3uIfZ5fKD7cpZ8c2TCLtNKpdIpgkFLUIBCioV5u2/iZrzqpHjoluW1FQAsvhpZcqKzJq5w4wlQKD4RR9Ov9iEnn5rLxKH1O9g4CLiyBTi8wDGvb2wL7RoUiFuD8oP7d6gke6azzKIBFZywy3RyZi6ytLLgusKpgAIUEfXSascm0pInQm4LS3/wlqQmMRXL+HrIeZfHJpnOiFocHb3zAq3n7deZlkJfu+qlBe1LyNxaFBAaYe59SZdW7ZD2zQSzIqeQqT4o/hxPhnGBQYdqW/7fvz6mVOBuvPM362ijAEVE3kYuJMTxSvp6aB5b098DEHYxUigZ/rzwBLGJmaJlJDW2m4UFQ4yFbFtcDPr5JB68zNSZlkJf9XD/IixRcaX1Y3F4HhQTP9ysJOCHpvA/PrdweytG8ZhqWpXx1Mgw7QDl7n7TOxcYzDAwnTDpWVKGoOdJGQUoNjrzwDUy9rk67aRXO6xMpqXdb+TYXf7OqJvOxOK9DRfw6tz9JkcDKPTWmdrWWF6OJzw1KOtOPDS6H6LyZuNyvMvb19CtWdH/jIhzMpmj5OSPwIub8Io9rFlkTQ1KlVA/o+vcYTh4gtMOOn7taXrnQmtblAy5Ws2SPZR7hT1PwihAsVHf5cc1j+l8Jl17rsXr/C20E6Qxc2P4c61oNy2YqkHRD0hMfXWMtdrwdfY991D8IdBS9s/lZzh29wUUSoYrT0wP+/dwU53u3OT8p73aZQJ1/u4jYLSWxckZkx4Aj89Y9hypSIsH9n0OJFkWBJ9/EG9+I7sy8etSGgb/jFne98jNxJXUDTz7s6CJhwn8jjEokZppYgCAyKOTigIFKMSlVSnNf2fz8KXhSB9ztM8Txmo8tLcxdQeuP3eOqQ61lY0cA58gH+kNlxVTZm4+3t90AXuvxSM2MRPv/nYOb/10El/9fR3dvj9i8rnq99hYwNezvm4fsqdaifDuJKThcZLhd8biER/f1gN+bge8lEauFYv8MVzVuXV1N4uelntug/mNHp8Bnhs2WYrBZOr6PJ7PlCdoESqb8zJYZmuAcjtBWFNNamYu/2sBqj4/8ysDu6YIfl0poABFVFSFUlSEdnr183LjXb7rcpzFr6kTfOgFGFvOPsb4384hJ6+wXKYm8NMPXkxPCCi8jF3rRgjf2AmtOHQPW889wei1Z/BMK4BYaWZGaKDwfdQf4q3mbuQ2OCkjF+0XHkLLOYZ9BayuNdWaJyULqovaNWUFK3dWRB4WZM5OETJtQ+F77Kbk6SSq/RmkPlMFbUua2FQ8q6Q+MVxmS4d6meH5xpPjyY9lSSfZ5zcEbZaT/AxxrCT/yhNLgcyXwMllwl9XAihAERE18RSdhl/sFTTKgm8oLiDsgqZP+8KmX+v6weaL+PvyM8RcLQx8DpjojKt/DmQmgltLvlbf7bttwdbOJz61sArb0oyf6u2N1ZjLjax4rNXXR7/GxOafvCIP3lAFWv7uUq+Ct27IUqObi4AcEzmEkiz/LVrCZB8UheE5hCmtSLhZ8L0Qmt+ECRyZAwBVL80TtJ17ykP0czukuzA7Rad8zoYCFBHxpVgn4tC/MKRl52PHJfOdXYN8PMxuI5T29evKE/PD+SZtvGB0nWETj/H9iJGm31UIaWYzRr21sQDFWD4sD62alTyFWJ9FwX5yC6vvfZnUR13YkNfnxk7dvz18tbe2ukSCylIEfVBM3WDw4QQmXwP0RvyYkA+eoMcO8woVJQpQRETxif3wXYsETaMueknEoX9xNTWD7t3nUr9wFR3tz9PSPn/mmniM1aC4ywuXi5FPR4fWxcfSGXGdiv4P2Cug8LGdk8mYfF9fGHZ2t6YPivoIst0CTG6neQ397+CDo8APTYD7h3i2FXaZzpUZ9n/Bj62AWOeddJICFBFRmnH7sWYCLwBINTP3jmXZXsX7fPX7oHy67Qrvdhk0v5NRlnwntD9nYzcSfEnupmy5hN1XC0ehCJmSQMh3StPh1kXPGYZNHXrviZun1h8ODFAS7xkuMxagnF8H7J1p8m7pUvDrgspkUCuyugvw4hawprvhxgJrUBR85U5+BKyxrFOzlFCAIiIKUOyH7xTz8IX5moUT94znqcnJV+D1bw/jw80XdZYfvPUcf17g6TwnIlMdaLXx1ayMfa2iyedYMzOys7C2iUf77bYk0NxwOhZzYgo7Kebqvbe81yoBxXqeZjgc1KL5WSTO/JFobcH3eeRmAFtGq+busZmFNzfGApQ/xwNHFwOP+JIAql5DKRPWpGxJHxShw4wzjd2M5duWUsGRKEAREQUo9sN30v/5iPnOddoZZPUdu/MSN+LS8MfZx0jPyceXO6/h/KMkDF15Cu9tuID7egHQo5e2NbVoJ4sTmgSML5dKj3qmp1TIyCkec8gIeQszcvLRe+lRzN1dGGQYq0Hxcjd/0RBSgyIocFJvo7WtSzfxmMTzgRz9Fri8STV3j/h7N0lprolH3fFUh4WfnQXXCiUTtu2S/a7XQZ4CFBEZyf9ERGBtE48p2ueI+btv4ucj99FLKznXQ72A5IEVuVO0/XKksDpZaP+J304aDuk0d27LyHXdZqF1JwrfDyHfiS3nHuPco2T8eLDwvTfWB8XLXY4h0aaH+gp5TSGVY4XNQK4ZlBh8RxkD4q9q/jx4mz8Ts0baM9PrLVCOPQPW9xc+ksVcgML3A9T0wBb2Esa+g3xyFMK2lYs8yaEU0CVVRFSD4ly0+xxcfWp4V5SdJ+4P/kV6ruax0Hl6+LKjmvuaiTUHkNQJOU7tWis1U036g18xHaDk64++4gkwhAQxmtoSrW29BdTgOAuDtyD+CrCsuebPE/eScLtgdnH+L7TI59JbMUCmsGlJlDZlXBV6SRVwfCmPgZu7oBT4XvDN+ePs+LNYFXN5CiXcragOEbMTJdFlbQ2KsTwoAHDoVmGeEu2kX/ZiTf+Jm3FpBsvyzQx1LS4BytNkvgRguvjeClO/0qqhpicSVCoZEtKyIec4BPt58m7zybbLeKNeBFpXMzVrsmENiiuPAsy7cwDaOY4byG5r9a/Sm1iQ4+zUeVhos6qZCz1vhGvZb67Sy//Mb7SoFgAgQOBb0VLG39HemVENip5Lj5NRY3oMluy/Y/FzLR0LT4SztoXHVIDy0+HCPiyPeSbeAxhux6cV3unZSLtaV2iA8kTrIty/cTn8879Xkc4zsqd3g8J+KcVlkrtZO66Z3YbvfbalpjM9Jx9Nv9qHRl/+azQQ3HruCYatMjO0k6cPiii1BrkZkkjKpf8WZ+jVZHWUn4VHFk8iQ3uW/eLvgjYz2weF53NixlfxCs7kGT1kozFuf4u+T0ejAEXPu7+dQ76SYd5u/sngTJHAecFlWfPWlivpDbnc+pN+Tr4SHRYdQodFh5BtIk+JUNqVcuqLW5+GZQEAraqGmH3+pA5VUDMigLcGpXu9CJQomIdH6Aih4oBvyK8tN+fao2+y8hTW/+atTKCV+PIFrvM0R6pW3ge+jgA22N6x1FZCRql4ZBZkXdb5QOz43T0hLM27VU086izFlj+zaGQYz2otZRSg6OG/kzZ0bnoHg2WU8dN+rGnimda1JtwsyNioL1Prrs9cPhUhtO/c1QFKsJ9qlJGHgEAqPNBbtS3PnDFyGafpU1NcalCE4IvVbKlB0X7u3mum53MyfT7gq0Ex4/5hlPy+EmqsKI9b93juwM+uUv1/0/F30kq9SwvfEGqZvKCHgfbnoQncHHepNxugmCqaRJv58xMfFP7hROcHClCs5MZzQaEbV/vIzlPg7MMko+vTc/Ixb/cNXH+WipfpOagUokqjHeDlzpt8SyjtzKJjfz1r9X7UtPsoqb8r6iaozFwFMnPzMX/3TZ2Ose4837MmkSUMlrnJOc3F05X7oJT25+/3YYw9Rn+pTd540WQQYvJzYAYPkFiunc4mOUyvi+C+zzUPQzb35NmpdC6Ohm8LX4DCl5pdne7XDscieGi/uRoUkxGK4OLYUzbTndX8WbrWMfHMPyRV1EnWSu48d+b2PBkWZ32WHcPVp8bnvpmz6wZ+PfEQS/brTmHPcab7oJil9dTzj5INVqdk5iHQx91guTG3CvqyMMY0HQR9PVU/wWN3X6LmjN0AgB/238GD2V0B8M/9wtcZ210u0wRjNg1CkLhaEQFIMDEJo77F/xrmhrDl2qf/GzcVgygYM3GCNaxByQysorOFJ5ePjJx8zXdEO5gpkfXQcJcSunvXvzHgTTammfm3iJp4BO7bbKp7nmNRj8qSyiegU2NVIgr5nFY+qPwswE28OcrsiWpQrMQ7FJ7iE7swFZwAwGWeobiA6qLdsIJhbYNgZj7PpynCmgPV/ruRAEBVW6K+u/b3EucewU2mVYPiwl9ES5pnjNVgWJKDQp/+MGNTNyWmPwbDUTx8idoyMrVmATb7uUrl8gjwtEIa4AoClFjtZnW7fneFvT/mayB5Osmq400JfQYaHAeF9qVe4Tx5kihAsRLfnTn1QXEMY++6h1yGT7rUsGG/pj9PvuYXc2KuxKHWzN2av309xAlQ/L3cCvuguHATz76CIE8IYx2bzdWqlQnyNrpOP0ApV9LH6Lamu6Coqrl0+jvwVH3JlYUXk3wrJrFzFCEjGtUXzTSdUWkFz0s1P1O5NaUSwuwoHt4gWVo1KDoS7yE9SyuNghPNcEwBihZLTux8fRvWnuCpdiU2yTSTFVWhZLgYm8y7LlehhJ+n9QGAuSlt5FZ0wH1nnW5fFm8PcZJzafe3oaZGFf1gAlDlGpGZCVB+H/2K0XXvb7yg87epfEkmPwcGQKlA1pNLmkUZ2Ybz8ySkFmYvjjOX90VCTTyGDMuWW9B86ab1HjL1xfPxGfGLIDA7rflRPMbfZ6Hz5tibfk1O/czjheuUVIPilCyZSp3jOIM7MbouiE/dL8OYNcceGF1n67li3/V4k+vFmJTPWIBiaW1cgLe7JtGXK9egWILvfRAyqqt8sPFaEYNMsiY+J1MBCgclsHMSfDf20yw79NIwSdzuy4U1CTlmh7oX4cUxJ83kCU9/FV/TR07BvEYyrc8kL7/gGH3ND7u3FyXf71q7r1AS3+gtadWgmDoD5OZTgOKU9H9U/16LR99lx/D3Jf7Im28kj9S5WjPUpjOxRtfJbYxQzDUnHLljZj4RAYw18ey+Go9fBEyGqObpJtPczZvLNFtcPOFJGaA/G7E9mRzEwwCcW6uzbB9rarCdv2dhAMuZS2Vuy/ddkQckWpA87JuywG99BW+ezjNMXx1wadeg5CsKApTK7Qy2LypKxhMIajWLeO0cx7Ne9R/HcUDkq3YqmXCm+sJogkAnQAGKFv1201Frz+DMwySMX3+Od3v9uVpK+Um7Z3RuvhKvf3sYk/WqqZ3ZDZ5U8Gr2rm0tW0J1p21L0OdjpAZl2vbL+GJnYabUoSYmsRsaXQEcx2lm4xUjqZw9/XbyIUatOWNxOfky6JrS/YcjFm1vDVOffOMv96q24fl+ML1+ADnMnTf8qBNRWKsi+tdZu1zr3wS+awBc+1P48+/8C9zlT9nO6R2ze55hR3f1hVK7qZRv1FpRY3yRpdbxyPgCGE2EAklUpZsKUBRUg+KcTH2vEjNyja8s8CI9F7GJts14a09H77zAjbg0bDv/xNFFEeTkvZc2Pd/YaI3xbSrZtF+1c49UuVnMnY+iSvkaXedlZII47YkFAaBZxWDe7WZ1r4nPetQGUDjZXJbEA5RPt13Bv9fjsfG08dovPpKs/TNRpDwFw7h1Z9Hkq32G5wX94crgEOhtOGT98O3CZkazNSimQpjrO4HTvxT+fex7YH4V4EXBlB7qQOPkj2ZeQ8+vvXgX69/s8b1N6iY4eX5hB07bJuoTB38nWaHfPQ5QmL9WOJJ+cCxlFKBoMfUVfJFu2IGNT8wV09klHcnZOk/2X3HCLvvtWDNMlP0kFgQRpob1+nrI8deEFkbXC00k17wSf4DiqRXgeLmrfs5SD1DULK0RkfJknO2ql+b9LHddicOL9Bws2KM7dYb+RUIJDoOaGdaS7ThdmMeFbxiyDlPvz8ZBwN/vAy8K9rdnmir9+e6p+jsx/RpW40tsWZBN+chMzTKmDlAceBHlDZLMlUed6p7jgGZjbS/EkUW278MIs3leJIQCFIG0f16vVilldLuv/rlu/8JYycniE7uxZqZqPhsL+r+YCvzkMg7+XsaTuUWa6JCpLUBvH5VL+wEA2lYvnDFX3eFW3XSSmJGLrece4+7zdPzw321BtYBFyZYsv/ZWr2ygoO2O3lX1Q7r3IgO+JkZkMUCnOcQg4RtkaFfdcPbjHrJjmsfm3i1Bv+8MM/2mxAgC83MML+g8+1UHI55xhSPbpDDhKtMOUM6sAg7OM/vm6qytI7xvjlH/zrLp6aaaeJgEaqmEokyyWoRWIXeuLc4dOLEvY0nQPNzEuzAmZ+YabaYBgNRs07UEHMdhy7jm6LPsmNFt+IbG/vO/V5GVq9DJZKsuR1bBHEKDfj6J688K2/7PPkzCquGGHTEdxdJOzEVZA7h2ZDOcfZiIplHBqD3T+EiyPy+oRtncf5GB/o3LaYJWXtrNIUy/CYRTfcbjjgN39gJ7ZwAAOM50Ijdt1+PSUdPkFqpX0iVykJiZCMyvirpK3U6x8fIwlFHoNi3zdUZVXzwzc/MhLHQXn06q+52TVP9XMZx7TYemBsX21x/76xlY2NBmWBwT6+JTM1HSxv0XFapB0SK0w6Wt58mEtGyHDAV1/L2JrnyFEv9ei0dSwZ39qfuJePPH4zoXVT6dawkLECON9P0QqwYFABbuvWXzhdPc3TrfV8XDTWaQZl/dB2XruSfotfSowfu434IU8UXB0pN5Udb6B3q7o231UIvy6IxuVdHoujS9QFX/LjaAK+ijEloTaPGeZvkkt61ISFKdl8wFKC+1a8iUSv4T1d39Jvdhs+t/AUrDETt8H7Usz7C/nrrp62JsktglE4y3hiHH9DlJgys4t7zxg9Wv3+nWTPMbaWGtPjZYZirj8iUHvreWogBFS0qmsEmUbOmsd/LeSzT9ah/GrbN98jlLObqTYW6+7g//lyP3MWrtGfT7UZVE6M0fj+PU/USMWnMGlx8bmVIewNx+dc2+lqmmkyBv8UZbPU/Lwcn7iZq/D33UBh91qmbRPtxECpjUAcrN+DTeuYP4JGbkOixviqWzCkuh+t8UTxP53f/TG7JuybGc374YgPkAReftXNIE2PCW4UYP9EY26SftsqYKIOlB4WMj5xgZT9nluYY3hOpzlFLhuH4Smv5BpibVO7Gs8Fjzc1An9SAArUCs4dtAo+FWvX5vuYWjz9wNz3X+yDC+PU8fFKWS4Zcj93H+kbSCFwpQtPBlnuTz92VhGQm1qX94Kw6pcg3suWY6CZirWX7wLmrNjMHpB4UX8+0F1eN3EtKx6mhhzo8nyVkmh4jyTdSoT/vi169RWc3j6mH+OjUPHWqGCjsAI+QyDsNXndb8HRboZfM+rWXpHDzXnqai4Rd7MWTlSTuVyDRLu6AI+XnWCA+wrjAiMJX2Xr/+kjHhBx+ZpsqqalH+ipd3gJv/GC6X6TVHxl3S+dOqYb6btS/ExgIUw1oJLt8wT406OHBkKFo2qeD3HKv1u9D/bcVMAa5uUz3eMx1uUAd6Wp9r9W52K6M2rukoy57AUxW56+wtDN7bGM9+elOkUomDAhQtpu8kC794J+4lmtjOsKbik22X8dq8A8jIybdoLhEAuPo0BX+cfSxK7Ycjf/Szd91AnoLhk62XNctytE64n+24xvc0XkLSw2vfCM7tW1jjou6YeX56B/w5vgX+r3N1wa+r1r5GYWfGXXqjtmQcUKWgA2tRe8yTmExbBb1apalbVReno3dsG85tLUs7yQppStv13quY1tX6+ZdstXtSK97la8vu0PlbYUHfj2qJB5B8Za+mhqxwpz107oblQn7hZmpI7r+wPE0CS9aa4sNoDYrhRTE3T3VRzw2qXPj0gs3Mjliyo6qJ/wF52ebbFJ8XjMw6VdhjROfdLapkc56GGYhNKeFteNkveWEZPLl8dJGfQmaiPeZBso7oAco333yDJk2awN/fH6VLl0bPnj1x86buELvs7GyMHz8ewcHB8PPzQ58+fRAf7/gahXwTvZstqfmcHXND5+/1Jx/hUWIm/rpo+Qff9bsj+HDzRRyQWP8BU2ITM7H84F2k8WSP1H4fLZlaQF/TSNPdvLRrULSHp6qXl/D1QL1yQZrRMJb4tGthV0T9oFbGceA4DqNfjbJ4v7bSb0LTF6SXZ+OiiWa0omBuThx9QmP0ZIFNtUKF+HsK3rZamD/a1zCsQWv1YoNNZTiycT7knN4bcO8AcPkPID8XeHYRMsbTIfviRiBZq+MuJ9eblJDTeWMrZZ4H0i27icrPNtGcoHkVww/vyClVTcXxvMK8RJqmLwc3R7PEe3pNIQLLo32Cc+Cw+HSvcKPrSngb9qvyzS0c3ZUY/9guZbKG6AHKwYMHMX78eJw4cQJ79+5FXl4eOnbsiIyMwi/x5MmTsWPHDmzevBkHDx7E06dP0bt3b7GLYjFTKcK1v2qhAaZPWKcL+iQolUynSUPfBSOT3PE5dNv2AEX7N2/P/ihv/HAEs3fdwMd/XDJYdys+HWPW2j4RmJeZWhRj/RssvSjyMTUbrnr/YryOpZ6lmK5BsbQJyN4sHcVj7jurrpFZe/yBtUXi1bWO8ZM9n5+HNjY55BgAOP2mFjMYwBvws+3jgA0DgR9bodmT1YZP3DYG+L5h4fZyD92aAY4Dkh9p/pRDCSyqZVHZOKX54es1cy8bLJvuvg4AcDWl8HyqzkHiyBoUoKA2UmuUUS5P81pKBs/vTSK5em6Hdze6Lp/nWPK1BvTKJDSZoOgBSkxMDIYNG4ZatWqhXr16WL16NR49eoSzZ1WdQlNSUvDLL79g4cKFaNu2LRo1aoRVq1bh2LFjOHHCPom5hDLVxHNTa4TPm43L6azT73Nw7lEyHidlYt3Jh+i3vHAWSf2v7k8F/VFuxqWh8+JD2H3VeJK3VUcfmCm9EIXHZ89rVVLBHeyuK3FY/O8tg/V7rsXbHCC9166yyfXGAgQvEx0ZAeDUp+2Mpp8HgG9610FogJfZ8oX4Cb/rBoCxJkaACNWtboTJ9aY6pZ59mCg4GaFYLA3izPVBUe9O7HTpU16vjrGvWfb5ZOSa7i8is3Am7O7yE4iSGdYyc0yhSjlvilZm0/tBzXQCFIWSGV5ULcyE6qbTfGP5e68djHCaPigm9pPxEviuIXBgjsWvJRQD0zlJPnpp2PQVeOZbg2XSCE+AYC/j79+S3RcwbNUpnUSJubLC8xUnofxEdu+DkpKiqkYuWVJVJX/27Fnk5eWhffv2mm2qV6+O8uXL4/jx47z7yMnJQWpqqs4/ewjgSTWt9sm2wjuASe2rAgAqhqiGsXavZ3hh+GjzJWw4ZTqV98uMHPx54Qk6LT6EG3FpGPurfUf2aMcERZVTYvG/t3mXK5nxVPRCqOfBMUb/Nza7dx2UK+mNr3vXMfm80v5eOPVpe6PrPeQyeJgJcgBg8CsV0KVOGBb0qwfAfEK2/+tcHXsn8/dfEGr0q6YvoqYysfZZdhyNvzRzoROBdmBqrgbl9INExKdqpUE3851VH9+EtqaDV0t5ucsx9fUaWD+6mWj7rHtnuWj7ssSJ+8lgWnfISkDV7GNK0kMgz3TtnIYV5xVO58aJAbmZkJnq/3HsWyDxLnDga4tfSyjfu7t0mngEJ7qXwLX9v+CBKBdofKTiOo9vsPphB3y/tWDIuSIPr8Tb1gRpL3YNUJRKJSZNmoQWLVqgdm3VfCFxcXHw8PBAUFCQzrahoaGIi+OvQfjmm28QGBio+VeuXDne7WxlKueBulbAx0OuqUr+c3wLbBnXHN3rhiNALylYQlo2rpnJ53HiXiLe23DBtkJbyUEjSzUUSmZTHxRfM/kp9M+TA5qWx+GP26JSiPk+J6a+B0JPQF7uciwd1Ah9CkYQvVG/jME2/lqvI5NxqBLqj5o2jEIx13n4Ymwyunx7WOeiry9focSGU49w73m61eUwRbuW0lQn2VP3E9Fv+XE0+3qfZpn6mcaa2NSL7ZVIkW+uHGv55FjWz0MsWbn5eqOBOMORPdqeXQK+rQsssV+CP50alMyXwNfhiE7eafwJVqZqT2BBgrf1v/MnmFYTjzxP6O/B8eNOrmcEgEsz39+x4+3PVA8e6bZcOHKItz67vpvjx4/HlStXsGGDbdHZ1KlTkZKSovkXG2vZJGNC5QlIAax94fP3ckejCiXAcRyWD26ku53YhROBdpmKMisnX3OOkjE8SzF+odR3broqk+PApqrg1FwCLTGPbqLWHbn6omppLegYvSacxf3rY8/7hjUmpqZREMO1Z6mYt/um0fWbzjzGlK2X0XbBQbu8vvZQflNNPIduGfa5UvfBMBbYqJuwKpqYnNGWO9yKpRwzOktMMg7IV2j1MeA40zUo1wtGH2n1UxEV003K7v3AfrV4pblkINd8h14AyFcCd+MLm/Ur/veOoOdJoQZlcHT5wiHQJoSygt+YXqEVEpqrx24ByoQJE7Bz507s378fZcsW5qEICwtDbm4ukpOTdbaPj49HWBj/nY+npycCAgJ0/tmDupNs1VDjJyJjE7E1r1wKr2vfufFcIW1p4x/QxPZaI91OsjbvTrDjPLMSW5IcrGudcJT09cD9b7rgm97mk7QBtncCfq1qCADgzcZl8UHHahjRIgp1ywaiU0EW22NTDIcQqptz+Ph5uqFTrcK+Sj0blEF4oLfBdqPMNNOIIctE/4gt5+zbgz9Xq9Zsz9U4zbxB+vRr11Iy89B58WEAJjpAFyw31ZT1bmvrZ7L29pCjephlQzqlxkOmm0+FQWb6qiqzbDaUnDwLO1imxekMQeayTadwsNnlPwRt9jwjDxk5VsxdJYEIJdDE3F/a1DVXaY90BzM4KnEjH9EDFMYYJkyYgG3btuG///5DVJTucMtGjRrB3d0d+/YVVt3evHkTjx49QnR0tNjFsUh+wUnR2qpc7RPnvReGkfr8PYYdRvUxxnhP2kL6PVjCWCe0E/de4v1NFzTp58Xw1k+GicAG/yI8OdjC/qoLv6kLT8vKpTCqZeF3zdS0BUL8PLQx/vvgNcztq3rtGd1r4q8JLTXz3YQFeqG8XmKuR4mmc0iMaKEqn6n+KL6elo3usMa/1+Px8CX/naS5ocq2WnHwnubxzkvPMN9IbU6OXjm0R8MZq3hxkxv/frTSBJy2BfrBfsKyEK94u5H5jRygUoivThV+mrmfuYWdea88sWzoelpOnk4NStDFny16vsUEjlBRMA5MIZ3RLGb5ak00yZegj0/BTZzbad3+UEpXrkEZP3481q1bh/Xr18Pf3x9xcXGIi4tDVpaqk1VgYCBGjhyJ999/H/v378fZs2cxfPhwREdH45VXXhG7OBZRVz9bO8uqGMHzsFWnUWNGjEFtixhNMtpBibEgecCKE9h67gkafLHX5tczRWgqdgDwdOO/aP9Pq+klxN8TH1uRdM0Yd7kMFc30V9kxsaXO3+aCyGYVg7HrvVex83+vGt3G2LEK1aO+6ZE8gOri/9q8A7zr7J1O/of9d3T+3n7hiZEtCymVuqXSr0FR99tZ3L8+7/P/17YyVg9rgsuzOqJCsPHmHyGEJrXrKHC+qCLHlMjPLxyunJGvldqdl2UnNUtPgalZ+bxJ3Ey/iN6rWHBuVIJD7O2LZmf0VUJm1eRPpm6iEF7f4v0JNmhT4eMHR813fEZhLbOC6Z63lDb0DRSb6AHKsmXLkJKSgtatWyM8PFzzb+PGjZptFi1ahG7duqFPnz5o1aoVwsLCsHXrVrGLYjF1ojZrJ5OzdG4RPgdvPQdjwE69pG5i17oVZR8UoX4Z2tii7d/vWDjnTUlfD6sDS2vp17SNbBllZMtCNcIDTPaf4TuGUgLv2gFgTp+6WDuiKS7MMDP7qhHaXwtjVb1KJcP07VewVYTmIA8Bv7WT9xN1m+z03qK//9cS56Z3QOtqpcGnpK8HZDIO/gKrvq0xNLqCwbKve5keMeYQjEGRV9j3SwEZnqfxND2r59fhLDsXeuZZNpdLbn4+PEzUfPHT2j43A/ihCbDzfYOtUmEYjGb8Mw3lfmuFE2ummn0Vc0EMf8lMHEsZO9aqhWk1fbt5Ae2FTDjI8N2+23iaqluNpnTlPCiMMd5/w4YN02zj5eWFJUuWIDExERkZGdi6davR/idFSZ0/wVQiLlPEvD5yHKdzUl5/UngntUO3nuM+TxOTTh8Unt+eLaNqxNBYLzusj4fcbKdRdTNLlzphVr//XetalojLGC/9VOQiea9gWLvQMrSqGmL1xThRq2kvM5f/RLXnWjx+PfEQ72+6aNVraBOSPC5X73upPzMwx3Eo6asbxDWvFKx53LOB4QgqsfEdx1vNylu/w5LW95UxhTEl/I4UDs8tx54i4DhPPpFvC/pTWRqgZFs2bQKnVNhW83xlC/DyNnDmF769GyzxZ6rzYvRD08O8GWQ6o3gE03/JLvO1XtyO1zjtz6lCNO8EgnxO7duCqjLdWkylK/dBcWbqTrJuchnWj26GLnUs+0KZrN6zgv457/hd8z/+84+SMGTlKbSZf8Bwf1qPt543vPs11h+gqMg4YFjzSACqvCUXZnTE2hGmhzfGTHoV+z54DY0qlLT6/Vf3DTGXIbioqJtp2lUvje8GNsBbTS2/0MllHI5NaYtDH7VBZwuaG7RHVmXk8J+gU7LE659krJZG+6NUKpnFk2tq7zfIR7zZqzeNtayfnJAaIl7NJ1r3PDPSlR7wu7lF87cblPC69KvR7ZnAAEX9fufLzScx1MZxDBZ1u1LkAce+K/zbxprgy8pI3uW+nm7ghCSs2zpG50+DM1CjYabWikf7B/PKu4KapzgwrPP4xmC50oqaI3uhAEWLv5cbqob6oUyQN5pXKoWlgyyrkjvJM1rFWnkKpcFd2V0BuSkum+ikdltr2NxnO67hq7+v4Z+CmZlTMvPw46F7xp4qWEqW9fOgeLvLMeuNWrj/TRcMaFoeHm4ys0GHj4ebTm6TMAFZXvU1qlACeye3wr4PWlv8XHuY27cu1o9uhmWDG+GNehFWN11FBHmjfLAPlg1uaH5jHuk5+bj+LNWg46ybVsfJS4+Trdq3mpAZxNNz8vHHWcuak+xVG9g0qiQezO6KQx+10VluLC/P8rete+8RUs38NlbYd8uyJpjrcQLzf3yuqv3MdrNshOX1JykIt+Q3e3mzRfs3x8Odv6YxIvM6GlyYYX4HlzbqLdD7rcrdgQotVI/r9gPaz7K4jCaViDRc5uErKEApw/Ffr5grd5J1Zt3rRWDP5Ncw643CuSgsaUd+akFeD3PWnXiITL07WHetttr41GyLhoNl5ubj+/90Oyj+dPg+3v3tHADg4y22V9cfvPUc9T7bY/HzTkxth1OftoNbwd2mLTVR1s43UyXU32xuFT5BPqoTnJj9Xzzd5GheqZRoI7esfT87Lz6E1789jG7fH9ZZrj1aZviq0zrrdlx8itbz9uPaU2HZno3Nf6Xdlv/7KctzcAgJfGzh5a772fi48393ypXwASegE+j9qIG6Cyo0t7pspkxwM58fQ1t8krDPUQ4lkHAd9e8ssWj/Gw6cxb3nFoy4yxIeYMkEdPgW/QLI91sbuhOYEqsKJlpOFvf1ArSaL9XNOqVr2BTgUg2KExEj/4g1HrzMRL3PdS/28oI71x0Xn6LZ1/swas1pg+dpX59TMvM0WUO/2HnN5OvttbAKnc/Qlaesel5YoBdK+1te88G7LytqUGyxdFBDVCzliyVvWXmnLGHqi/yteN27aO1g7KXecPSJv5/Hg5eZ6PKdblBj/DXMnwwbVyhhsKxjTcMZg7XVKRMo6PWtVVrve+bpzn8qTc3OQ3/5AbP7O6SwbII+a5XlXpjfSEubx8uEbxwzxcLSAIPytpgPJLROanl6E92ZeqYfzCdlEzuM5b0XkMkAL62apUlXgH6rxXlB7dqOj+4C//cQ8PQHKrUFZqUA9QdbvEvTo7qKFgUoZth7VlpLUpurskAqMfH38wCA/TdNz3Bc7/M9aPb1PqRk5uF3M/MCWTNyKTtPgfHrz2Ha9svI4Zkh0xG+HVAfzSsFY/0o8eZNMaV5pVL478PWdkuvLpY5fcQbUeJmYW4MU4T0QSlb0rDDn3ryPr55sADg487VMa51JeyeZNv8RqZoj9wx1tekaqg/GnB3eNdpC5TxjKTxcLKkcPcOWPyUhrLb0A4THih5Ak+tAEV/QtWb2k1QVo26ET1EMb9JUDmguvHZhi2i3ZHXwwfwDtJdHy4ssaU2qkFxMmKN8uDzz3uv4sOOwkZp5CsYMvWSuJ17lKRJMAfwZ1C9+8J0OzJjjLeJwliWT7V1Jx7i70vPsO7EI0zZYjiduiNUDPHD+tGvoHll+6aMdzb9m5TH4Y/bmN9QAP1Rbrb0+jc287D2K/Dtv1GFkrgwowO+G1Cf9/mB3u74v87VUc2OmV+1hzU3rxzMu42/lzv6ux0wu6/uvjw1nF0XWFs0SUvyLGyWCObS8Jbbfs3fFxjf6KXCz//SY90mnrScwj5vaTcPWFaQ40tRRWE+eLSE4NZUWwdUVOuq+v+Vd828TsElXuYGhNQQtOvsXOv7EYqNAhQBKmnN7SFmhshqoaqTZy2B1dF3n6cbdFrvvfQY5poZfXPBTFK0PAXjjftNpUQHgASt/AnbzptPuEUcq1xJH/wowvdXrpe3wlh/jwQTkxJqO/vQdL+CNccf8i4P8vEQfeScJV6rGoKONUMxoEk5VA+zbfoNeXmeGr9SVWzap1T5hxmfziGPGfbl0dx0ZbzEJ27rddbJtCY6vBdn4SCF3Xq5ULottuz5PGSmJl7U2dDGlAT9fwX+dwGo3VvY9tVeB3r/KGjTnw7dtb5cIrO8V2AxpN3MYypDpIdchlyFEoHe7ujXqCyUDAgL9MTX/9ww2LZH/QjMK0ijLvQU++Ohe7wzJK84dA/5CoYZ3WvyPu/IHdPtzkfvvEAGTzBibvJEoRcgIh2drMxwyhjDzkvPEOLvaVCDkq9UwoPnXicxMxfgADnHIdjP+BDu7eefoJFePxPtuOO6mVnBHUUm47BiiPnkgsqyTSF7bKZ/VpNRhsvKuF6/JgBwczOeoycBQQbLmHpCwRNLDdZpB6i2zL+VWrUPAiq1tfr5mjJYkjfGPxxIe2bFqxTMQF3SfGJITQ0KY4Cb4dxffKK4OLy77gxK5DzFl8O7gROxSddSVIMigHoeD3PdUf4YF4221Utj8zvRmNatJmZ0r4n+TfhzWPh4uGlGabSoXApVSgubKfXwbf5gY+XR+3iWksXbomouF0PMlTje5fEpOUjLLuxoq8/cqKVyJYX9IIj03U5Ix8Tfz2PAihN4+xfdi626mUa/H5JCydD0q31o9OW/Os2Q+vjm/zFVM7JymGUZhx1N9qphllMdM5KM31E3Gyf4dY5V/8SCUjkQJ8dhRW3eVQE8SVGy1AkDeTpv6lw8bQhQ5CwPKGGYDdji/VhyMR93DHjLimHTNboJ31b9O2JMcK3NdPd1qHh9Ob6KfRtxfwnJSGs/FKAI0LB8Cfw1oQVOf9re5HZ1ywZh5bAmqBpa2O6tnQ69pVa/iByt/h3ucpnBvC7WeJmeyzts01z+lPJGJq/r/sMRNPh8L5p9vY83HXaOmT4qW95pjr2T7ddJkVinbXX+lPCmfPTHJaPr8hVKHL3zAtWmxegsT80qzPianpNv9A43Ic2ymri21U2P4JEcvlwVaqP+Mz0hX6sPdf/u9DUwmH9akKblxe1vkxYnbv8MDU4GH45/Znc/ngCl+xfrsO96PG+/DU5rzhlbpu/IqixOp1XOkhoUn5JAZAvLX6TNp8K3bfA28MlToN8qi17iQ3dV4BR+4TszW9oXBSgC1S0bZLKa2pSbX3bGzoktsW5UM8107fqd9zxFyHnR7fsjvInSbieYDlDmmejDou5fcOp+4WyyR26/QJv5B/A4Kcvo8/w93VA6wAtVQg1PmtZOJUDE8d3ABpjXty52TGiJnwQ0UQDAxdhko+vylQyTN14wWK6dL+VFeo7RG9z9N59j/80EnWXW5KSRrNI1gFc/UD2up5fvpKyZPkG+ep29K7QAKrfj3ZQTeQ6VHT98aH4ja8jc0Eh2m3dVQqrhOeU/zw8xcs0Z3rT7nNa5RGFDcr7cMuKM+rM8H5IV50I3C65DcndV4jY3T8EzOUsJBShFwNNNjtoFHWG/6lUb77auhOEtdNsPxersZ6/2+vHrz2H9yUd4de5/GPzLSdx/kWGQA0Pb7D6Fw9tGv6p7rCNfjcKsgv4yc/taPgyO2MbP0w39GpdDnbKB6FAzFGtHNMXOiS2xdJCqz4N+EjJzXqbn6nSYVtMeQtx+4SGTSfTWHnug87e3neY1cph2M1R5KXqZngPGPNV7eLauYdW7HOIO9dceXSMqEzVGJnOi8NVOaC3TnrPJkiSWqiKJc/4NCRA2B46GhXMdAQDkVk7dkM9fayVlLnSb4hwaVSiJRhVK8q77qFM1k7UZQuy7kWCwLNjXw2QwIdQn24QPJS6vlbtiYrsqaFShBF6tEoJLj1PQOLIE3OUyDGha3m4T7BHh1H2sapcJxPnpHeDtIUf16TFmnlVo3G9neZfr19yt0QtCtOlfTqQ427bDvD4X2PWx6nFBP4z6ITwXVG/DhHaS1G4mcH0H76qWsitGn/YoKRv6PfpkWhf4nNx8/H7qEb799zZWvN0Q6lufDJ8yyGNyBGUZz0gsxkz0ABDia+H5zJrX9bEyhYI9Jyu0E6pBkZDxbSrz9tloUD7Ipv1aEpysGtbEptdS086sGeDljs61w+Hr6YboSsGapHAUnEhPCV8Piz+Xhy8zeZcf1Gu2+fLv60b3ceDmcyRn5mJOzA3cjk+DhCZUdbxmYwsfFyRvk1/dYrhdLYFDTh1p2D8mh0/XkPEHEX3lB/HHWcNUBi8yC5u0FXlZmLr1MuJSs/H+xnOa5Wc6bsWzINMjokQbrn7Cgsy7gHU1KO5WZsv2Kw0MjxGcD0UKKECRGL4+GyFW9n2xRhsrOlDy8XKj4MOZ/TXBis57erJMdKKe0a0mmkXp1iTW/3wvlh24iw6LDoEZqer/bmADm8vlcKMLmk7aThf+nG6LVZ0jQwqSOip4kmlZW/VflKws43z3H6Hk6a+x6Uxh0JKdpuonVwKpCM0unPg0wNsTfj6mm140nVtr9rSqfBrJFs4bxcmB+oOEb9/iPcv2r69CNPD6HMGb764937bXsxEFKBLHcdCZvNBZlA4ouqCKiK9u2SCc/KQdbn/1utX7OHrHeOKsQa+Ux4t0423ic2MMmzpvf/U63jCS2t6plGkIzEw2HKFjSuPhwGsfF/7dhmdIsQOT1pn0vlYeKBuSz6lHlmjTDlrO3X0GDkqc93oHv+UXvrc+Xh4oW8p0MkxNFxRzmVnNsTQBm0wG9Fyq6p/05lrT2wZXATp8bn3Z1Cq+JnjTNrVtH3ptC+qDIkFrRjTF+UdJ+F9b1Y9ZzPmAPnujFjrUDEXz2f+Jtk8+1Hzj/EILJsSrUyYQl5+kiLpvGWfZLChlgrytmi9KsmwNJkppzVZbvRtQ/y3rmguKQkA48H8PVJ001XPF9P8N2GhBzYER2pMfuiMffeWHDLbx9nAHZ6ZZJFfdpljWxiZufxumRanZw/T6l/wjn+zJw8vCTr8ik+g3unh7rWoIJrWvCpmM0wQn9coF6Wwzt491o1+GNo9ERJDpBGrfW1iNXjHEV+dve07QRopeqB1qw9xkHFpVCTG7Xa2IAIxtVRH7P2wtehmcmnaA8+ZaoHpXCwOUIq5t8S6h20lTpGBquvs6zeP/c9uAee4rDLbx8nQz+3qebgX36rZmTbUkR4mlRMh0a1LDoYbLyr1i39c0gwIUJ7F1XHOdv2tG2Db3RyRPcrbKBdlsjc0Qa8zYVrpza9hzgjZS9OrrBce28naXg+M4fNSpmtltA73dMbVLDU3WZVKgVFWgSkdVXhV1s4K55gXti/QUC/tKiI2JOyQaAOQcf52cj6eH2ZqNEj7G0+9bRD9vjaUq6PX96v8b0HclEF7P/pNH+vBMeCl3bCML/eqdhFzG4cHsrtg0Nhq/DG2syasCAGtHNLV4fyuHNTHopLhjQmE2W/0am7GtKuqkzD/4UWvN4wrBujUoxLWMbFkRfRuVRcOC0WTtqpfGFz1qYQ/PiLPXa4dheItIk/u79nknAICvp5vZzrjUVGgExwGDNgvPq9LnF6CyViZsrwDjHVY7fGF7+dSG/cO/3Nd87ZlYfDzc+WsHtOVpjUT7+L7x7czV/LjbOL2HXC9QqtENqN0HGHsIKGl8kkWLqWdD1pZrOqGnI1AfFCfTVCuo+HVkUyRm5GryWABAh5qhmNunLj7cfBF9G5XFuN/O8e0GFUP8sHFsNAAgOTMXQT66J6vt7zbH2uMPMfOvq5jTpw76NymPAU3Lo838A2hVNQQVgn1x+6vXoWRMJ6U5cT3eHnLM76ea2DIzN19TAwIAN77orJMzZdngRjhwMwGrjj7QLJvWtYZmiPH56R10hnTWLRuEjztX4+0UC1DWYYv97zzwnV4T7YxEVe3K+XW6yyt3AG7+rbus60Kg7pvAXgtGGJkSYaS5uFwzVXNIxnPglGGzjJhkHAe4mRk9FFCm8LFPScA/Akh7WrCuLJD6WPXYww/IMZIMs0QUUNrGAQ3ygubU0jWBgb/bti9TBhbMCp2bAXxdUGNexvaZzsVGAYoTe1WrDX/P5Fb468JTjHmtIgK83PGLBflM9IMTQJUXYGjzSAxtHqlZFlXKFxdmdIC/lyrKV3daDPEvvMtd8bb0vuREPD4euqcMvhqO16qGoHW1EBy4+RyAqt9T30Zl4eUu593+3daVjQYoT5KNT6dAeJSsqBoR8uQcsHU00Hl2YdOPuoOqWvUuhgFKk5Gm91+mMZD0AMgs6Jw6PAbY/xXw4DD/9h5GOllynGpU0v1Ddg9QDGol9JWsaNhpWR2cAEBYba0Axdd4gNL/V9v7sKjL2mSU6TmcxKI1lxHK6/U30W9ucgAKUFxE1VB/fGimTb9muG39VgD+YAYALs7siHvP00Xvr0Ck74setTD9z6s49YlqjhiO47B6eFNsPhMLbw853OUyo98btVOftEPTr/cZLB/9qojV2sVJmYbARL0Mvx2/BHIzgWZjVH/XewvwCwN2fQQk3gNqvGF+v6P+BZQKIOURkJMOhNcF3vge+K6+deVUit8XRdvFkp1RTx18hNYG4nky1VblGUrf60dgW0GCvLJNgFsFtYQlooC0Z/wvxonQHNluJtDyfSBIP2eunbh5qpq0OJnubNHvXRJldmdbUYBSjKwaLk6WWD6B3u5oUN5JUm0TUb0dHYm3oyMNlvdrXE7wPkoHeOHLnrXx54Un6FQrDH9dfIr32lVBuxpONnOxlAWWBQZtKvxbJgOqtAci/gWu/wXUNpGJtlpXoP5AVU2D3E23P0TJKFW/Ff1moVYfmS9T+VdU/VFKRAKPT1t0OELoNBGO/g/IfAlc2gj8O6twOV9OmRpvFAYor34AXPsTiLukev82DALuHzR8jhgdf9WJ+IoKx6matABVc4+au2OHF6txzNgc6BKWmpqKwMBApKSkICDA9loBVxY5RVWFu2lstE7/FUIIMWplZ+DR8cK/ZwnIg5Mcq+rn0niEqsMlX9MJH0UeIHMDPguyurjG3A97HVHvbDAs5+Laqsf/98D4HEbZqaqOxHw5VHa8B5xdrbts5F6gnOUDFoobS67fNIrHxe2Z3Ao/vt2IghNCiHDD/ja/jb6gckCbqYB/KBBcSXgyOrm7alvt1+y/zvj2FigXxNO0qF07YGpUjleA8XlvOn2jyhESpNUMElzZukISo6iJx8VVDfVHVZ75fQghxCiZXNVnZc+0onvNyJaqmpr8XNOjbt49ASwVlkDMLfO54ULfYKD5RFVw4mU6Bb5RHj7AyN2qx5mJqmHKPnQTKDYKUAghhBhqMhqIvwpU7VS0r6sOTiacAR6fAeoNUNWwnFmpCgZCqgvf16Nj/Ms7fml7OdV8SgKg4MQeKEAhhBBiyN1LeCI4eyhVRXdywcYjHFcW4hDUB4UQQohz8zTS2bKXnXOsELuiGhRCCCHO5e3tQOpT4M93VX93WwTU6at6nPES2DgYqNIBqNffYUUktqMAhRBCiHOp1Eb1/529qqy51bSSrfkGAyN2OaZcRFQUoBBCCHFOfVcBjNmeYp5IEgUohBBCnBPHCc+3QpwOhZ2EEEIIkRwKUAghhBAiORSgEEIIIURyKEAhhBBCiORQgEIIIYQQyaEAhRBCCCGSQwEKIYQQQiSHAhRCCCGESA4FKIQQQgiRHApQCCGEECI5FKAQQgghRHKcci4exhgAIDU11cElIYQQQohQ6uu2+jpuilMGKGlpaQCAcuXKObgkhBBCCLFUWloaAgMDTW7DMSFhjMQolUo8ffoU/v7+4Jx0JsvU1FSUK1cOsbGxCAgIcHRxREHH5BzomJwDHZNzcLVjsvfxMMaQlpaGiIgIyGSme5k4ZQ2KTCZD2bJlHV0MUQQEBLjEl1obHZNzoGNyDnRMzsHVjsmex2Ou5kSNOskSQgghRHIoQCGEEEKI5FCA4iCenp6YOXMmPD09HV0U0dAxOQc6JudAx+QcXO2YpHQ8TtlJlhBCCCGujWpQCCGEECI5FKAQQgghRHIoQCGEEEKI5FCAQgghhBDJoQCFEEIIIZJDAQoR5PHjx3j27BkAYZM8OYOsrCxHF0F0Dx8+xOPHjwEACoXCwaURx/Pnz5GcnAylUgkAmv+dWXZ2tqOLILrbt29j/vz5uHnzpqOLIho6RzgWBSgiysvLw6pVq7Bt2zbcuHHD0cURRV5eHsaMGYNmzZphzZo1AOC08x+p5eXlYdy4cejduzeGDBmCEydOuETQ9eeffyIqKgoTJkwAAMjlcgeXyDZ5eXl455130KpVK3Tp0gUjRoyAQqEwO3+HlOXm5mLy5MkYNGgQhgwZgsOHDzu6SDZTKBQYP3486tSpg+vXr+P58+eOLpLN6BwhDc77S5eYH3/8EaGhoVi5ciUmTZqE3r17Y9OmTQCc944vNjYWLVq0wJUrV7B582a89dZbYIw59Q81Li4OzZo1w6VLl9C9e3dcunQJ77zzDubNmwfAeT8rADh16hSaNWuG2NhYbNmyBYD075CMuXPnDpo0aYKbN29i6dKl6NKlC44fP675nJzR9u3bUblyZVy4cAGtW7fGhQsXMHXqVM1n5awWLlyIixcv4uDBg/jll1/QsmVLAM5b00rnCOmgAMVG+fn5WLx4MZYsWYIffvgBhw8fxo4dO9C+fXvMnTsXSqXSae/49uzZg8DAQBw7dgzNmzeHTCZDfn6+U9egHD16FLm5udi0aRPeffddHDx4EL169cLMmTNx9epVyGQypzuxqk+YKSkpaNKkCRo0aIBvv/0WeXl5kMvlTnc8ALBr1y74+flhx44daNOmDT7++GNUqFBB8CRjUnP37l2sW7cOI0aMwP79+zFx4kTs27cPHh4euH37tqOLZxXGGDIyMrBt2zYMGzYMzZo1w/Hjx7FixQocOXIEGRkZji6iVegcIR3OeeWUCMYY8vLykJ6ejr59+2LAgAEAgLp166JWrVqQy+VOV92pXUNy5swZ1KtXD0lJSXjzzTfRoUMHNG3aFGPGjEFcXJyDS2oZ9Q/0+fPnSEpKQpkyZQCoZtUcO3YsWrZsibFjxwJwviYs9Qnzzp07GDx4MHr16oWXL19i2bJlAFTV1c5C/Tm9ePECcXFx8PPzAwDEx8cjKSkJvr6+TtV8qv4t5ebmom7duhg6dCgA1V1rSEgI5HI57t6968giWo3jODx9+hT37t1D586d8cEHH6BPnz5Ys2YN+vTpg169eiE1NdXRxRSMzhHSQwGKFe7evQulUgmO4+Dl5YVBgwZhxowZOpF1UFAQMjIyULp0aQeXVpi7d++CMQaO4zQ/vitXrgAAFi9eDAD44Ycf8M4772DHjh2YOXMmnjx5AkC6VbkrVqzA+vXrcefOHU0tllwuR1hYmE7bf1hYGKZMmYLTp09j7969AJzjmNQUCgU4joNcLkdOTg5eeeUV9OrVC7/88gsGDx6MhQsXIicnx4GlNk19TLdv39Z8TvXr10dWVhY6d+6MwYMHo1KlSvD09MTixYvRtm1brFy5EoB0P6dTp04BKLzo1ahRAzNmzEBUVBQA1fcwNzcXmZmZiI6Odlg5LaF/TABQtmxZBAcHY9q0aXj48CH27duHv/76C/v27cPZs2fx5ZdfSvYzAoA//vgD//77L549e+Yy5wjtY1Jz2nMEI4L98ssvrHz58qxRo0asWbNm7Ndff2VKpVKzXqFQaB4PGzaMDR48mDHGWG5ubpGXVSj9Y1q3bh3LyclhjDE2f/58JpfLWdWqVdnp06c1z1m1ahWrVasW27Fjh6OKbVJMTAwLCQlh9evXZxUqVGBVqlRhCxYsYIwxdunSJVajRg02e/ZszXEyxlhcXBx744032Ntvv+2oYpvEd0yLFi3SrH/58iULCwvTHNPkyZOZl5cX8/b2ZmfOnHFQqU0z9TkpFAp29uxZtnbtWlalShX2xx9/MMYYS0pKYl999RULDg5meXl5jiw+r23btrGIiAgWHBzM7t+/zxhjLD8/X7Ne+3yRlpbGqlSpwk6cOFHUxbSIqWNKTExkI0eOZP7+/qx3795MoVBozoM///wzCwwMZJmZmY4qulFr165lpUuXZk2bNmUhISGsRYsWbMuWLYwxxs6dO8dq1qzpdOcIvmPatm2bZn1iYqLTnSMoQBFo8eLFrHLlymzDhg3syJEjbObMmUwul7MlS5ZoAhClUsny8/NZXl4ea9CgAfvxxx8N9qMdxDga3zHJZDK2ZMkSlp+fz65evcrq1avHIiMj2ZMnT3SeW6ZMGbZs2TIHldy0vn37sjFjxjDGGLt16xabP38+4ziO/fXXX4wxxsaNG8eaNGnC9u/fr/O8Pn36sKFDhxZxaYUxdkw7d+5k+fn5LD4+nvXr14/9/vvvrE6dOqxUqVKsW7durHr16uzUqVOMMd0LpRQYO6YdO3Zofifffvsta9q0KWOs8OJ+6NAh5uvry44ePeqYghuxbt061qRJEzZgwADWsmVLNnbsWJPbx8TEsPDwcJaYmKhZFhcXZ+9iWkTIMa1fv54FBwezHj16MMYKv2cnTpxgISEh7OzZs0VZZJPy8vLY4sWLWY0aNdjPP//McnJy2NGjR9mQIUPY66+/rgmmxowZw5o2beoU5whzx5Sdnc0YY+zJkyesf//+TnWOoABFgIyMDNahQwc2c+ZMxljhibJVq1asQoUKbPv27TrLnz17xsqWLctu3LjBGGPs/PnzkvtSmzqmcuXKsZ07dzLGGJszZw6Ty+Vs06ZNmucmJCSwOnXqsHXr1hV5uY1Rl//evXssKCiIxcTE6Kx/6623WJUqVdjz589ZfHw8a9CgARs4cCB7/PixZpsuXbqwyZMnF2m5TRFyTNWrV2dPnjxhjx8/ZhzHMXd3dzZ+/HiWlJTErl69yjp37sxatmzpiOLzEnJMNWrUYHfu3GGMqb5/3bp1YykpKZptvv76a9aqVSuWkZFRdAU3QfuCPGXKFPbw4UM2d+5cVq1aNc0Fju/EP3bsWDZw4EDGmOquvXXr1qxXr16SuIkRckzqO/H09HQ2adIkxnEc27t3r2Yf8+fPZx06dJDE8aglJyezTz/9lM2ePVunXLNnz2YtWrRgycnJjDHVOdwZzhGMmT+mtLQ0xhhjjx49copzhDYKUATIyclhJUuWZOvXr2eMMZaVlcUYU90BRkREsLfffpslJCRotv/1119Zq1atWGpqKhsxYgRzd3dnPXr0YAqFQqeK15HMHdPgwYNZUlISS09PZ7169WLlypVjM2fOZOfPn2cjR45kDRo0YE+fPnXkITDGVHfe2u9pVlYWK126NFuxYgVjrPAkmpyczHx8fNg333zDGGNs48aN7NVXX2UVKlRgCxYsYG+//TYrXbo0O3z4cNEfhB5Ljsnb21tzTOvXr2cnT57U2dfy5cvZvHnzmFKpdOh3z9LPac6cOYwxxtasWcOaNGnCOnTowP744w82YsQIFhISwpYvX170B6FH/5gYY5pmpytXrrA33niDdenSRbNOvzm4R48ebN68eWzChAlMJpOxIUOGOLw52NJjUgcy9+7dY0OGDGG+vr6sd+/ebODAgaxkyZKaWmQpfffOnz+vKbf6gv7bb7+x+vXr6zTpbN682WnOEUKPacOGDZI9R/ChAEXPpk2b2KhRo9jixYvZpUuXNMsHDhzIqlevromm161bx9q0acNGjRrFqlatys6fP88YU/0QBwwYwORyOfP392eNGzdm169fd8ShaFhzTFWqVNEcU25uLvvf//7HGjVqxKpVq8Zee+01zR2uo2zcuJFFRkayatWqsaZNm7JffvmFMaa6mxsyZAjr1KmT5oepPulPnTqVlS9fXrOPx48fszFjxrCePXuyLl26aGq8HEWMY1JTn2gcXWUrxjGtW7eOtWrVirVs2VLSnxNjuhfilStXspo1a7KVK1cyxnSbd9V3sxzHsebNm7Nr164V3QHwsPaY9PsBLV++nH300Uds+PDhkvucfv75Z5312p/HW2+9xYYNG8YYYzoXdKmfI4QeE1/gK5VzhCkUoBR48eIF69u3LwsLC2PvvPMOa9myJStTpgxbs2YNY0wVsVasWJFVrFiRRUREMB8fH02nKjc3N/b3338zxlRfkAEDBrDIyEjNMkcR65jU0tPTHR6YMMbYnj17WGRkJFuyZAmLiYlh77//PnNzc9Pcja9evVqnD5D6JHr69GkWEhKi0+GXscLaI0ey9Zik2MnN1mPSvtPLy8uTRP8MvmNyd3dnK1as0PRfUB/H48eP2ciRI1mTJk001ezqi9+VK1dY//79dZpEHMXWY3J0rQ8fU8ek/r2rawyysrJY3bp12a+//mp0f1I9R1hzTFIOSPRRgFJg8+bNrGnTpjrtjX369GFRUVGantCxsbFs9+7dbM2aNZofZUJCAqtYsaJOH41bt24VadmNsfWYNm/e7IhiG6WO+D/77DPWqFEjnRPju+++yxo0aMB2797NUlNT2aBBg1jz5s01ow4YU919REREsHv37hV10Y2iY3KNY2rcuDHbunWrwfN27tzJGjduzGbOnMkuXrzIunbtyh49elRk5TZFrGPq1q2bUx/TkydPWGRkpOa8fevWLUn1M3HFYxKK8qAUWL9+PcqWLYsyZcogPT0dAPDGG2/gwYMH+P7775GQkICyZcuiffv2GDJkCNzd3QEA+/fvh4eHB1599VXNvqpUqeKQY9Bn6zGpU1ZLhTo/y7Vr11CpUiW4u7trEgx9+eWX8PX1xbp16yCXyzF+/HjIZDIMGDAAx44dw6NHj/DPP/+gUaNGCAsLc+Rh6KBjco1j8vLywp9//qlJYKhOH96mTRs0bdoUn3/+ORo1aoT8/HzJ5EYS65jy8vKc9pgA4N9//0W5cuUQHh6O9957DzVr1sTDhw+Rl5cniVwnrnhMgjk6QnKEgwcPspiYGJ32048//phVq1ZNZ7spU6awdu3asebNm2uqpRlT1TBcv36dff/99ywiIoJ98sknLC8vz6EdjFzxmPbs2cMmTpzIFi1apFPdv2LFCubv76+pqlTfUaxYsYJVrlyZHTlyhDHG2I0bNzT9ZkJDQ1mDBg0c3oZMx+S6x1S1alV24MABzbbp6els0aJFTC6Xs9atW+v0/3IEOqbCY1KPRFIqlaxfv36sRIkSLDg4mNWqVcugCbioueIxWatYBSjPnz9nQ4YMYRzHsXr16ulUK9+9e5eFhISwVq1asblz57Lo6GgWFRXF9u3bx+rVq8emT5+u2fbs2bOsZ8+eLCoqymS7ZVFwxWN6+vQp69atGytdujQbNGgQq1OnDgsMDNT8WG/evMnKlCmjKb92p7awsDC2cOFCzd9paWns/v37Dk+GRcdUPI5JO3ne1atXWbNmzdjatWuL9Bj00TEZP6aMjAzWrVs3VrZsWbZhw4YiPw5trnhMtio2AUpeXh5bunQp69SpE9u4caNmyKk6iQ1jjB05coSNGjWKNWzYkE2YMIE9f/6cMcbY22+/zfr06aOzv3PnzhVp+fm44jFlZGSwoUOHsv79++v0QWjatKmmR3pqair78ssvmbe3t6btW13T89prr7FRo0ZpnieFYXN0TMXzmKSAjsn8MUmhg7krHpMYik2Awpgq6ZA6m+hnn33GQkJCNENptWlHpvHx8ax27drsyy+/ZIwZDqtzNFc8pjFjxrBdu3YxxgrLNmvWLNasWTOdRF8tWrRgr7zyCnvw4AFjjLGHDx+yGjVqaJLMSQkdEx2To9Ax0TE5q2IVoOjfpUVERLAxY8aw1NRUg/VZWVksNzeXLV26lDVo0MDhba3GuOIxafdSV4/rf+utt9jo0aN1tnv8+DGrXLkyi4yM1CSYa9u2rSSGo+qjY6JjchQ6JjomZ1WsAhQ1dW3Cpk2bmJubG9uzZ4/O+sePH7OlS5eyxo0b62RblTJXPCZtLVq0YKtXr2aMMZ0JyW7fvs02bNjAJk+erFnvLOiYnAMdk3OgY3I9xTJA0RYdHc3at2/P4uPjGWNMk7J+/fr1bP78+Y4smtVc7Zju3r3LQkNDddpVtZusnBEdk3OgY3IOdEyuyc3Rw5wdJT8/H25ubvjpp59Qr149bNiwAXfv3sWRI0ewZs0aDBw40NFFtJirHRNjDBzH4ciRI/Dz80OjRo0AAJ999hni4uLw2WefSSb/glB0TM6Bjsk50DG5tmIboLi5qQ69Vq1aaNiwISZNmoTy5cvjxx9/RO3atR1cOuu42jGpExSdOnUKffr0wd69ezFmzBhkZmbi119/dcofKR2Tc6Bjcg50TC7OgbU3Dnfnzh1Wu3Zt5uPjYzDpkrNytWPKyspilStXZhzHMU9PTzZ79mxHF8lmdEzOgY7JOdAxua5iW4MCAHK5HH369MH//d//wdvb29HFEYWrHZOXlxciIyPRoUMHLFy4EF5eXo4uks3omJwDHZNzoGNyXRxjzpSYnxRHCoUCcrnc0cUQFR2Tc6Bjcg50TK6JAhRCCCGESA7NZkwIIYQQyaEAhRBCCCGSQwEKIYQQQiSHAhRCCCGESA4FKIQQQgiRHApQCCGEECI5FKAQQgghRHIoQCGEFInIyEgsXrzY0cUghDgJClAIKcY4jjP5b9asWY4uog7tsvn6+qJKlSoYNmwYzp49a/G+WrdujUmTJolfSEKIKChAIaQYe/bsmebf4sWLERAQoLPsww8/1GzLGEN+fr4DS6uyatUqPHv2DFevXsWSJUuQnp6OZs2aYe3atY4uGiFERBSgEFKMhYWFaf4FBgaC4zjN3zdu3IC/vz927dqFRo0awdPTE0eOHMHdu3fRo0cPhIaGws/PD02aNMG///6rs9+EhAR0794d3t7eiIqKwm+//Wbw2snJyRg1ahRCQkIQEBCAtm3b4uLFi2bLHBQUhLCwMERGRqJjx474448/MGjQIEyYMAFJSUkAgJcvX2LgwIEoU6YMfHx8UKdOHfz++++afQwbNgwHDx7Et99+q6mRefDgAQDgypUreP311+Hn54fQ0FC8/fbbePHihQ3vMiHEGhSgEEJMmjJlCmbPno3r16+jbt26SE9PR5cuXbBv3z6cP38enTt3Rvfu3fHo0SPNc4YNG4bY2Fjs378ff/zxB5YuXYqEhASd/fbr1w8JCQnYtWsXzp49i4YNG6Jdu3ZITEy0uIyTJ09GWloa9u7dCwDIzs5Go0aN8Pfff+PKlSsYM2YM3n77bZw6dQoA8O233yI6OhqjR4/W1BaVK1cOycnJaNu2LRo0aIAzZ84gJiYG8fHxePPNN214BwkhVmGEEMIYW7VqFQsMDNT8vX//fgaAbd++3exza9Wqxb7//nvGGGM3b95kANipU6c0669fv84AsEWLFjHGGDt8+DALCAhg2dnZOvupVKkS+/HHH42+DgC2bds2g+VZWVkMAJszZ47R53bt2pV98MEHmr9fe+019t577+ls88UXX7COHTvqLIuNjWUA2M2bN43umxAiPjdHBkeEEOlr3Lixzt/p6emYNWsW/v77bzx79gz5+fnIysrS1KBcv34dbm5uaNSokeY51atXR1BQkObvixcvIj09HcHBwTr7zsrKwt27dy0uIyuYlJ3jOACqqeq//vprbNq0CU+ePEFubi5ycnLg4+Njcj8XL17E/v374efnZ7Du7t27qFq1qsVlI4RYhwIUQohJvr6+On9/+OGH2Lt3L+bPn4/KlSvD29sbffv2RW5uruB9pqenIzw8HAcOHDBYpx3ICHX9+nUAQFRUFABg3rx5+Pbbb7F48WLUqVMHvr6+mDRpktkypqeno3v37pgzZ47BuvDwcIvLRQixHgUohBCLHD16FMOGDUOvXr0AqC7q6g6mgKq2JD8/H2fPnkWTJk0AADdv3kRycrJmm4YNGyIuLg5ubm6IjIy0uUzqEUjt27fXlLFHjx4YPHgwAECpVOLWrVuoWbOm5jkeHh5QKBQ6+2nYsCG2bNmCyMhIuLnR6ZEQR6JOsoQQi1SpUgVbt27FhQsXcPHiRbz11ltQKpWa9dWqVUPnzp0xduxYnDx5EmfPnsWoUaPg7e2t2aZ9+/aIjo5Gz549sWfPHjx48ADHjh3Dp59+ijNnzph8/eTkZMTFxeHhw4fYu3cv+vbti/Xr12PZsmWa2pcqVapg7969OHbsGK5fv46xY8ciPj5eZz+RkZE4efIkHjx4gBcvXkCpVGL8+PFITEzEwIEDcfr0ady9exe7d+/G8OHDDYIZQoh9UYBCCLHIwoULUaJECTRv3hzdu3dHp06d0LBhQ51tVq1ahYiICLz22mvo3bs3xowZg9KlS2vWcxyHf/75B61atcLw4cNRtWpVDBgwAA8fPkRoaKjJ1x8+fDjCw8NRvXp1jBs3Dn5+fjh16hTeeustzTbTpk1Dw4YN0alTJ7Ru3RphYWHo2bOnzn4+/PBDyOVy1KxZEyEhIXj06BEiIiJw9OhRKBQKdOzYEXXq1MGkSZMQFBQEmYxOl4QUJY6pe5cRQgghhEgE3RIQQgghRHIoQCGEEEKI5FCAQgghhBDJoQCFEEIIIZJDAQohhBBCJIcCFEIIIYRIDgUohBBCCJEcClAIIYQQIjkUoBBCCCFEcihAIYQQQojkUIBCCCGEEMn5fxg1I0o7+G9IAAAAAElFTkSuQmCC", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "vix_spot_wide[\"Close\"][[\"VIX\",\"VIX9D\"]].plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "id": "fe6b2e70", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 11, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "vix_spot_wide[\"Close\"][[\"SHORTVOL\"]].plot()" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "id": "f732d32f", + "metadata": {}, + "outputs": [], + "source": [ + "def add_column_level(df:pd.DataFrame,var_name):\n", + " df2=pd.DataFrame(df)\n", + " idx=df2.columns.to_frame()\n", + " idx.insert(0,\"Variable\",var_name)\n", + " df2.columns=pd.MultiIndex.from_frame(idx)\n", + " return df2 \n" + ] + }, + { + "cell_type": "markdown", + "id": "8809898e", + "metadata": {}, + "source": [ + "Compute the basis (future price - spot price) for the varous tenors and VIX indexes. It is really only correct\n", + "to compare the VIX index since the futures are trading on the VIX, not VIX9D etc. " + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "id": "ed7dc06f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
VariableFuturesVIX9D_Basis...VIX3M_BasisGVZ_Basis
1.01.51.52.03.04.05.06.01.01.5...5.06.01.01.51.52.03.04.05.06.0
Trade Date
2004-03-26NaNNaNNaN20.2720.20NaN20.06NaNNaNNaN...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
2004-03-29NaNNaNNaN19.7719.76NaN19.76NaNNaNNaN...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
2004-03-30NaNNaNNaN19.6119.73NaN19.92NaNNaNNaN...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
2004-03-31NaNNaNNaN19.7219.90NaN20.18NaNNaNNaN...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
2004-04-01NaNNaNNaN19.6519.94NaN20.28NaNNaNNaN...NaNNaNNaNNaNNaNNaNNaNNaNNaNNaN
..................................................................
2024-01-2614.1414.634414.634415.1715.8716.21NaN17.031.071.5644...NaN2.002.232.72442.72443.263.964.30NaN5.12
2024-01-2914.2014.735614.735615.2315.9116.25NaN16.960.250.7856...NaN1.741.121.65561.65562.152.833.17NaN3.88
2024-01-3014.1014.660014.660015.1015.8716.25NaN17.070.380.9400...NaN1.931.051.61001.61002.052.823.20NaN4.02
2024-01-3114.8815.384015.384015.7216.4116.71NaN17.470.330.8340...NaN1.511.722.22402.22402.563.253.55NaN4.31
2024-02-0114.3915.010815.010815.3616.1016.43NaN17.191.111.7308...NaN1.690.671.29081.29081.642.382.71NaN3.47
\n", + "

4996 rows × 40 columns

\n", + "
" + ], + "text/plain": [ + "Variable Futures \\\n", + "0 1.0 1.5 1.5 2.0 3.0 4.0 5.0 6.0 \n", + "Trade Date \n", + "2004-03-26 NaN NaN NaN 20.27 20.20 NaN 20.06 NaN \n", + "2004-03-29 NaN NaN NaN 19.77 19.76 NaN 19.76 NaN \n", + "2004-03-30 NaN NaN NaN 19.61 19.73 NaN 19.92 NaN \n", + "2004-03-31 NaN NaN NaN 19.72 19.90 NaN 20.18 NaN \n", + "2004-04-01 NaN NaN NaN 19.65 19.94 NaN 20.28 NaN \n", + "... ... ... ... ... ... ... ... ... \n", + "2024-01-26 14.14 14.6344 14.6344 15.17 15.87 16.21 NaN 17.03 \n", + "2024-01-29 14.20 14.7356 14.7356 15.23 15.91 16.25 NaN 16.96 \n", + "2024-01-30 14.10 14.6600 14.6600 15.10 15.87 16.25 NaN 17.07 \n", + "2024-01-31 14.88 15.3840 15.3840 15.72 16.41 16.71 NaN 17.47 \n", + "2024-02-01 14.39 15.0108 15.0108 15.36 16.10 16.43 NaN 17.19 \n", + "\n", + "Variable VIX9D_Basis ... VIX3M_Basis GVZ_Basis \\\n", + "0 1.0 1.5 ... 5.0 6.0 1.0 1.5 \n", + "Trade Date ... \n", + "2004-03-26 NaN NaN ... NaN NaN NaN NaN \n", + "2004-03-29 NaN NaN ... NaN NaN NaN NaN \n", + "2004-03-30 NaN NaN ... NaN NaN NaN NaN \n", + "2004-03-31 NaN NaN ... NaN NaN NaN NaN \n", + "2004-04-01 NaN NaN ... NaN NaN NaN NaN \n", + "... ... ... ... ... ... ... ... \n", + "2024-01-26 1.07 1.5644 ... NaN 2.00 2.23 2.7244 \n", + "2024-01-29 0.25 0.7856 ... NaN 1.74 1.12 1.6556 \n", + "2024-01-30 0.38 0.9400 ... NaN 1.93 1.05 1.6100 \n", + "2024-01-31 0.33 0.8340 ... NaN 1.51 1.72 2.2240 \n", + "2024-02-01 1.11 1.7308 ... NaN 1.69 0.67 1.2908 \n", + "\n", + "Variable \n", + "0 1.5 2.0 3.0 4.0 5.0 6.0 \n", + "Trade Date \n", + "2004-03-26 NaN NaN NaN NaN NaN NaN \n", + "2004-03-29 NaN NaN NaN NaN NaN NaN \n", + "2004-03-30 NaN NaN NaN NaN NaN NaN \n", + "2004-03-31 NaN NaN NaN NaN NaN NaN \n", + "2004-04-01 NaN NaN NaN NaN NaN NaN \n", + "... ... ... ... ... .. ... \n", + "2024-01-26 2.7244 3.26 3.96 4.30 NaN 5.12 \n", + "2024-01-29 1.6556 2.15 2.83 3.17 NaN 3.88 \n", + "2024-01-30 1.6100 2.05 2.82 3.20 NaN 4.02 \n", + "2024-01-31 2.2240 2.56 3.25 3.55 NaN 4.31 \n", + "2024-02-01 1.2908 1.64 2.38 2.71 NaN 3.47 \n", + "\n", + "[4996 rows x 40 columns]" + ] + }, + "execution_count": 13, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "vix_spot_history_closes=vix_spot_wide['Close'] \n", + "vix_basis_by_index=[add_column_level(close.sub(vix_spot_history_closes[spot_symbol],axis=0),spot_symbol+\"_Basis\") for spot_symbol in [\"VIX9D\",\"VIX\",\"VIX3M\",\"GVZ\"]]\n", + "\n", + "closes=add_column_level(close,\"Futures\")\n", + "vix_basis=pd.concat(chain([closes],vix_basis_by_index),axis=1,join=\"inner\")\n", + "vix_basis \n" + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "id": "83045156", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "Symbol\n", + "GVZ 12.0500\n", + "LONGVOL 26.6759\n", + "OVX 30.0000\n", + "SHORTVOL 1774.0829\n", + "VIX 13.3400\n", + "VIX1D 10.1700\n", + "VIX3M 16.0400\n", + "VIX6M 18.2100\n", + "VIX9D 11.9000\n", + "VVIX 94.8900\n", + "VXTLT 14.6700\n", + "Name: 2023-07-14 00:00:00, dtype: float64" + ] + }, + "execution_count": 14, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "day_of_interest='2023-07-14'\n", + "di_spot=vix_spot_history_closes.loc[day_of_interest]\n", + "di_spot\n" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "id": "301310f9", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
1.01.5...5.06.0
ChangeCloseExpiryFileHighLowOpenSettleTenor_DaysChange...Tenor_DaysChangeCloseExpiryFileHighLowOpenSettleTenor_Days
Trade Date
2023-07-14-0.387513.772023-07-192023-07-19.w_.CFE_VX_2023.csv14.413.7514.1913.80485.0-0.214355...124.0-0.111418.322023-12-202023-12-20.w_.CFE_VX_2023.csv18.5718.2118.4318.3386159.0
\n", + "

1 rows × 72 columns

\n", + "
" + ], + "text/plain": [ + " 1.0 \\\n", + " Change Close Expiry File High \n", + "Trade Date \n", + "2023-07-14 -0.3875 13.77 2023-07-19 2023-07-19.w_.CFE_VX_2023.csv 14.4 \n", + "\n", + " 1.5 ... 5.0 \\\n", + " Low Open Settle Tenor_Days Change ... Tenor_Days \n", + "Trade Date ... \n", + "2023-07-14 13.75 14.19 13.8048 5.0 -0.214355 ... 124.0 \n", + "\n", + " 6.0 \\\n", + " Change Close Expiry File High \n", + "Trade Date \n", + "2023-07-14 -0.1114 18.32 2023-12-20 2023-12-20.w_.CFE_VX_2023.csv 18.57 \n", + "\n", + " \n", + " Low Open Settle Tenor_Days \n", + "Trade Date \n", + "2023-07-14 18.21 18.43 18.3386 159.0 \n", + "\n", + "[1 rows x 72 columns]" + ] + }, + "execution_count": 15, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "di_futures=vix_futures_wide.loc[[day_of_interest]]\n", + "di_futures" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "id": "b3296243", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0\n", + "1.0 0.430\n", + "1.5 2.113\n", + "1.5 2.113\n", + "2.0 2.410\n", + "3.0 3.710\n", + "4.0 4.330\n", + "5.0 4.740\n", + "6.0 4.980\n", + "Name: 2023-07-14 00:00:00, dtype: float64" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "di_basis=vix_basis.loc[day_of_interest]\n", + "di_basis[\"VIX_Basis\"]" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "id": "00ef882f", + "metadata": {}, + "outputs": [ + { + "data": { + "text/html": [ + "
\n", + "\n", + "\n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
CloseTenor_Days
1.01.51.52.03.04.05.06.01.01.51.52.03.04.05.06.0
Trade Date
2023-07-1413.7715.45315.45315.7517.0517.6718.0818.325.028.028.033.068.096.0124.0159.0
\n", + "
" + ], + "text/plain": [ + " Close \\\n", + " 1.0 1.5 1.5 2.0 3.0 4.0 5.0 6.0 \n", + "Trade Date \n", + "2023-07-14 13.77 15.453 15.453 15.75 17.05 17.67 18.08 18.32 \n", + "\n", + " Tenor_Days \n", + " 1.0 1.5 1.5 2.0 3.0 4.0 5.0 6.0 \n", + "Trade Date \n", + "2023-07-14 5.0 28.0 28.0 33.0 68.0 96.0 124.0 159.0 " + ] + }, + "execution_count": 17, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "cols_to_plot=[1,1.5] + list(range(2,5))\n", + "df_day_of_interest_to_plot=di_futures.swaplevel(axis=1)[['Close',\"Tenor_Days\"]]\n", + "\n", + "#.swaplevel(axis=1)[cols_to_plot].swaplevel()\n", + "dx=df_day_of_interest_to_plot.T\n", + "df_day_of_interest_to_plot\n" + ] + }, + { + "cell_type": "code", + "execution_count": 18, + "id": "2a103aa1", + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "" + ] + }, + "execution_count": 18, + "metadata": {}, + "output_type": "execute_result" + }, + { + "data": { + "image/png": "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", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "df_day_of_interest_to_plot.plot(x=\"Tenor_Days\", y=\"Close\", kind = 'scatter', use_index=True)" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "id": "f3f881dc", + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3 (ipykernel)", + "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.11.2" + } + }, + "nbformat": 4, + "nbformat_minor": 5 +} diff --git a/src/vix_utils/vix_cash_term_structure.py b/src/vix_utils/vix_cash_term_structure.py index e9b5ef9..3fa30c7 100644 --- a/src/vix_utils/vix_cash_term_structure.py +++ b/src/vix_utils/vix_cash_term_structure.py @@ -20,8 +20,9 @@ def get_vix_index_histories(): Return the history of some volatility indexes. """ - with asyncio.Runner() as runner: - return runner.run(async_get_vix_index_histories()) +# with asyncio.Runner() as runner: +# return runner.run(async_get_vix_index_histories()) + return asyncio.run(async_get_vix_index_histories()) async def async_get_vix_index_histories(): """ @@ -36,7 +37,7 @@ async def async_get_vix_index_histories(): make_dir(download_data_directory) symbols_with_value_only=['VVIX','GVZ','OVX','SHORTVOL','LONGVOL','VXTLT'] - symbols_with_high_low_close=['VIX', 'VIX9D', "VIX3M", "VIX6M" ] + symbols_with_high_low_close=['VIX', 'VIX9D', "VIX3M", "VIX6M","VIX1D" ] index_history_symbols = symbols_with_value_only + symbols_with_high_low_close index_history_urls = [f"https://cdn.cboe.com/api/global/us_indices/daily_prices/{symbol}_History.csv" for symbol in index_history_symbols] @@ -74,7 +75,7 @@ async def download_csv_from_web(url): # download all of them - logging.debug(f"Skipping read from web") + download_coro = (download_csv_from_web(url) for url in index_history_urls) l = await asyncio.gather(*download_coro) @@ -92,20 +93,19 @@ def read_index_csv(fname,col_names,symbol): frames=chain(frames1,frames2) - all_vix_cash = pd.concat(frames) - all_vix_cash['Trade Date'] = pd.to_datetime(all_vix_cash['Trade Date']) - all_vix_cash.set_index('Trade Date') - logging.debug(f"\nAll Vix cash \n{all_vix_cash}") - - - return all_vix_cash + all_vix_spot = pd.concat(frames) + all_vix_spot['Trade Date'] = pd.to_datetime(all_vix_spot['Trade Date']) + all_vix_spot.set_index('Trade Date') + logging.debug(f"\nAll Vix spot \n{all_vix_spot}") + + return all_vix_spot -def pivot_cash_term_structure_on_symbol(all_vix_cash): +def pivot_spot_term_structure_on_symbol(all_vix_cash): try: m1=f"all_vix_cash columns index:\n{all_vix_cash.columns}" - all_cash_frame = all_vix_cash.set_index(["Trade Date","Symbol"]).unstack() + all_spot_frame = all_vix_cash.set_index(["Trade Date","Symbol"]).unstack() except Exception as e: - logging.error("{e} in pivot_cash_term_structure_on_trade_date\n{m1}\n{m1}") + logging.error("{e} in pivot_spot_term_structure_on_trade_date\n{m1}\n{m1}") raise e - return all_cash_frame \ No newline at end of file + return all_spot_frame \ No newline at end of file diff --git a/src/vix_utils/vixutil.py b/src/vix_utils/vixutil.py index c2e1b16..b85cba8 100644 --- a/src/vix_utils/vixutil.py +++ b/src/vix_utils/vixutil.py @@ -48,12 +48,12 @@ parser.add_argument("-c", metavar="output_file", - dest="cash_records", help=f"""output the vix cash term structure a file in record format. + dest="spot_records", help=f"""output the vix spot term structure a file in record format. {output_format_help}. Some other indexes from CBOE will also be included. {output_format_help} """) parser.add_argument("-d", metavar="output_file", - dest="cash_wide", help=f"""output the vix cash term structure a file in wide format,with a column for each index. + dest="spot_wide", help=f"""output the vix spot term structure a file in wide format,with a column for each index. {output_format_help}. Some other indexes from CBOE will also be included. {output_format_help} """) @@ -92,9 +92,9 @@ def main(): logger.setLevel(args.loglevel) vix_futures=vix_utils.load_vix_term_structure() - vix_cash=vix_utils.get_vix_index_histories() + vix_spot=vix_utils.get_vix_index_histories() vix_monthly_futures_wide=vix_utils.pivot_futures_on_monthly_tenor(vix_futures) - vix_cash_wide=vix_utils.pivot_cash_term_structure_on_symbol(vix_cash) + vix_spot_wide=vix_utils.pivot_spot_term_structure_on_symbol(vix_spot) vix_m1m2_weights = vix_utils.vix_constant_maturity_weights(vix_utils.vix_futures_trade_dates_and_expiry_dates()) futures_m1m2=vix_utils.continuous_maturity_one_month(vix_monthly_futures_wide) @@ -104,11 +104,11 @@ def main(): if ofile := args.futures_wide: write_frame(vix_monthly_futures_wide, ofile) - if ofile := args.cash_records: - write_frame(vix_cash,ofile) + if ofile := args.spot_records: + write_frame(vix_spot,ofile) - if ofile := args.cash_wide: - write_frame(vix_cash_wide,ofile) + if ofile := args.spot_wide: + write_frame(vix_spot_wide,ofile) if ofile := args.w_m1m2: write_frame(vix_m1m2_weights,ofile) diff --git a/test.ps1 b/test.ps1 deleted file mode 100644 index ad7354c..0000000 --- a/test.ps1 +++ /dev/null @@ -1,11 +0,0 @@ -mkdir test_output -cd test_output -vixutil -i -m continuous.pkl -t term.pkl -c cash.pkl --calendar calendar.pkl -w continuous_weights.pkl - -vixutil -i -m continuous.csv -t term.csv -c cash.csv --calendar calendar.csv -w continuous_weights.csv - - -vixutil -i -m continuous.html -t term.html -c cash.html --calendar calendar.html -w continuous_weights.html - -vixutil -i -m continuous.xlsx -t term.xlsx -c cash.xlsx --calendar calendar.xlsx -w continuous_weights.xlsx -cd .. \ No newline at end of file diff --git a/test/test_read_vix_futures_history.py b/test/test_read_vix_futures_history.py index 0c90202..ec3dac5 100644 --- a/test/test_read_vix_futures_history.py +++ b/test/test_read_vix_futures_history.py @@ -1,5 +1,6 @@ import pytest from vix_utils.download_vix_futures import read_csv_future_file,read_csv_future_files +from vix_utils import load_vix_term_structure,get_vix_index_histories import pandas as pd from pathlib import Path from shutil import copy,copytree @@ -71,4 +72,24 @@ def test_read_future_file_may_2007(tmp_path): bogus_data=df2.loc[date_str] print(f"\n{date_str}: Bogus data:\n{bogus_data}") - \ No newline at end of file +def debug_all_dates(): + """ + We aren't making this a test because there are just missing data or data over various ranges so they won't + necessarly match. + """ + pass + spot=get_vix_index_histories().set_index("Trade Date") + sv=spot[spot.Symbol=='SHORTVOL'][["Close"]] + print(f"sv\n{sv}") + ts=load_vix_term_structure().set_index("Trade Date") + print(f"ts\n{ts}") + diff1=sv.index.difference(ts.index).to_list() + diff2=ts.index.difference(sv.index).to_list() + diff3=ts.index.symmetric_difference(sv.index).to_list() + if(len(diff3) >0 ): + print(f"Missing from futures\n{diff1}\n\nMissing from Spot\n{diff2}\n\nMissing from either\n{diff3}") + pass #make it easy to put a breakpoint + assert len(diff3) == 0 + +if __name__=="__main__": + debug_all_dates() \ No newline at end of file