diff --git a/backtester/backtester.py b/backtester/backtester.py index 6bd18d6..bb72bf8 100644 --- a/backtester/backtester.py +++ b/backtester/backtester.py @@ -6,10 +6,9 @@ from .datahandler import HistoricalOptionsData class Backtest: """Processes signals from the Strategy object""" - def __init__(self, qty=1, capital=1_000_000, shares_per_contract=100): + + def __init__(self, capital=1_000_000): self.capital = capital - self.shares_per_contract = shares_per_contract - self.qty = qty self._strategy = None self._data = None self.inventory = pd.DataFrame() @@ -47,12 +46,22 @@ class Backtest: assert self._strategy is not None assert self._data.schema == self._strategy.schema + index = pd.MultiIndex.from_product( + [[l.name for l in self._strategy.legs], + [ + 'contract', 'underlying', 'expiration', 'type', 'strike', + 'cost', 'date', 'order' + ]]) + index_totals = pd.MultiIndex.from_product([['totals'], ['cost']]) + self.inventory = pd.DataFrame(columns=index.append(index_totals)) self.trade_log = pd.DataFrame() - data_iterator = self._data.iter_months() if monthly else self._data.iter_dates() + data_iterator = self._data.iter_months( + ) if monthly else self._data.iter_dates() for _date, options in data_iterator: - entry_signals = self._strategy.filter_entries(options, self.inventory) + entry_signals = self._strategy.filter_entries( + options, self.inventory) exit_signals = self._strategy.filter_exits(options, self.inventory) self._execute_exit(exit_signals) @@ -84,9 +93,11 @@ class Backtest: if not entry_signals.empty: costs = entry_signals['totals']['cost'] - return entry_signals.loc[costs.idxmin():costs.idxmin()], costs.min() + return entry_signals.loc[costs.idxmin():costs.idxmin()], costs.min( + ) else: return entry_signals, 0 def __repr__(self): - return "Backtest(capital={}, strategy={})".format(self.capital, self._strategy) + return "Backtest(capital={}, strategy={})".format( + self.capital, self._strategy) diff --git a/backtester/strategy/strategy.py b/backtester/strategy/strategy.py index 089569e..1cbff39 100644 --- a/backtester/strategy/strategy.py +++ b/backtester/strategy/strategy.py @@ -17,9 +17,12 @@ class Strategy: Takes in a number of `StrategyLeg`'s (option contracts), and filters that determine entry and exit conditions. """ - def __init__(self, schema): + + def __init__(self, schema, qty=1, shares_per_contract=100): assert isinstance(schema, Schema) self.schema = schema + self.qty = qty + self._shares_per_contract = shares_per_contract self.legs = [] self.conditions = [] self.exit_thresholds = (0.0, 0.0) @@ -82,8 +85,10 @@ class Strategy: """ # Remove contracts already in inventory - inventory_contracts = pd.concat([inventory[leg.name]['contract'] for leg in self.legs]) - subset_options = options[~options[self.schema['contract']].isin(inventory_contracts)] + inventory_contracts = pd.concat( + [inventory[leg.name]['contract'] for leg in self.legs]) + subset_options = options[~options[self.schema['contract']]. + isin(inventory_contracts)] return self._filter_legs(subset_options, Signal.ENTRY) @@ -98,20 +103,20 @@ class Strategy: pd.DataFrame: Exit signals """ - # inventory could be empty, in which case this function breaks. - if inventory.empty: - return - - underlying_col, spot_col = self.schema['underlying'], self.schema['underlying_last'] - underlying_symbols = options.loc[:, (underlying_col, spot_col)].drop_duplicates(underlying_col) + underlying_col, spot_col = self.schema['underlying'], self.schema[ + 'underlying_last'] + underlying_symbols = options.loc[:, ( + underlying_col, spot_col)].drop_duplicates(underlying_col) spot_prices = underlying_symbols.set_index(underlying_col).to_dict() leg_candidates = [ - self._exit_candidates(l.direction, inventory[l.name], options, spot_prices) for l in self.legs + self._exit_candidates(l.direction, inventory[l.name], options, + spot_prices) for l in self.legs ] total_costs = sum([l['cost'] for l in leg_candidates]) - threshold_exits = self._filter_thresholds(inventory['totals']['cost'], total_costs) + threshold_exits = self._filter_thresholds(inventory['totals']['cost'], + total_costs) filter_mask = [] for i, leg in enumerate(self.legs): @@ -119,11 +124,12 @@ class Strategy: filter_mask.append(flt(leg_candidates[i])) fields = self._signal_fields((~leg.direction).value) leg_candidates[i] = leg_candidates[i].loc[:, fields.values()] - leg_candidates[i].columns = pd.MultiIndex.from_product([["leg_{}".format(i + 1)], - leg_candidates[i].columns]) + leg_candidates[i].columns = pd.MultiIndex.from_product( + [["leg_{}".format(i + 1)], leg_candidates[i].columns]) totals = pd.DataFrame.from_dict({"cost": total_costs}) - totals.columns = pd.MultiIndex.from_product([["totals"], totals.columns]) + totals.columns = pd.MultiIndex.from_product([["totals"], + totals.columns]) leg_candidates.append(totals) filter_mask = reduce(lambda x, y: x | y, filter_mask) exits_mask = threshold_exits | filter_mask @@ -165,10 +171,7 @@ class Strategy: if leg.direction == Direction.SELL: subset_df['cost'] = -subset_df['cost'] - # shares_per_contract_ hardcoded, we calculate this here so that inventory['totals']['cost'] shows the - # actual value that was paid to enter (we should multiply by qty as well but its default value is 1). - # This should probably be moved? - subset_df['cost'] *= 100 + subset_df['cost'] *= self._shares_per_contract * self.qty dfs.append(subset_df.reset_index(drop=True)) @@ -209,10 +212,12 @@ class Strategy: cost = sum(leg["cost"] for leg in dfs) totals = pd.DataFrame.from_dict({"cost": cost}) - totals.columns = pd.MultiIndex.from_product([["totals"], totals.columns]) + totals.columns = pd.MultiIndex.from_product([["totals"], + totals.columns]) for i in range(len(dfs)): - dfs[i].columns = pd.MultiIndex.from_product([["leg_{}".format(i + 1)], dfs[i].columns]) + dfs[i].columns = pd.MultiIndex.from_product( + [["leg_{}".format(i + 1)], dfs[i].columns]) dfs.append(totals) @@ -237,7 +242,9 @@ class Strategy: # the daily data the values will all be NaN and the filters should all yield False. fields = self._signal_fields((~direction).value) options = options.rename(columns=fields) - candidates = inventory_leg[['contract']].merge(options, how='left', on='contract') + candidates = inventory_leg[['contract']].merge(options, + how='left', + on='contract') order = get_order(direction, Signal.EXIT) candidates['order'] = order.name @@ -246,9 +253,7 @@ class Strategy: if ~direction == Direction.SELL: candidates['cost'] = -candidates['cost'] - # This is shares_per_contract hardcoded because it is currently an attribute of the backtester. See the comment - # on _filter_legs. - candidates['cost'] *= 100 + candidates['cost'] *= self._shares_per_contract * self.qty return candidates @@ -271,4 +276,5 @@ class Strategy: return (excess_return >= profit_pct) | (excess_return <= -loss_pct) def __repr__(self): - return "Strategy(legs={}, conditions={})".format(self.legs, self.conditions) + return "Strategy(legs={}, conditions={})".format( + self.legs, self.conditions) diff --git a/backtester_demo.ipynb b/backtester_demo.ipynb new file mode 100644 index 0000000..6e1d9c7 --- /dev/null +++ b/backtester_demo.ipynb @@ -0,0 +1,1368 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "%config InlineBackend.figure_format=\"retina\"\n", + "%matplotlib inline\n", + "\n", + "import pandas as pd\n", + "import os\n", + "import matplotlib.pyplot as plt\n", + "from importlib import reload\n", + "plt.style.use(\"seaborn\")\n", + "plt.rcParams[\"figure.figsize\"] = (14, 8)" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [], + "source": [ + "from backtester.datahandler import HistoricalOptionsData\n", + "from backtester.strategy import Strategy, StrategyLeg\n", + "from backtester.option import Type, Direction\n", + "from backtester import Backtest" + ] + }, + { + "cell_type": "code", + "execution_count": 3, + "metadata": {}, + "outputs": [], + "source": [ + "# Original data\n", + "data = HistoricalOptionsData(\"allspx/options_data_v2_clean_compressed.h5\", key=\"/SPX\")\n", + "schema = data.schema" + ] + }, + { + "cell_type": "code", + "execution_count": 4, + "metadata": {}, + "outputs": [], + "source": [ + "# Cleaned up data\n", + "data = HistoricalOptionsData(\"allspx/options_data_v2_pruned_compressed.h5\", key=\"/SPX\")\n", + "schema = data.schema" + ] + }, + { + "cell_type": "code", + "execution_count": 5, + "metadata": {}, + "outputs": [], + "source": [ + "data._data = data._data[(data._data['quotedate'] >= '2006-12-06') & (data._data['quotedate'] <= '2015-08-21')]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We run the backtest on the date range above to compare with [this backtest.](http://dtr-trading.blogspot.com/p/spx-straddle-articles.html) We do the comparison with a [short (ATM) straddle](https://www.investopedia.com/terms/s/shortstraddle.asp) 45 DTE. Essentially the strategy consists of selling both a call and a put with (approximately) the same strike and expiration date, profiting if the underlying asset's price does not move very much. " + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "To run the backtest monthly, use the boolean parameter *monthly* on the *run* method (False by default)." + ] + }, + { + "cell_type": "code", + "execution_count": 6, + "metadata": {}, + "outputs": [], + "source": [ + "# Short ATM straddle\n", + "short_straddle = Strategy(schema)\n", + "\n", + "leg1 = StrategyLeg(\"leg_1\", schema, option_type=Type.CALL, direction=Direction.SELL)\n", + "leg1.entry_filter = (schema.underlying == \"SPX\") & (schema.dte >= 40) & (schema.dte <= 50) & (schema.strike >= schema.underlying_last * 0.95) & (schema.strike <= schema.underlying_last * 1.05)\n", + "\n", + "leg1.exit_filter = (schema.dte <= 2)\n", + "\n", + "leg2 = StrategyLeg(\"leg_2\", schema, option_type=Type.PUT, direction=Direction.SELL)\n", + "leg2.entry_filter = (schema.underlying == \"SPX\") & (schema.dte >= 40) & (schema.dte <= 50) & (schema.strike >= schema.underlying_last * 0.95) & (schema.strike <= schema.underlying_last * 1.05)\n", + "\n", + "leg2.exit_filter = (schema.dte <= 2)\n", + "\n", + "short_straddle.add_legs([leg1, leg2])\n", + "# Exit thresholds: we exit if the loss or profit on the investment on an entry is greater than 25%.\n", + "short_straddle.exit_thresholds = (0.25, 0.25)" + ] + }, + { + "cell_type": "code", + "execution_count": 7, + "metadata": {}, + "outputs": [], + "source": [ + "bt = Backtest(capital = 0)\n", + "bt.strategy = short_straddle\n", + "bt.data = data\n", + "bt.stop_if_broke = False" + ] + }, + { + "cell_type": "code", + "execution_count": 8, + "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", + "
leg_1leg_2totals
contractunderlyingexpirationtypestrikecostdateordercontractunderlyingexpirationtypestrikecostdateordercost
0SXZ070120C01480000SPX2007-01-20call1480.0-85.02006-12-06STOSXZ070120P01410000SPX2007-01-20put1410.0-1490.02006-12-06STO-1575.0
1SXZ070120C01480000SPX2007-01-20call1480.0125.02006-12-07BTCSXZ070120P01410000SPX2007-01-20put1410.01990.02006-12-07BTC2115.0
2SXZ070120C01475000SPX2007-01-20call1475.0-130.02006-12-07STOSXY070120P01395000SPX2007-01-20put1395.0-1380.02006-12-07STO-1510.0
3SXZ070120C01435000SPX2007-01-20call1435.0-980.02006-12-08STOSXY070120P01340000SPX2007-01-20put1340.0-430.02006-12-08STO-1410.0
4SXZ070120C01440000SPX2007-01-20call1440.0-870.02006-12-11STOSXY070120P01345000SPX2007-01-20put1345.0-350.02006-12-11STO-1220.0
......................................................
1336SPX150821C01975000SPX2015-08-21call1975.010390.02015-08-19BTCSPX150821P01975000SPX2015-08-21put1975.020.02015-08-19BTC10410.0
1337SPX150821C01965000SPX2015-08-21call1965.011390.02015-08-19BTCSPX150821P01965000SPX2015-08-21put1965.020.02015-08-19BTC11410.0
1338SPX150821C01980000SPX2015-08-21call1980.09890.02015-08-19BTCSPX150821P01980000SPX2015-08-21put1980.020.02015-08-19BTC9910.0
1339SPX150918C02005000SPX2015-09-18call2005.05680.02015-08-20BTCSPX150918P02015000SPX2015-09-18put2015.03460.02015-08-20BTC9140.0
1340SPX150918C02180000SPX2015-09-18call2180.060.02015-08-20BTCSPX150918P02205000SPX2015-09-18put2205.017780.02015-08-20BTC17840.0
\n", + "

1341 rows × 17 columns

\n", + "
" + ], + "text/plain": [ + " leg_1 \\\n", + " contract underlying expiration type strike cost \n", + "0 SXZ070120C01480000 SPX 2007-01-20 call 1480.0 -85.0 \n", + "1 SXZ070120C01480000 SPX 2007-01-20 call 1480.0 125.0 \n", + "2 SXZ070120C01475000 SPX 2007-01-20 call 1475.0 -130.0 \n", + "3 SXZ070120C01435000 SPX 2007-01-20 call 1435.0 -980.0 \n", + "4 SXZ070120C01440000 SPX 2007-01-20 call 1440.0 -870.0 \n", + "... ... ... ... ... ... ... \n", + "1336 SPX150821C01975000 SPX 2015-08-21 call 1975.0 10390.0 \n", + "1337 SPX150821C01965000 SPX 2015-08-21 call 1965.0 11390.0 \n", + "1338 SPX150821C01980000 SPX 2015-08-21 call 1980.0 9890.0 \n", + "1339 SPX150918C02005000 SPX 2015-09-18 call 2005.0 5680.0 \n", + "1340 SPX150918C02180000 SPX 2015-09-18 call 2180.0 60.0 \n", + "\n", + " leg_2 \\\n", + " date order contract underlying expiration type strike \n", + "0 2006-12-06 STO SXZ070120P01410000 SPX 2007-01-20 put 1410.0 \n", + "1 2006-12-07 BTC SXZ070120P01410000 SPX 2007-01-20 put 1410.0 \n", + "2 2006-12-07 STO SXY070120P01395000 SPX 2007-01-20 put 1395.0 \n", + "3 2006-12-08 STO SXY070120P01340000 SPX 2007-01-20 put 1340.0 \n", + "4 2006-12-11 STO SXY070120P01345000 SPX 2007-01-20 put 1345.0 \n", + "... ... ... ... ... ... ... ... \n", + "1336 2015-08-19 BTC SPX150821P01975000 SPX 2015-08-21 put 1975.0 \n", + "1337 2015-08-19 BTC SPX150821P01965000 SPX 2015-08-21 put 1965.0 \n", + "1338 2015-08-19 BTC SPX150821P01980000 SPX 2015-08-21 put 1980.0 \n", + "1339 2015-08-20 BTC SPX150918P02015000 SPX 2015-09-18 put 2015.0 \n", + "1340 2015-08-20 BTC SPX150918P02205000 SPX 2015-09-18 put 2205.0 \n", + "\n", + " totals \n", + " cost date order cost \n", + "0 -1490.0 2006-12-06 STO -1575.0 \n", + "1 1990.0 2006-12-07 BTC 2115.0 \n", + "2 -1380.0 2006-12-07 STO -1510.0 \n", + "3 -430.0 2006-12-08 STO -1410.0 \n", + "4 -350.0 2006-12-11 STO -1220.0 \n", + "... ... ... ... ... \n", + "1336 20.0 2015-08-19 BTC 10410.0 \n", + "1337 20.0 2015-08-19 BTC 11410.0 \n", + "1338 20.0 2015-08-19 BTC 9910.0 \n", + "1339 3460.0 2015-08-20 BTC 9140.0 \n", + "1340 17780.0 2015-08-20 BTC 17840.0 \n", + "\n", + "[1341 rows x 17 columns]" + ] + }, + "execution_count": 8, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bt.run(monthly=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 9, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "/Users/jrchatruc/anaconda3/lib/python3.7/site-packages/pandas/plotting/_matplotlib/converter.py:103: FutureWarning: Using an implicitly registered datetime converter for a matplotlib plotting method. The converter was registered by pandas on import. Future versions of pandas will require you to explicitly register matplotlib converters.\n", + "\n", + "To register the converters:\n", + "\t>>> from pandas.plotting import register_matplotlib_converters\n", + "\t>>> register_matplotlib_converters()\n", + " warnings.warn(msg, FutureWarning)\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 251, + "width": 398 + }, + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "capital = (-bt.trade_log['totals']['cost']).cumsum()\n", + "date = bt.trade_log['leg_1']['date']\n", + "plt.plot(date, capital);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "We now run a [long (ATM) straddle](https://www.investopedia.com/terms/l/longstraddle.asp) 45 DTE. This is the opposite of the previous strategy, where we enter buying the contracts instead of selling, and therefore profit from big movements in the underlying asset's price. " + ] + }, + { + "cell_type": "code", + "execution_count": 10, + "metadata": {}, + "outputs": [], + "source": [ + "# Long (ATM) straddle\n", + "long_straddle = Strategy(schema)\n", + "\n", + "leg1 = StrategyLeg(\"leg_1\", schema, option_type=Type.CALL, direction=Direction.BUY)\n", + "leg1.entry_filter = (schema.underlying == \"SPX\") & (schema.dte >= 40) & (schema.dte <= 50) & (schema.strike <= schema.underlying_last * 1.05) & (schema.strike >= schema.underlying_last * 0.95)\n", + "leg1.exit_filter = (schema.dte <= 2)\n", + "\n", + "leg2 = StrategyLeg(\"leg_2\", schema, option_type=Type.PUT, direction=Direction.BUY)\n", + "leg2.entry_filter = (schema.underlying == \"SPX\") & (schema.dte >= 40) & (schema.dte <= 50) & (schema.strike <= schema.underlying_last * 1.05) & (schema.strike >= schema.underlying_last * 0.95)\n", + "leg2.exit_filter = (schema.dte <= 2)\n", + "\n", + "long_straddle.add_legs([leg1, leg2])\n", + "long_straddle.add_condition(['strike'])\n", + "long_straddle.exit_thresholds = (0.25, 0.25)" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, + "outputs": [], + "source": [ + "bt = Backtest(capital = 0)\n", + "bt.strategy = long_straddle\n", + "bt.data = data\n", + "bt.stop_if_broke = False" + ] + }, + { + "cell_type": "code", + "execution_count": 12, + "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", + "
leg_1leg_2totals
contractcostdateexpirationorderstriketypeunderlyingcontractcostdateexpirationorderstriketypeunderlyingcost
0SXZ070120C014350001230.02006-12-062007-01-20BTO1435.0callSPXSXZ070120P014350002720.02006-12-062007-01-20BTO1435.0putSPX3950.0
1SXZ070120C01440000930.02006-12-072007-01-20BTO1440.0callSPXSXZ070120P014400003520.02006-12-072007-01-20BTO1440.0putSPX4450.0
2SXZ070120C01450000570.02006-12-082007-01-20BTO1450.0callSPXSXZ070120P014500004060.02006-12-082007-01-20BTO1450.0putSPX4630.0
3SXZ070120C01465000280.02006-12-112007-01-20BTO1465.0callSPXSXZ070120P014650004800.02006-12-112007-01-20BTO1465.0putSPX5080.0
4SXZ070120C01435000-1220.02006-12-142007-01-20STC1435.0callSPXSXZ070120P01435000-1690.02006-12-142007-01-20STC1435.0putSPX-2910.0
......................................................
1273SPX150918C02115000-410.02015-08-202015-09-18STC2115.0callSPXSPX150918P02115000-8650.02015-08-202015-09-18STC2115.0putSPX-9060.0
1274SPX150918C02125000-255.02015-08-202015-09-18STC2125.0callSPXSPX150918P02125000-9500.02015-08-202015-09-18STC2125.0putSPX-9755.0
1275SPX150918C02100000-260.02015-08-212015-09-18STC2100.0callSPXSPX150918P02100000-12820.02015-08-212015-09-18STC2100.0putSPX-13080.0
1276SPX150918C02105000-210.02015-08-212015-09-18STC2105.0callSPXSPX150918P02105000-13270.02015-08-212015-09-18STC2105.0putSPX-13480.0
1277SPX150918C02095000-300.02015-08-212015-09-18STC2095.0callSPXSPX150918P02095000-12380.02015-08-212015-09-18STC2095.0putSPX-12680.0
\n", + "

1278 rows × 17 columns

\n", + "
" + ], + "text/plain": [ + " leg_1 \\\n", + " contract cost date expiration order strike type \n", + "0 SXZ070120C01435000 1230.0 2006-12-06 2007-01-20 BTO 1435.0 call \n", + "1 SXZ070120C01440000 930.0 2006-12-07 2007-01-20 BTO 1440.0 call \n", + "2 SXZ070120C01450000 570.0 2006-12-08 2007-01-20 BTO 1450.0 call \n", + "3 SXZ070120C01465000 280.0 2006-12-11 2007-01-20 BTO 1465.0 call \n", + "4 SXZ070120C01435000 -1220.0 2006-12-14 2007-01-20 STC 1435.0 call \n", + "... ... ... ... ... ... ... ... \n", + "1273 SPX150918C02115000 -410.0 2015-08-20 2015-09-18 STC 2115.0 call \n", + "1274 SPX150918C02125000 -255.0 2015-08-20 2015-09-18 STC 2125.0 call \n", + "1275 SPX150918C02100000 -260.0 2015-08-21 2015-09-18 STC 2100.0 call \n", + "1276 SPX150918C02105000 -210.0 2015-08-21 2015-09-18 STC 2105.0 call \n", + "1277 SPX150918C02095000 -300.0 2015-08-21 2015-09-18 STC 2095.0 call \n", + "\n", + " leg_2 \\\n", + " underlying contract cost date expiration order \n", + "0 SPX SXZ070120P01435000 2720.0 2006-12-06 2007-01-20 BTO \n", + "1 SPX SXZ070120P01440000 3520.0 2006-12-07 2007-01-20 BTO \n", + "2 SPX SXZ070120P01450000 4060.0 2006-12-08 2007-01-20 BTO \n", + "3 SPX SXZ070120P01465000 4800.0 2006-12-11 2007-01-20 BTO \n", + "4 SPX SXZ070120P01435000 -1690.0 2006-12-14 2007-01-20 STC \n", + "... ... ... ... ... ... ... \n", + "1273 SPX SPX150918P02115000 -8650.0 2015-08-20 2015-09-18 STC \n", + "1274 SPX SPX150918P02125000 -9500.0 2015-08-20 2015-09-18 STC \n", + "1275 SPX SPX150918P02100000 -12820.0 2015-08-21 2015-09-18 STC \n", + "1276 SPX SPX150918P02105000 -13270.0 2015-08-21 2015-09-18 STC \n", + "1277 SPX SPX150918P02095000 -12380.0 2015-08-21 2015-09-18 STC \n", + "\n", + " totals \n", + " strike type underlying cost \n", + "0 1435.0 put SPX 3950.0 \n", + "1 1440.0 put SPX 4450.0 \n", + "2 1450.0 put SPX 4630.0 \n", + "3 1465.0 put SPX 5080.0 \n", + "4 1435.0 put SPX -2910.0 \n", + "... ... ... ... ... \n", + "1273 2115.0 put SPX -9060.0 \n", + "1274 2125.0 put SPX -9755.0 \n", + "1275 2100.0 put SPX -13080.0 \n", + "1276 2105.0 put SPX -13480.0 \n", + "1277 2095.0 put SPX -12680.0 \n", + "\n", + "[1278 rows x 17 columns]" + ] + }, + "execution_count": 12, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bt.run(monthly=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 248, + "width": 404 + }, + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "capital = (-bt.trade_log['totals']['cost']).cumsum()\n", + "date = bt.trade_log['leg_1']['date']\n", + "plt.plot(date, capital);" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Finally we run an [iron condor](https://www.investopedia.com/terms/i/ironcondor.asp)." + ] + }, + { + "cell_type": "code", + "execution_count": 14, + "metadata": {}, + "outputs": [], + "source": [ + "# Iron Condor\n", + "iron_condor = Strategy(schema)\n", + "\n", + "leg1 = StrategyLeg(\"leg_1\", schema, option_type=Type.PUT, direction=Direction.BUY)\n", + "leg1.entry_filter = (schema.underlying == \"SPX\") & (schema.dte >= 40) & (schema.dte <= 50) & (schema.strike <= 0.85 * schema.underlying_last)\n", + "leg1.exit_filter = (schema.dte <= 2)\n", + "\n", + "leg2 = StrategyLeg(\"leg_2\", schema, option_type=Type.PUT, direction=Direction.SELL)\n", + "leg2.entry_filter = (schema.underlying == \"SPX\") & (schema.dte >= 40) & (schema.dte <= 50) & (schema.strike >= 0.90 * schema.underlying_last) & (schema.strike <= schema.underlying_last)\n", + "leg2.exit_filter = (schema.dte <= 2)\n", + "\n", + "leg3 = StrategyLeg(\"leg_3\", schema, option_type=Type.CALL, direction=Direction.SELL)\n", + "leg3.entry_filter = (schema.underlying == \"SPX\") & (schema.dte >= 40) & (schema.dte <= 50) & (schema.strike >= schema.underlying_last) & (schema.strike <= 1.10 * schema.underlying_last)\n", + "leg3.exit_filter = (schema.dte <= 2)\n", + "\n", + "leg4 = StrategyLeg(\"leg_4\", schema, option_type=Type.PUT, direction=Direction.BUY)\n", + "leg4.entry_filter = (schema.underlying == \"SPX\") & (schema.dte >= 40) & (schema.dte <= 50) & (schema.strike >= 1.15 * schema.underlying_last)\n", + "leg4.exit_filter = (schema.dte <= 2)\n", + "\n", + "\n", + "iron_condor.add_legs([leg1, leg2, leg3, leg4])\n", + "iron_condor.exit_thresholds = (0.25, 0.25)" + ] + }, + { + "cell_type": "code", + "execution_count": 15, + "metadata": {}, + "outputs": [], + "source": [ + "bt = Backtest()\n", + "bt.strategy = iron_condor\n", + "bt.data = data\n", + "bt.stop_if_broke = False" + ] + }, + { + "cell_type": "code", + "execution_count": 16, + "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", + "
leg_1leg_2...leg_3leg_4totals
contractunderlyingexpirationtypestrikecostdateordercontractunderlying...ordercontractunderlyingexpirationtypestrikecostdateordercost
0SPV090117P00200000SPX2009-01-17put200.035.02008-12-01BTOSPZ090117P00740000SPX...STOSXB090117P00940000SPX2009-01-17put940.014740.02008-12-01BTO5325.0
1SPV090117P00200000SPX2009-01-17put200.0-0.02008-12-02STCSPZ090117P00740000SPX...BTCSXB090117P00940000SPX2009-01-17put940.0-11750.02008-12-02STC-1520.0
2SPV090117P00300000SPX2009-01-17put300.040.02008-12-02BTOSPZ090117P00765000SPX...STOSXB090117P00980000SPX2009-01-17put980.014870.02008-12-02BTO4830.0
3SPV090117P00300000SPX2009-01-17put300.0-5.02008-12-03STCSPZ090117P00765000SPX...BTCSXB090117P00980000SPX2009-01-17put980.0-13250.02008-12-03STC-2315.0
4SPV090117P00200000SPX2009-01-17put200.040.02008-12-04BTOSPZ090117P00765000SPX...STOSXB090117P00975000SPX2009-01-17put975.014870.02008-12-04BTO4880.0
..................................................................
546SPX150821P00800000SPX2015-08-21put800.0-0.02015-08-19STCSPX150821P01845000SPX...BTCSPX150821P02600000SPX2015-08-21put2600.0-52120.02015-08-19STC-49045.0
547SPX150918P00500000SPX2015-09-18put500.0-0.02015-08-20STCSPX150918P01900000SPX...BTCSPX150918P02450000SPX2015-09-18put2450.0-41660.02015-08-20STC-39960.0
548SPX150918P00600000SPX2015-09-18put600.0-0.02015-08-21STCSPX150918P01895000SPX...BTCSPX150918P02500000SPX2015-09-18put2500.0-52480.02015-08-21STC-49100.0
549SPX150918P00700000SPX2015-09-18put700.0-0.02015-08-21STCSPX150918P01890000SPX...BTCSPX150918P02550000SPX2015-09-18put2550.0-57480.02015-08-21STC-54100.0
550SPX150918P00825000SPX2015-09-18put825.0-0.02015-08-21STCSPX150918P01880000SPX...BTCSPX150918P02400000SPX2015-09-18put2400.0-42490.02015-08-21STC-39160.0
\n", + "

551 rows × 33 columns

\n", + "
" + ], + "text/plain": [ + " leg_1 \\\n", + " contract underlying expiration type strike cost date \n", + "0 SPV090117P00200000 SPX 2009-01-17 put 200.0 35.0 2008-12-01 \n", + "1 SPV090117P00200000 SPX 2009-01-17 put 200.0 -0.0 2008-12-02 \n", + "2 SPV090117P00300000 SPX 2009-01-17 put 300.0 40.0 2008-12-02 \n", + "3 SPV090117P00300000 SPX 2009-01-17 put 300.0 -5.0 2008-12-03 \n", + "4 SPV090117P00200000 SPX 2009-01-17 put 200.0 40.0 2008-12-04 \n", + ".. ... ... ... ... ... ... ... \n", + "546 SPX150821P00800000 SPX 2015-08-21 put 800.0 -0.0 2015-08-19 \n", + "547 SPX150918P00500000 SPX 2015-09-18 put 500.0 -0.0 2015-08-20 \n", + "548 SPX150918P00600000 SPX 2015-09-18 put 600.0 -0.0 2015-08-21 \n", + "549 SPX150918P00700000 SPX 2015-09-18 put 700.0 -0.0 2015-08-21 \n", + "550 SPX150918P00825000 SPX 2015-09-18 put 825.0 -0.0 2015-08-21 \n", + "\n", + " leg_2 ... leg_3 leg_4 \\\n", + " order contract underlying ... order contract \n", + "0 BTO SPZ090117P00740000 SPX ... STO SXB090117P00940000 \n", + "1 STC SPZ090117P00740000 SPX ... BTC SXB090117P00940000 \n", + "2 BTO SPZ090117P00765000 SPX ... STO SXB090117P00980000 \n", + "3 STC SPZ090117P00765000 SPX ... BTC SXB090117P00980000 \n", + "4 BTO SPZ090117P00765000 SPX ... STO SXB090117P00975000 \n", + ".. ... ... ... ... ... ... \n", + "546 STC SPX150821P01845000 SPX ... BTC SPX150821P02600000 \n", + "547 STC SPX150918P01900000 SPX ... BTC SPX150918P02450000 \n", + "548 STC SPX150918P01895000 SPX ... BTC SPX150918P02500000 \n", + "549 STC SPX150918P01890000 SPX ... BTC SPX150918P02550000 \n", + "550 STC SPX150918P01880000 SPX ... BTC SPX150918P02400000 \n", + "\n", + " totals \n", + " underlying expiration type strike cost date order cost \n", + "0 SPX 2009-01-17 put 940.0 14740.0 2008-12-01 BTO 5325.0 \n", + "1 SPX 2009-01-17 put 940.0 -11750.0 2008-12-02 STC -1520.0 \n", + "2 SPX 2009-01-17 put 980.0 14870.0 2008-12-02 BTO 4830.0 \n", + "3 SPX 2009-01-17 put 980.0 -13250.0 2008-12-03 STC -2315.0 \n", + "4 SPX 2009-01-17 put 975.0 14870.0 2008-12-04 BTO 4880.0 \n", + ".. ... ... ... ... ... ... ... ... \n", + "546 SPX 2015-08-21 put 2600.0 -52120.0 2015-08-19 STC -49045.0 \n", + "547 SPX 2015-09-18 put 2450.0 -41660.0 2015-08-20 STC -39960.0 \n", + "548 SPX 2015-09-18 put 2500.0 -52480.0 2015-08-21 STC -49100.0 \n", + "549 SPX 2015-09-18 put 2550.0 -57480.0 2015-08-21 STC -54100.0 \n", + "550 SPX 2015-09-18 put 2400.0 -42490.0 2015-08-21 STC -39160.0 \n", + "\n", + "[551 rows x 33 columns]" + ] + }, + "execution_count": 16, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "bt.run(monthly=False)" + ] + }, + { + "cell_type": "code", + "execution_count": 17, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "image/png": { + "height": 248, + "width": 400 + }, + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "capital = (-bt.trade_log['totals']['cost']).cumsum()\n", + "date = bt.trade_log['leg_1']['date']\n", + "plt.plot(date, capital);" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +} diff --git a/data_cleanup.ipynb b/data_cleanup.ipynb new file mode 100644 index 0000000..20f454e --- /dev/null +++ b/data_cleanup.ipynb @@ -0,0 +1,2638 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 77, + "metadata": {}, + "outputs": [], + "source": [ + "import pandas as pd\n", + "import os\n", + "from backtester.datahandler import HistoricalOptionsData" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Our data has some zero values and missing entries that are inaccurate and could throw off our backtester, giving misleading results. We perform here a cleanup of the data." + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "store_path = os.path.join(\"/Users/jrchatruc/Documents/backtester_options/allspx/\", \"options_data_v2_light.h5\")\n", + "store = pd.HDFStore(store_path, complevel=9, complib=\"blosc\", fletcher32=True)\n", + "underlying_dtype = pd.api.types.CategoricalDtype(\n", + " categories=['SPX', 'SPXW', 'SPXPM'])\n", + "\n", + "offset = 0\n", + "sizes = {\"optionroot\": 20, \"optionalias\": 20}\n", + "for year in range(1990, 2019):\n", + " filename = \"SPX_{}.csv\".format(year)\n", + " year_df = pd.read_csv(os.path.join(\"/Users/jrchatruc/Documents/backtester_options/allspx/\", filename),\n", + " parse_dates=[\"expiration\", \"quotedate\"])\n", + " year_df.rename(columns={\" exchange\": \"exchange\"}, inplace=True)\n", + " year_df = year_df.astype({\"strike\": \"float\", \"optionalias\": \"object\", \"type\": \"category\",\n", + " 'underlying': underlying_dtype})\n", + " year_df = year_df.drop('optionext', axis=1)\n", + " year_df = year_df.drop('exchange', axis=1)\n", + " year_df = year_df.reset_index(drop=True)\n", + " year_df.index += offset\n", + " offset += len(year_df)\n", + " store.append(\"/SPX\", year_df, index=False, data_columns=True, min_itemsize=sizes)\n", + " print(year)" + ] + }, + { + "cell_type": "code", + "execution_count": 79, + "metadata": {}, + "outputs": [], + "source": [ + "store.close()" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "%cd -q /Users/jrchatruc/Documents/backtester_options/allspx\n", + "!ptrepack --complevel=9 --complib=blosc options_data_v2_light.h5 options_data_v2_light_compressed.h5" + ] + }, + { + "cell_type": "code", + "execution_count": 95, + "metadata": {}, + "outputs": [], + "source": [ + "data = HistoricalOptionsData(\"options_data_v2_light_compressed.h5\", key=\"/SPX\")\n", + "schema = data.schema\n", + "df = data._data" + ] + }, + { + "cell_type": "code", + "execution_count": 96, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(16756680, 19)" + ] + }, + "execution_count": 96, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 97, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.065681208926828" + ] + }, + "execution_count": 97, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df[(df['bid'] == 0) & (df['ask'] == 0)].shape[0] / df.shape[0]" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "As can be seen, around $6.5\\%$ of the rows have both their bid and ask equal to zero. Some of these are because these values are going progressively down until they reach around $0.1$ or $0.05$, at which point they (sometimes) get replaced with zero. This isn't a problematic case, but it is not the only one." + ] + }, + { + "cell_type": "code", + "execution_count": 98, + "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", + "
underlyingunderlying_lastoptionroottypeexpirationquotedatestrikelastbidaskvolumeopeninterestimpliedvoldeltagammathetavegaoptionaliasdte
13359109SPX2276.98SPX191220P00100000put2019-12-202017-01-06100.00.150.100.15207730.31850.00000.00.00000.0000SPX191220P001000001078
13388755SPX2275.32SPX191220P00100000put2019-12-202017-01-11100.00.150.100.1507830.5958-0.00020.0-0.24542.4561SPX191220P001000001073
13400173SPX2270.44SPX191220P00100000put2019-12-202017-01-12100.00.150.100.1517830.5940-0.00020.0-0.24662.4588SPX191220P001000001072
13411669SPX2274.64SPX191220P00100000put2019-12-202017-01-13100.00.110.100.1507850.5963-0.00020.0-0.24582.4539SPX191220P001000001071
13423111SPX2267.89SPX191220P00100000put2019-12-202017-01-17100.00.100.100.1508050.5986-0.00020.0-0.24532.4442SPX191220P001000001067
............................................................
16740413SPX2351.10SPX191220P00100000put2019-12-212018-12-24100.00.050.050.10530145410.35000.00000.00.00000.0000NaN362
16744107SPX2467.70SPX191220P00100000put2019-12-212018-12-26100.00.050.000.100150590.32190.00000.00.00000.0000NaN360
16747947SPX2488.83SPX191220P00100000put2019-12-212018-12-27100.00.050.000.050150590.33140.00000.00.00000.0000NaN359
16751791SPX2485.74SPX191220P00100000put2019-12-212018-12-28100.00.050.000.05500150590.32560.00000.00.00000.0000NaN358
16755635SPX2506.85SPX191220P00100000put2019-12-212018-12-31100.00.050.000.051100155590.31880.00000.00.00000.0000NaN355
\n", + "

497 rows × 19 columns

\n", + "
" + ], + "text/plain": [ + " underlying underlying_last optionroot type expiration \\\n", + "13359109 SPX 2276.98 SPX191220P00100000 put 2019-12-20 \n", + "13388755 SPX 2275.32 SPX191220P00100000 put 2019-12-20 \n", + "13400173 SPX 2270.44 SPX191220P00100000 put 2019-12-20 \n", + "13411669 SPX 2274.64 SPX191220P00100000 put 2019-12-20 \n", + "13423111 SPX 2267.89 SPX191220P00100000 put 2019-12-20 \n", + "... ... ... ... ... ... \n", + "16740413 SPX 2351.10 SPX191220P00100000 put 2019-12-21 \n", + "16744107 SPX 2467.70 SPX191220P00100000 put 2019-12-21 \n", + "16747947 SPX 2488.83 SPX191220P00100000 put 2019-12-21 \n", + "16751791 SPX 2485.74 SPX191220P00100000 put 2019-12-21 \n", + "16755635 SPX 2506.85 SPX191220P00100000 put 2019-12-21 \n", + "\n", + " quotedate strike last bid ask volume openinterest \\\n", + "13359109 2017-01-06 100.0 0.15 0.10 0.15 20 773 \n", + "13388755 2017-01-11 100.0 0.15 0.10 0.15 0 783 \n", + "13400173 2017-01-12 100.0 0.15 0.10 0.15 1 783 \n", + "13411669 2017-01-13 100.0 0.11 0.10 0.15 0 785 \n", + "13423111 2017-01-17 100.0 0.10 0.10 0.15 0 805 \n", + "... ... ... ... ... ... ... ... \n", + "16740413 2018-12-24 100.0 0.05 0.05 0.10 530 14541 \n", + "16744107 2018-12-26 100.0 0.05 0.00 0.10 0 15059 \n", + "16747947 2018-12-27 100.0 0.05 0.00 0.05 0 15059 \n", + "16751791 2018-12-28 100.0 0.05 0.00 0.05 500 15059 \n", + "16755635 2018-12-31 100.0 0.05 0.00 0.05 1100 15559 \n", + "\n", + " impliedvol delta gamma theta vega optionalias dte \n", + "13359109 0.3185 0.0000 0.0 0.0000 0.0000 SPX191220P00100000 1078 \n", + "13388755 0.5958 -0.0002 0.0 -0.2454 2.4561 SPX191220P00100000 1073 \n", + "13400173 0.5940 -0.0002 0.0 -0.2466 2.4588 SPX191220P00100000 1072 \n", + "13411669 0.5963 -0.0002 0.0 -0.2458 2.4539 SPX191220P00100000 1071 \n", + "13423111 0.5986 -0.0002 0.0 -0.2453 2.4442 SPX191220P00100000 1067 \n", + "... ... ... ... ... ... ... ... \n", + "16740413 0.3500 0.0000 0.0 0.0000 0.0000 NaN 362 \n", + "16744107 0.3219 0.0000 0.0 0.0000 0.0000 NaN 360 \n", + "16747947 0.3314 0.0000 0.0 0.0000 0.0000 NaN 359 \n", + "16751791 0.3256 0.0000 0.0 0.0000 0.0000 NaN 358 \n", + "16755635 0.3188 0.0000 0.0 0.0000 0.0000 NaN 355 \n", + "\n", + "[497 rows x 19 columns]" + ] + }, + "execution_count": 98, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "# A (mostly) innocuous contract, its bid and ask values are always very close to zero, so them dipping into zero\n", + "# is not a problem.\n", + "df[df['optionroot'] == 'SPX191220P00100000']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "This next contract, however, is a problem. On first inspection it looks fine, but it actually contains a lot of zero values intermingled." + ] + }, + { + "cell_type": "code", + "execution_count": 99, + "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", + "
underlyingunderlying_lastoptionroottypeexpirationquotedatestrikelastbidaskvolumeopeninterestimpliedvoldeltagammathetavegaoptionaliasdte
144SPX359.69SPX910622C00300000call1991-06-221990-01-02300.00.094.394.3000.00000.00000.00000.00000.0000SPX910622C00300000536
314SPX358.76SPX910622C00300000call1991-06-221990-01-03300.00.093.393.3000.00000.00000.00000.00000.0000SPX910622C00300000535
484SPX355.66SPX910622C00300000call1991-06-221990-01-04300.00.090.290.2000.00000.00000.00000.00000.0000SPX910622C00300000534
654SPX352.20SPX910622C00300000call1991-06-221990-01-05300.00.086.686.6000.00000.00000.00000.00000.0000SPX910622C00300000533
824SPX353.79SPX910622C00300000call1991-06-221990-01-08300.00.088.188.1000.00000.00000.00000.00000.0000SPX910622C00300000530
............................................................
68132SPX380.13SPX910622C00300000call1991-06-221991-06-17300.081.580.480.9137281.05310.98320.0010-0.24420.0173SPX910622C003000005
68330SPX378.59SPX910622C00300000call1991-06-221991-06-18300.00.078.579.0037271.44220.96080.0016-0.69670.0307SPX910622C003000004
68528SPX375.09SPX910622C00300000call1991-06-221991-06-19300.075.575.076.075637271.66340.95980.0017-0.95830.0260SPX910622C003000003
68726SPX375.42SPX910622C00300000call1991-06-221991-06-20300.00.075.076.0035571.81060.98240.0011-0.70400.0099SPX910622C003000002
68924SPX377.75SPX910622C00300000call1991-06-221991-06-21300.076.077.578.513235573.95470.97660.0012-3.77580.0063SPX910622C003000001
\n", + "

373 rows × 19 columns

\n", + "
" + ], + "text/plain": [ + " underlying underlying_last optionroot type expiration \\\n", + "144 SPX 359.69 SPX910622C00300000 call 1991-06-22 \n", + "314 SPX 358.76 SPX910622C00300000 call 1991-06-22 \n", + "484 SPX 355.66 SPX910622C00300000 call 1991-06-22 \n", + "654 SPX 352.20 SPX910622C00300000 call 1991-06-22 \n", + "824 SPX 353.79 SPX910622C00300000 call 1991-06-22 \n", + "... ... ... ... ... ... \n", + "68132 SPX 380.13 SPX910622C00300000 call 1991-06-22 \n", + "68330 SPX 378.59 SPX910622C00300000 call 1991-06-22 \n", + "68528 SPX 375.09 SPX910622C00300000 call 1991-06-22 \n", + "68726 SPX 375.42 SPX910622C00300000 call 1991-06-22 \n", + "68924 SPX 377.75 SPX910622C00300000 call 1991-06-22 \n", + "\n", + " quotedate strike last bid ask volume openinterest impliedvol \\\n", + "144 1990-01-02 300.0 0.0 94.3 94.3 0 0 0.0000 \n", + "314 1990-01-03 300.0 0.0 93.3 93.3 0 0 0.0000 \n", + "484 1990-01-04 300.0 0.0 90.2 90.2 0 0 0.0000 \n", + "654 1990-01-05 300.0 0.0 86.6 86.6 0 0 0.0000 \n", + "824 1990-01-08 300.0 0.0 88.1 88.1 0 0 0.0000 \n", + "... ... ... ... ... ... ... ... ... \n", + "68132 1991-06-17 300.0 81.5 80.4 80.9 1 3728 1.0531 \n", + "68330 1991-06-18 300.0 0.0 78.5 79.0 0 3727 1.4422 \n", + "68528 1991-06-19 300.0 75.5 75.0 76.0 756 3727 1.6634 \n", + "68726 1991-06-20 300.0 0.0 75.0 76.0 0 3557 1.8106 \n", + "68924 1991-06-21 300.0 76.0 77.5 78.5 132 3557 3.9547 \n", + "\n", + " delta gamma theta vega optionalias dte \n", + "144 0.0000 0.0000 0.0000 0.0000 SPX910622C00300000 536 \n", + "314 0.0000 0.0000 0.0000 0.0000 SPX910622C00300000 535 \n", + "484 0.0000 0.0000 0.0000 0.0000 SPX910622C00300000 534 \n", + "654 0.0000 0.0000 0.0000 0.0000 SPX910622C00300000 533 \n", + "824 0.0000 0.0000 0.0000 0.0000 SPX910622C00300000 530 \n", + "... ... ... ... ... ... ... \n", + "68132 0.9832 0.0010 -0.2442 0.0173 SPX910622C00300000 5 \n", + "68330 0.9608 0.0016 -0.6967 0.0307 SPX910622C00300000 4 \n", + "68528 0.9598 0.0017 -0.9583 0.0260 SPX910622C00300000 3 \n", + "68726 0.9824 0.0011 -0.7040 0.0099 SPX910622C00300000 2 \n", + "68924 0.9766 0.0012 -3.7758 0.0063 SPX910622C00300000 1 \n", + "\n", + "[373 rows x 19 columns]" + ] + }, + "execution_count": 99, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "problematic = df[df['optionroot'] == 'SPX910622C00300000']\n", + "problematic" + ] + }, + { + "cell_type": "code", + "execution_count": 100, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
underlyingunderlying_lastoptionroottypeexpirationquotedatestrikelastbidaskvolumeopeninterestimpliedvoldeltagammathetavegaoptionaliasdte
824SPX353.79SPX910622C00300000call1991-06-221990-01-08300.00.088.188.1000.00000.00000.00000.00000.0000SPX910622C00300000530
994SPX349.62SPX910622C00300000call1991-06-221990-01-09300.00.083.883.8000.00000.00000.00000.00000.0000SPX910622C00300000529
1164SPX347.31SPX910622C00300000call1991-06-221990-01-10300.00.081.481.4000.00000.00000.00000.00000.0000SPX910622C00300000528
1334SPX348.53SPX910622C00300000call1991-06-221990-01-11300.00.082.682.6000.00000.00000.00000.00000.0000SPX910622C00300000527
1504SPX339.93SPX910622C00300000call1991-06-221990-01-12300.00.00.00.0000.00000.00000.00000.00000.0000SPX910622C00300000526
1674SPX337.00SPX910622C00300000call1991-06-221990-01-15300.00.070.870.8000.00000.00000.00000.00000.0000SPX910622C00300000523
1844SPX340.75SPX910622C00300000call1991-06-221990-01-16300.00.074.574.5000.00000.00000.00000.00000.0000SPX910622C00300000522
2026SPX337.40SPX910622C00300000call1991-06-221990-01-17300.00.071.171.1000.00000.00000.00000.00000.0000SPX910622C00300000521
2208SPX338.19SPX910622C00300000call1991-06-221990-01-18300.00.00.00.0000.00000.00000.00000.00000.0000SPX910622C00300000520
2391SPX339.15SPX910622C00300000call1991-06-221990-01-19300.00.00.00.0000.00000.00000.00000.00000.0000SPX910622C00300000519
2548SPX330.38SPX910622C00300000call1991-06-221990-01-22300.00.063.864.5000.09260.97760.0015-22.362820.9095SPX910622C00300000516
2705SPX331.61SPX910622C00300000call1991-06-221990-01-23300.00.065.065.5000.09040.98160.0013-22.365817.7692SPX910622C00300000515
2862SPX330.26SPX910622C00300000call1991-06-221990-01-24300.00.063.564.2000.08960.98060.0013-22.363618.4703SPX910622C00300000514
3022SPX326.08SPX910622C00300000call1991-06-221990-01-25300.00.00.059.7000.00000.00000.00000.00000.0000SPX910622C00300000513
3182SPX325.80SPX910622C00300000call1991-06-221990-01-26300.00.059.059.7000.08870.97470.0017-22.345722.7432SPX910622C00300000512
3344SPX325.20SPX910622C00300000call1991-06-221990-01-29300.00.058.259.3000.09570.96440.0021-22.376930.0972SPX910622C00300000509
\n", + "
" + ], + "text/plain": [ + " underlying underlying_last optionroot type expiration \\\n", + "824 SPX 353.79 SPX910622C00300000 call 1991-06-22 \n", + "994 SPX 349.62 SPX910622C00300000 call 1991-06-22 \n", + "1164 SPX 347.31 SPX910622C00300000 call 1991-06-22 \n", + "1334 SPX 348.53 SPX910622C00300000 call 1991-06-22 \n", + "1504 SPX 339.93 SPX910622C00300000 call 1991-06-22 \n", + "1674 SPX 337.00 SPX910622C00300000 call 1991-06-22 \n", + "1844 SPX 340.75 SPX910622C00300000 call 1991-06-22 \n", + "2026 SPX 337.40 SPX910622C00300000 call 1991-06-22 \n", + "2208 SPX 338.19 SPX910622C00300000 call 1991-06-22 \n", + "2391 SPX 339.15 SPX910622C00300000 call 1991-06-22 \n", + "2548 SPX 330.38 SPX910622C00300000 call 1991-06-22 \n", + "2705 SPX 331.61 SPX910622C00300000 call 1991-06-22 \n", + "2862 SPX 330.26 SPX910622C00300000 call 1991-06-22 \n", + "3022 SPX 326.08 SPX910622C00300000 call 1991-06-22 \n", + "3182 SPX 325.80 SPX910622C00300000 call 1991-06-22 \n", + "3344 SPX 325.20 SPX910622C00300000 call 1991-06-22 \n", + "\n", + " quotedate strike last bid ask volume openinterest impliedvol \\\n", + "824 1990-01-08 300.0 0.0 88.1 88.1 0 0 0.0000 \n", + "994 1990-01-09 300.0 0.0 83.8 83.8 0 0 0.0000 \n", + "1164 1990-01-10 300.0 0.0 81.4 81.4 0 0 0.0000 \n", + "1334 1990-01-11 300.0 0.0 82.6 82.6 0 0 0.0000 \n", + "1504 1990-01-12 300.0 0.0 0.0 0.0 0 0 0.0000 \n", + "1674 1990-01-15 300.0 0.0 70.8 70.8 0 0 0.0000 \n", + "1844 1990-01-16 300.0 0.0 74.5 74.5 0 0 0.0000 \n", + "2026 1990-01-17 300.0 0.0 71.1 71.1 0 0 0.0000 \n", + "2208 1990-01-18 300.0 0.0 0.0 0.0 0 0 0.0000 \n", + "2391 1990-01-19 300.0 0.0 0.0 0.0 0 0 0.0000 \n", + "2548 1990-01-22 300.0 0.0 63.8 64.5 0 0 0.0926 \n", + "2705 1990-01-23 300.0 0.0 65.0 65.5 0 0 0.0904 \n", + "2862 1990-01-24 300.0 0.0 63.5 64.2 0 0 0.0896 \n", + "3022 1990-01-25 300.0 0.0 0.0 59.7 0 0 0.0000 \n", + "3182 1990-01-26 300.0 0.0 59.0 59.7 0 0 0.0887 \n", + "3344 1990-01-29 300.0 0.0 58.2 59.3 0 0 0.0957 \n", + "\n", + " delta gamma theta vega optionalias dte \n", + "824 0.0000 0.0000 0.0000 0.0000 SPX910622C00300000 530 \n", + "994 0.0000 0.0000 0.0000 0.0000 SPX910622C00300000 529 \n", + "1164 0.0000 0.0000 0.0000 0.0000 SPX910622C00300000 528 \n", + "1334 0.0000 0.0000 0.0000 0.0000 SPX910622C00300000 527 \n", + "1504 0.0000 0.0000 0.0000 0.0000 SPX910622C00300000 526 \n", + "1674 0.0000 0.0000 0.0000 0.0000 SPX910622C00300000 523 \n", + "1844 0.0000 0.0000 0.0000 0.0000 SPX910622C00300000 522 \n", + "2026 0.0000 0.0000 0.0000 0.0000 SPX910622C00300000 521 \n", + "2208 0.0000 0.0000 0.0000 0.0000 SPX910622C00300000 520 \n", + "2391 0.0000 0.0000 0.0000 0.0000 SPX910622C00300000 519 \n", + "2548 0.9776 0.0015 -22.3628 20.9095 SPX910622C00300000 516 \n", + "2705 0.9816 0.0013 -22.3658 17.7692 SPX910622C00300000 515 \n", + "2862 0.9806 0.0013 -22.3636 18.4703 SPX910622C00300000 514 \n", + "3022 0.0000 0.0000 0.0000 0.0000 SPX910622C00300000 513 \n", + "3182 0.9747 0.0017 -22.3457 22.7432 SPX910622C00300000 512 \n", + "3344 0.9644 0.0021 -22.3769 30.0972 SPX910622C00300000 509 " + ] + }, + "execution_count": 100, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "problematic[4:20]" + ] + }, + { + "cell_type": "code", + "execution_count": 101, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(34, 19)" + ] + }, + "execution_count": 101, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "problematic[problematic['bid'] == 0].shape" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Of $373$ total rows, $34$ of them have their bid equal to zero even though the non-zero values in between are never even close to zero. These types of contracts happen all throughout the dataset and need to be addressed. We will drop contracts that have an entry with both their ask and bid equal to zero. This means of course that we will also be dropping some contracts with correct values, but we are willing to make that tradeoff." + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Here's an example of a contract with all its bid and ask entries set to zero." + ] + }, + { + "cell_type": "code", + "execution_count": 102, + "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", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + " \n", + "
underlyingunderlying_lastoptionroottypeexpirationquotedatestrikelastbidaskvolumeopeninterestimpliedvoldeltagammathetavegaoptionaliasdte
117271SPX409.76SPX920718P00250000put1992-07-181992-06-12250.00.0000.00.0000.5202-0.00080.0-0.00250.0035SPX920718P0025000036
117505SPX410.29SPX920718P00250000put1992-07-181992-06-15250.00.0310.00.025000.5463-0.00080.0-0.00280.0034SPX920718P0025000033
117743SPX408.32SPX920718P00250000put1992-07-181992-06-16250.00.0000.00.0000.5485-0.00080.0-0.00290.0033SPX920718P0025000032
117981SPX402.26SPX920718P00250000put1992-07-181992-06-17250.00.0000.00.002500.5408-0.00080.0-0.00290.0033SPX920718P0025000031
118219SPX400.96SPX920718P00250000put1992-07-181992-06-18250.00.0000.00.002500.5452-0.00090.0-0.00310.0033SPX920718P0025000030
118457SPX403.67SPX920718P00250000put1992-07-181992-06-19250.00.0000.00.002500.5618-0.00080.0-0.00320.0032SPX920718P0025000029
118645SPX403.40SPX920718P00250000put1992-07-181992-06-22250.00.0000.00.002500.5933-0.00080.0-0.00350.0030SPX920718P0025000026
118833SPX404.04SPX920718P00250000put1992-07-181992-06-23250.00.0000.00.002500.6072-0.00080.0-0.00370.0030SPX920718P0025000025
119021SPX403.84SPX920718P00250000put1992-07-181992-06-24250.00.0000.00.002500.6194-0.00080.0-0.00390.0029SPX920718P0025000024
119209SPX403.12SPX920718P00250000put1992-07-181992-06-25250.00.0000.00.002500.6311-0.00080.0-0.00400.0029SPX920718P0025000023
119397SPX403.45SPX920718P00250000put1992-07-181992-06-26250.00.0000.00.002500.6466-0.00080.0-0.00420.0028SPX920718P0025000022
119585SPX408.94SPX920718P00250000put1992-07-181992-06-29250.00.0000.00.002500.7150-0.00080.0-0.00490.0025SPX920718P0025000019
119773SPX408.14SPX920718P00250000put1992-07-181992-06-30250.00.0000.00.002500.7327-0.00080.0-0.00520.0025SPX920718P0025000018
119961SPX412.88SPX920718P00250000put1992-07-181992-07-01250.00.0000.00.002500.7704-0.00080.0-0.00560.0024SPX920718P0025000017
120149SPX411.79SPX920718P00250000put1992-07-181992-07-02250.00.0000.00.002500.7914-0.00080.0-0.00590.0023SPX920718P0025000016
120339SPX413.84SPX920718P00250000put1992-07-181992-07-06250.00.0000.00.002500.9286-0.00080.0-0.00800.0020SPX920718P0025000012
120529SPX409.16SPX920718P00250000put1992-07-181992-07-07250.00.0000.00.002500.9527-0.00080.0-0.00870.0019SPX920718P0025000011
120719SPX410.28SPX920718P00250000put1992-07-181992-07-08250.00.0000.00.002501.0074-0.00080.0-0.00970.0018SPX920718P0025000010
120909SPX414.22SPX920718P00250000put1992-07-181992-07-09250.00.0000.00.002501.0846-0.00080.0-0.01090.0017SPX920718P002500009
121099SPX414.62SPX920718P00250000put1992-07-181992-07-10250.00.0000.00.002501.1581-0.00080.0-0.01240.0016SPX920718P002500008
121289SPX414.87SPX920718P00250000put1992-07-181992-07-13250.00.0000.00.002501.5091-0.00080.0-0.02090.0012SPX920718P002500005
121479SPX417.68SPX920718P00250000put1992-07-181992-07-14250.00.0000.00.002501.7409-0.00080.0-0.02730.0010SPX920718P002500004
121669SPX417.10SPX920718P00250000put1992-07-181992-07-15250.00.0000.00.002502.0753-0.00080.0-0.03900.0009SPX920718P002500003
121859SPX417.54SPX920718P00250000put1992-07-181992-07-16250.00.0000.00.002502.7500-0.00080.0-0.06830.0007SPX920718P002500002
122049SPX415.62SPX920718P00250000put1992-07-181992-07-17250.00.0000.00.002505.4547-0.00080.0-0.27270.0003SPX920718P002500001
\n", + "
" + ], + "text/plain": [ + " underlying underlying_last optionroot type expiration \\\n", + "117271 SPX 409.76 SPX920718P00250000 put 1992-07-18 \n", + "117505 SPX 410.29 SPX920718P00250000 put 1992-07-18 \n", + "117743 SPX 408.32 SPX920718P00250000 put 1992-07-18 \n", + "117981 SPX 402.26 SPX920718P00250000 put 1992-07-18 \n", + "118219 SPX 400.96 SPX920718P00250000 put 1992-07-18 \n", + "118457 SPX 403.67 SPX920718P00250000 put 1992-07-18 \n", + "118645 SPX 403.40 SPX920718P00250000 put 1992-07-18 \n", + "118833 SPX 404.04 SPX920718P00250000 put 1992-07-18 \n", + "119021 SPX 403.84 SPX920718P00250000 put 1992-07-18 \n", + "119209 SPX 403.12 SPX920718P00250000 put 1992-07-18 \n", + "119397 SPX 403.45 SPX920718P00250000 put 1992-07-18 \n", + "119585 SPX 408.94 SPX920718P00250000 put 1992-07-18 \n", + "119773 SPX 408.14 SPX920718P00250000 put 1992-07-18 \n", + "119961 SPX 412.88 SPX920718P00250000 put 1992-07-18 \n", + "120149 SPX 411.79 SPX920718P00250000 put 1992-07-18 \n", + "120339 SPX 413.84 SPX920718P00250000 put 1992-07-18 \n", + "120529 SPX 409.16 SPX920718P00250000 put 1992-07-18 \n", + "120719 SPX 410.28 SPX920718P00250000 put 1992-07-18 \n", + "120909 SPX 414.22 SPX920718P00250000 put 1992-07-18 \n", + "121099 SPX 414.62 SPX920718P00250000 put 1992-07-18 \n", + "121289 SPX 414.87 SPX920718P00250000 put 1992-07-18 \n", + "121479 SPX 417.68 SPX920718P00250000 put 1992-07-18 \n", + "121669 SPX 417.10 SPX920718P00250000 put 1992-07-18 \n", + "121859 SPX 417.54 SPX920718P00250000 put 1992-07-18 \n", + "122049 SPX 415.62 SPX920718P00250000 put 1992-07-18 \n", + "\n", + " quotedate strike last bid ask volume openinterest impliedvol \\\n", + "117271 1992-06-12 250.0 0.000 0.0 0.0 0 0 0.5202 \n", + "117505 1992-06-15 250.0 0.031 0.0 0.0 250 0 0.5463 \n", + "117743 1992-06-16 250.0 0.000 0.0 0.0 0 0 0.5485 \n", + "117981 1992-06-17 250.0 0.000 0.0 0.0 0 250 0.5408 \n", + "118219 1992-06-18 250.0 0.000 0.0 0.0 0 250 0.5452 \n", + "118457 1992-06-19 250.0 0.000 0.0 0.0 0 250 0.5618 \n", + "118645 1992-06-22 250.0 0.000 0.0 0.0 0 250 0.5933 \n", + "118833 1992-06-23 250.0 0.000 0.0 0.0 0 250 0.6072 \n", + "119021 1992-06-24 250.0 0.000 0.0 0.0 0 250 0.6194 \n", + "119209 1992-06-25 250.0 0.000 0.0 0.0 0 250 0.6311 \n", + "119397 1992-06-26 250.0 0.000 0.0 0.0 0 250 0.6466 \n", + "119585 1992-06-29 250.0 0.000 0.0 0.0 0 250 0.7150 \n", + "119773 1992-06-30 250.0 0.000 0.0 0.0 0 250 0.7327 \n", + "119961 1992-07-01 250.0 0.000 0.0 0.0 0 250 0.7704 \n", + "120149 1992-07-02 250.0 0.000 0.0 0.0 0 250 0.7914 \n", + "120339 1992-07-06 250.0 0.000 0.0 0.0 0 250 0.9286 \n", + "120529 1992-07-07 250.0 0.000 0.0 0.0 0 250 0.9527 \n", + "120719 1992-07-08 250.0 0.000 0.0 0.0 0 250 1.0074 \n", + "120909 1992-07-09 250.0 0.000 0.0 0.0 0 250 1.0846 \n", + "121099 1992-07-10 250.0 0.000 0.0 0.0 0 250 1.1581 \n", + "121289 1992-07-13 250.0 0.000 0.0 0.0 0 250 1.5091 \n", + "121479 1992-07-14 250.0 0.000 0.0 0.0 0 250 1.7409 \n", + "121669 1992-07-15 250.0 0.000 0.0 0.0 0 250 2.0753 \n", + "121859 1992-07-16 250.0 0.000 0.0 0.0 0 250 2.7500 \n", + "122049 1992-07-17 250.0 0.000 0.0 0.0 0 250 5.4547 \n", + "\n", + " delta gamma theta vega optionalias dte \n", + "117271 -0.0008 0.0 -0.0025 0.0035 SPX920718P00250000 36 \n", + "117505 -0.0008 0.0 -0.0028 0.0034 SPX920718P00250000 33 \n", + "117743 -0.0008 0.0 -0.0029 0.0033 SPX920718P00250000 32 \n", + "117981 -0.0008 0.0 -0.0029 0.0033 SPX920718P00250000 31 \n", + "118219 -0.0009 0.0 -0.0031 0.0033 SPX920718P00250000 30 \n", + "118457 -0.0008 0.0 -0.0032 0.0032 SPX920718P00250000 29 \n", + "118645 -0.0008 0.0 -0.0035 0.0030 SPX920718P00250000 26 \n", + "118833 -0.0008 0.0 -0.0037 0.0030 SPX920718P00250000 25 \n", + "119021 -0.0008 0.0 -0.0039 0.0029 SPX920718P00250000 24 \n", + "119209 -0.0008 0.0 -0.0040 0.0029 SPX920718P00250000 23 \n", + "119397 -0.0008 0.0 -0.0042 0.0028 SPX920718P00250000 22 \n", + "119585 -0.0008 0.0 -0.0049 0.0025 SPX920718P00250000 19 \n", + "119773 -0.0008 0.0 -0.0052 0.0025 SPX920718P00250000 18 \n", + "119961 -0.0008 0.0 -0.0056 0.0024 SPX920718P00250000 17 \n", + "120149 -0.0008 0.0 -0.0059 0.0023 SPX920718P00250000 16 \n", + "120339 -0.0008 0.0 -0.0080 0.0020 SPX920718P00250000 12 \n", + "120529 -0.0008 0.0 -0.0087 0.0019 SPX920718P00250000 11 \n", + "120719 -0.0008 0.0 -0.0097 0.0018 SPX920718P00250000 10 \n", + "120909 -0.0008 0.0 -0.0109 0.0017 SPX920718P00250000 9 \n", + "121099 -0.0008 0.0 -0.0124 0.0016 SPX920718P00250000 8 \n", + "121289 -0.0008 0.0 -0.0209 0.0012 SPX920718P00250000 5 \n", + "121479 -0.0008 0.0 -0.0273 0.0010 SPX920718P00250000 4 \n", + "121669 -0.0008 0.0 -0.0390 0.0009 SPX920718P00250000 3 \n", + "121859 -0.0008 0.0 -0.0683 0.0007 SPX920718P00250000 2 \n", + "122049 -0.0008 0.0 -0.2727 0.0003 SPX920718P00250000 1 " + ] + }, + "execution_count": 102, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df[df['optionroot'] == 'SPX920718P00250000']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Another issue are contracts with missing entries like the following, which stops showing up at 358 dte (it also has almost all rows with both ask and bid set to zero, so this is a particularly problematic contract)." + ] + }, + { + "cell_type": "code", + "execution_count": 109, + "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", + "
underlyingunderlying_lastoptionroottypeexpirationquotedatestrikelastbidaskvolumeopeninterestimpliedvoldeltagammathetavegaoptionaliasdte
1120981SPX1165.25SXG031220P01450000put2003-12-202002-01-031450.00.00.00.0000.1837-0.71890.0011-4.9932550.1433SXG031220P01450000716
1121467SPX1172.50SXG031220P01450000put2003-12-202002-01-041450.00.00.00.002000.1780-0.71980.0012-4.3687552.3557SXG031220P01450000715
1121957SPX1164.90SXG031220P01450000put2003-12-202002-01-071450.00.00.00.002000.1820-0.72300.0011-4.5666544.5476SXG031220P01450000712
1122447SPX1160.70SXG031220P01450000put2003-12-202002-01-081450.00.00.00.002000.1830-0.72650.0011-4.3912538.8742SXG031220P01450000711
1122940SPX1155.15SXG031220P01450000put2003-12-202002-01-091450.00.00.00.002000.1846-0.73040.0011-4.2222532.0289SXG031220P01450000710
............................................................
1265123SPX895.82SXG031220P01450000put2003-12-202002-12-201450.00.00.00.0024210.2241-0.96480.00021.531443.4461SXG031220P01450000365
1265633SPX897.38SXG031220P01450000put2003-12-202002-12-231450.00.00.00.0024210.2170-0.96660.00020.531336.1597SXG031220P01450000362
1266143SPX892.47SXG031220P01450000put2003-12-202002-12-241450.00.00.00.0024190.2175-0.96670.0002-0.183433.7203SXG031220P01450000361
1266653SPX889.66SXG031220P01450000put2003-12-202002-12-261450.00.00.00.0024190.2145-0.96510.0002-3.371728.2564SXG031220P01450000359
1267163SPX875.40SXG031220P01450000put2003-12-202002-12-271450.0550.0571.3574.3024190.2282-0.96250.0002-3.867532.5230SXG031220P01450000358
\n", + "

249 rows × 19 columns

\n", + "
" + ], + "text/plain": [ + " underlying underlying_last optionroot type expiration \\\n", + "1120981 SPX 1165.25 SXG031220P01450000 put 2003-12-20 \n", + "1121467 SPX 1172.50 SXG031220P01450000 put 2003-12-20 \n", + "1121957 SPX 1164.90 SXG031220P01450000 put 2003-12-20 \n", + "1122447 SPX 1160.70 SXG031220P01450000 put 2003-12-20 \n", + "1122940 SPX 1155.15 SXG031220P01450000 put 2003-12-20 \n", + "... ... ... ... ... ... \n", + "1265123 SPX 895.82 SXG031220P01450000 put 2003-12-20 \n", + "1265633 SPX 897.38 SXG031220P01450000 put 2003-12-20 \n", + "1266143 SPX 892.47 SXG031220P01450000 put 2003-12-20 \n", + "1266653 SPX 889.66 SXG031220P01450000 put 2003-12-20 \n", + "1267163 SPX 875.40 SXG031220P01450000 put 2003-12-20 \n", + "\n", + " quotedate strike last bid ask volume openinterest \\\n", + "1120981 2002-01-03 1450.0 0.0 0.0 0.0 0 0 \n", + "1121467 2002-01-04 1450.0 0.0 0.0 0.0 0 200 \n", + "1121957 2002-01-07 1450.0 0.0 0.0 0.0 0 200 \n", + "1122447 2002-01-08 1450.0 0.0 0.0 0.0 0 200 \n", + "1122940 2002-01-09 1450.0 0.0 0.0 0.0 0 200 \n", + "... ... ... ... ... ... ... ... \n", + "1265123 2002-12-20 1450.0 0.0 0.0 0.0 0 2421 \n", + "1265633 2002-12-23 1450.0 0.0 0.0 0.0 0 2421 \n", + "1266143 2002-12-24 1450.0 0.0 0.0 0.0 0 2419 \n", + "1266653 2002-12-26 1450.0 0.0 0.0 0.0 0 2419 \n", + "1267163 2002-12-27 1450.0 550.0 571.3 574.3 0 2419 \n", + "\n", + " impliedvol delta gamma theta vega optionalias dte \n", + "1120981 0.1837 -0.7189 0.0011 -4.9932 550.1433 SXG031220P01450000 716 \n", + "1121467 0.1780 -0.7198 0.0012 -4.3687 552.3557 SXG031220P01450000 715 \n", + "1121957 0.1820 -0.7230 0.0011 -4.5666 544.5476 SXG031220P01450000 712 \n", + "1122447 0.1830 -0.7265 0.0011 -4.3912 538.8742 SXG031220P01450000 711 \n", + "1122940 0.1846 -0.7304 0.0011 -4.2222 532.0289 SXG031220P01450000 710 \n", + "... ... ... ... ... ... ... ... \n", + "1265123 0.2241 -0.9648 0.0002 1.5314 43.4461 SXG031220P01450000 365 \n", + "1265633 0.2170 -0.9666 0.0002 0.5313 36.1597 SXG031220P01450000 362 \n", + "1266143 0.2175 -0.9667 0.0002 -0.1834 33.7203 SXG031220P01450000 361 \n", + "1266653 0.2145 -0.9651 0.0002 -3.3717 28.2564 SXG031220P01450000 359 \n", + "1267163 0.2282 -0.9625 0.0002 -3.8675 32.5230 SXG031220P01450000 358 \n", + "\n", + "[249 rows x 19 columns]" + ] + }, + "execution_count": 109, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "df[df['optionroot'] == 'SXG031220P01450000']" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Once again, we will drop contracts with missing entries." + ] + }, + { + "cell_type": "code", + "execution_count": 26, + "metadata": {}, + "outputs": [], + "source": [ + "unique_contracts_per_day = df.groupby('quotedate').apply(lambda x: x['optionroot'].nunique())" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's plot the number of contracts per day to compare after the cleanup." + ] + }, + { + "cell_type": "code", + "execution_count": 28, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "unique_contracts_per_day.plot();" + ] + }, + { + "cell_type": "code", + "execution_count": 71, + "metadata": {}, + "outputs": [], + "source": [ + "# to_clean is a set with the contracts with missing entries to then drop.\n", + "current_contracts = set()\n", + "to_clean = set()\n", + "for _, options in df.groupby('quotedate'):\n", + " current_contracts = current_contracts.union(set(options['optionroot']))\n", + " current_contracts = current_contracts.difference(set(options[options['dte'] <= 1]['optionroot']))\n", + " missing_contracts = current_contracts.difference(set(options['optionroot']))\n", + " to_clean = to_clean.union(missing_contracts)\n", + "to_clean = to_clean.union(current_contracts)" + ] + }, + { + "cell_type": "code", + "execution_count": 54, + "metadata": {}, + "outputs": [], + "source": [ + "to_clean_df = df[df['optionroot'].isin(list(to_clean))]" + ] + }, + { + "cell_type": "code", + "execution_count": 55, + "metadata": {}, + "outputs": [], + "source": [ + "new_df = df.drop(to_clean_df.index)" + ] + }, + { + "cell_type": "code", + "execution_count": 56, + "metadata": {}, + "outputs": [], + "source": [ + "new_df.reset_index(inplace=True, drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 57, + "metadata": {}, + "outputs": [], + "source": [ + "# Drop the contracts that have a row with both their ask and bid zero.\n", + "contracts_with_zero = new_df[(new_df['ask'] == 0) & (new_df['bid'] == 0)]['optionroot'].unique()" + ] + }, + { + "cell_type": "code", + "execution_count": 58, + "metadata": {}, + "outputs": [], + "source": [ + "final_df = new_df.drop(new_df[new_df['optionroot'].isin(contracts_with_zero)].index)" + ] + }, + { + "cell_type": "code", + "execution_count": 59, + "metadata": {}, + "outputs": [], + "source": [ + "final_df.reset_index(inplace=True, drop=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 72, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "0.6339574482236837" + ] + }, + "execution_count": 72, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "final_df['optionroot'].nunique() / df['optionroot'].nunique()" + ] + }, + { + "cell_type": "code", + "execution_count": 64, + "metadata": {}, + "outputs": [ + { + "data": { + "text/plain": [ + "(9245562, 19)" + ] + }, + "execution_count": 64, + "metadata": {}, + "output_type": "execute_result" + } + ], + "source": [ + "final_df.shape" + ] + }, + { + "cell_type": "code", + "execution_count": 103, + "metadata": {}, + "outputs": [], + "source": [ + "unique_contracts_per_day_final = final_df.groupby('quotedate').apply(lambda x: x['optionroot'].nunique())" + ] + }, + { + "cell_type": "code", + "execution_count": 105, + "metadata": {}, + "outputs": [ + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": { + "needs_background": "light" + }, + "output_type": "display_data" + } + ], + "source": [ + "unique_contracts_per_day_final.plot();" + ] + }, + { + "cell_type": "code", + "execution_count": 66, + "metadata": {}, + "outputs": [], + "source": [ + "store_path = os.path.join(\"/Users/jrchatruc/Documents/backtester_options/allspx/\", \"options_data_v2_pruned.h5\")\n", + "store = pd.HDFStore(store_path, complevel=9, complib=\"blosc\", fletcher32=True)" + ] + }, + { + "cell_type": "code", + "execution_count": 68, + "metadata": {}, + "outputs": [], + "source": [ + "sizes = {\"optionroot\": 20, \"optionalias\": 20}\n", + "store.append(\"/SPX\", final_df, index=False, data_columns=True, min_itemsize=sizes)" + ] + }, + { + "cell_type": "code", + "execution_count": 69, + "metadata": {}, + "outputs": [], + "source": [ + "store.close()" + ] + }, + { + "cell_type": "code", + "execution_count": 70, + "metadata": {}, + "outputs": [], + "source": [ + "%cd -q /Users/jrchatruc/Documents/backtester_options/allspx\n", + "!ptrepack --complevel=9 --complib=blosc options_data_v2_pruned.h5 options_data_v2_pruned_compressed.h5" + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "Python 3", + "language": "python", + "name": "python3" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.7.3" + } + }, + "nbformat": 4, + "nbformat_minor": 4 +}