From 5db93fc320aa630abd35d43d0d82a1f96c6c1259 Mon Sep 17 00:00:00 2001 From: ojustino Date: Thu, 2 Jan 2025 19:03:42 -0500 Subject: [PATCH 1/9] Confirm expected test outputs; update FB ticker --- test_suite.py | 30 +++++++++++++++++++++--------- 1 file changed, 21 insertions(+), 9 deletions(-) diff --git a/test_suite.py b/test_suite.py index 563d04b..8fce564 100644 --- a/test_suite.py +++ b/test_suite.py @@ -38,7 +38,7 @@ def _rewind_prices(self): NOTE: VALUES WILL NEED TO BE CHANGED AGAIN ONCE run_time_loop IS CORRECTED SUCH THAT IT DOESN'T DOUBLE COUNT DIVIDENDS. ''' - for _, val in self.assets.items(): + for tkr, val in self.assets.items(): df = val['df'].copy() cols = ['close', 'high', 'low', 'open'] @@ -87,6 +87,11 @@ def _rewind_prices(self): # add the readjusted price colums to the original dataFrame val['df'][adj_cols] = tot_splits_cast * divFactors * df[cols] + # reset benchmark portfolio starting value to reflect any price adjustments + # (copied from HistoricalSimulator.__init__()) + self._bench_cash = self.portfolio_value(self.start_date, at_close=False) + self._starting_value = self._bench_cash + def _compare_figs(ax, img_root): ''' Compare axes from plot_results() or plot_assets() in the test function's @@ -177,7 +182,7 @@ def test_sma(): pf2.add_ticker('ACES', .07, label='core') pf2.add_ticker('BIV', .15, label='core', shares=.445) pf2.add_ticker('LQD', .05, label='core', shares=5) - pf2.add_ticker('FB', 0, label='core', shares=30) + pf2.add_ticker('META', 0, label='core', shares=30) pf2.add_ticker('TQQQ', label='satellite', in_market=True) pf2.add_ticker('TLT', label='satellite', in_market=False) pf2.add_ticker('SPY', .6, label='benchmark', track=True) @@ -197,8 +202,8 @@ def test_sma(): sma.begin_time_loop() # compare portfolio values to expectations - exp_pf_val = 14038.487133948604 - exp_bnch_val = 10898.582343484206 + exp_pf_val = 13377.608096729453 # 14038.487133948604 + exp_bnch_val = 10944.954633797679 # 10898.582343484206 test_pf_val = sma.portfolio_value() test_bnch_val = sma.portfolio_value(main_portfolio=False) @@ -208,10 +213,15 @@ def test_sma(): err_msg=': benchmark portfolio') # compare portfolios' share counts to expectations - exp_shares = {'SCHG': 35.83601442282118, 'SCHM': 18.748962642069873, - 'EFG': 11.109352277298585, 'ACES': 11.169197042734888, - 'BIV': 12.618948407993443, 'LQD': 3.040265631432126, - 'FB': 0.0, 'TQQQ': 43.0, 'TLT': 0.0, + # exp_shares = {'SCHG': 35.83601442282118, 'SCHM': 18.748962642069873, + # 'EFG': 11.109352277298585, 'ACES': 11.169197042734888, + # 'BIV': 12.618948407993443, 'LQD': 3.040265631432126, + # 'META': 0.0, 'TQQQ': 43.0, 'TLT': 0.0, + # 'SPY': 19.300408108960365, 'AGG': 36.53405970562885} + exp_shares = {'SCHG': 33.828459163391145, 'SCHM': 17.74082135494017, + 'EFG': 10.103045729309041, 'ACES': 11.16278720221734, + 'BIV': 12.612833394729345, 'LQD': 2.040265631432126, + 'META': 0.0, 'TQQQ': 41.0, 'TLT': 0.0, 'SPY': 19.300408108960365, 'AGG': 36.53405970562885} tst_shares = {key : val['shares'] for key,val in sma.assets.items()} @@ -223,7 +233,9 @@ def test_sma(): # compare results plot to reference img_root = 'sma' ax = sma.plot_results(return_plot=True, verbose=False) - _compare_figs(ax, img_root) + # _compare_figs(ax, img_root) # won't match ref since values have changed + # using graphreader.com, sma_ref.png's start value looks like ~$9,825. + # (prob close: $9,879 reading with sma_test.png on 1/2/25 only $2 too high) def test_vlt(): ''' From 5bd5035b898c698b8315a4989f2219f5411d643b Mon Sep 17 00:00:00 2001 From: ojustino Date: Tue, 31 Mar 2026 19:14:55 -0400 Subject: [PATCH 2/9] Tighten up past price normalization --- test_suite.py | 100 +++++++++++++++++++++++++++----------------------- 1 file changed, 55 insertions(+), 45 deletions(-) diff --git a/test_suite.py b/test_suite.py index 8fce564..05bf026 100644 --- a/test_suite.py +++ b/test_suite.py @@ -17,23 +17,28 @@ def _rewind_prices(self): ''' Takes a dataFrame from a symbol's 'df' key in the `assets` dictionary of a Strategy instance (e.g. bnh.assets['AAPL']['df']) and adjusts the - dataFrame's 'adj' columns (close, high, low, open) to approximate how they - would have looked on the Strategy instance's end date instead of on - whichever date the instance was created. - - This is useful because, as seen in cron job results, Tiingo's own 'adj' - column values vary over time as dividends and stock splits occur. To get - consistent results for testing purposes, you must either use the unadjusted - columns (ignoring dividends and splits) or figure out how to reproducibly - adjust the price values to your own liking (this!). + dataFrame's 'adj' columns (close, high, low, open) to the basis of the + prices on the Strategy instance's end date. **This makes simulation results + reproducible over time.** + + This is useful because Tiingo's own 'adj' values are adjusted to the basis + of the prices on the date the data were queried. This means the values + change over time as more dividend payments and stock splits occur. To get + consistent numbers, one must either use the unadjusted columns (and ignore + dividends and splits), always query price data until the present day (to + capture and factor in subsequent corporate actions), or otherwise adjust the + unadjusted prices in a reproducible manner (this!). Assigned to Strategy instances as a new method through MethodType. - NOTE: Past dates' 'adj' values won't exactly match the originals for - Strategy instances with end dates on your present date. This is likely - because the original 'close' column is rounded to only the hundredths - place. It should only be a small discrepancy: for AAPL from 1993-12-27 to - 2021-02-10, the difference in 'adjClose' values is 3e-5 on the first day. + NOTE: Past dates' 'adj' values won't exactly match Tiingo's originals, + even when a Strategy query includes all corporate actions between the start + date and the present. This is almost fully because Tiingo's unadjusted + 'close' column is rounded to 2 decimal places while they use more for their + adjustments. However, this is a minuscule discrepancy that doesn't affect + Strategy simulations. For example, the Tiingo-provided adjClose on the start + date of an AAPL query from 1993-12-27 to 2026-03-30 (conducted on the latter + date) was 0.02% different in price from this method's adjClose. NOTE: VALUES WILL NEED TO BE CHANGED AGAIN ONCE run_time_loop IS CORRECTED SUCH THAT IT DOESN'T DOUBLE COUNT DIVIDENDS. @@ -42,50 +47,55 @@ def _rewind_prices(self): df = val['df'].copy() cols = ['close', 'high', 'low', 'open'] - # split factor for each date through cumulative product + # split factor for each date through reversed cumulative product # (inspiration from https://stackoverflow.com/questions/62130566/) - tot_splits = df['splitFactor'].cumprod().values + tot_splits = df['splitFactor'][::-1].cumprod()[::-1].values tot_splits_cast = np.tile(tot_splits, (len(cols), 1)).T - # get dates and amounts of dividends - div_dts = df[df['divCash'] != 0].index + # get prices on dates that precede dividend ex-dates + # (excluding any that aren't present in the dataFrame) + div_dts_all = df[df['divCash'] != 0].index + pre_div_inds_all = df.index.get_indexer_for(div_dts_all) + pre_div_inds = pre_div_inds_all[pre_div_inds_all > 0] + pre_div_prices = df.iloc[pre_div_inds - 1][cols] + + # get dates and amounts of remaining dividends + div_dts = div_dts_all[pre_div_inds_all > 0] div_amts = df.loc[div_dts, 'divCash'].values div_amts_cast = np.tile(div_amts, (len(cols), 1)).T - # get indices of days that precede dividend ex-dates - pre_div_inds = df.reset_index()[df.index.isin(div_dts)].index - 1 - - # get dates and prices of these pre-dividend indices - pre_div_dts = df.iloc[pre_div_inds].index - pre_div_prices = df.iloc[pre_div_inds][cols] - # (pre_div_closes, pre_div_highs, - # pre_div_lows, pre_div_opens) = df.iloc[pre_div_inds][cols].T.values - - # calculate dividend adjustments on close prices, then get - # cumulative product of these adjustments going backward in time - tot_div_adjs = ( (pre_div_prices - div_amts_cast) - / pre_div_prices)[::-1].cumprod()[::-1] - - # apply the dividend adjustments to previous prices - divFactors = pd.DataFrame(index=df.index, columns=cols, data=1, - dtype=np.float64) - - for i, dt in enumerate(pre_div_dts): - if i == 0: - divFactors.loc[:pre_div_dts[i]] = tot_div_adjs.iloc[i].T.values - else: - divFactors.loc[div_dts[i-1] : pre_div_dts[i], - :] = tot_div_adjs.iloc[i].T.values + # calculate dividend adjustments on close (and other) prices + # (div_adjs_by_dt[::-1].cumprod()[::-1] == old tot_div_adjs) + div_adjs_by_dt = ((pre_div_prices - div_amts_cast) / pre_div_prices) + + # multiply each dividend adjustment into the dates before its ex date + divFactors = pd.DataFrame(index=df.index, columns=cols, + data=1, dtype=np.float64) + for dt in div_adjs_by_dt.index: + divFactors.loc[divFactors.index <= dt] *= div_adjs_by_dt.loc[dt] + + # NOT NEEDED; DIVIDENDS ARE ALREADY BAKED INTO THE ADJUSTMENT + # # calculate each dividend's value as shares of previous (unadj.) close + # divs_in_shares = df.loc[div_dts, 'divCash'] / pre_div_prices['close'].values + + # # scale each dividend to equivalent per-share value for adjusted prices; + # # rename original divCash column and replace with scaled values + # val['df']['OG_divCash'] = val['df']['divCash'].copy() + # for i, dt in enumerate(divs_in_shares.index): + # val['df'].loc[dt, 'divCash'] = ( + # df.loc[df.index[pre_div_inds[i]], 'close'] + # * divs_in_shares.loc[dt] + # ) # rename Tiingo's adj columns adj_cols = ['adj' + c.title() for c in cols] - old_adj_cols = ['OG_' + c.title() for c in adj_cols] + old_adj_cols = ['OG_' + c for c in adj_cols] renames = {adj: old for adj, old in zip(adj_cols, old_adj_cols)} val['df'].rename(columns=renames, inplace=True) - # add the readjusted price colums to the original dataFrame - val['df'][adj_cols] = tot_splits_cast * divFactors * df[cols] + # add the readjusted price columns to the original dataFrame + val['df'][adj_cols] = df[cols] / tot_splits_cast * divFactors # reset benchmark portfolio starting value to reflect any price adjustments # (copied from HistoricalSimulator.__init__()) From d81189dbbe2c2aba4000306d42b14f685cd3c305 Mon Sep 17 00:00:00 2001 From: ojustino Date: Wed, 1 Apr 2026 00:08:24 -0400 Subject: [PATCH 3/9] Move price normalization to HistoricalSimulator --- simulator.py | 84 +++++++++++++++++++++++++ test_suite.py | 18 ++---- walkthrough.ipynb | 155 +++++++++++++++++++++++++++++++++++----------- 3 files changed, 210 insertions(+), 47 deletions(-) diff --git a/simulator.py b/simulator.py index e56840a..5764d51 100755 --- a/simulator.py +++ b/simulator.py @@ -1418,3 +1418,87 @@ def plot_assets(self, *tickers, start_value=None, reinvest_dividends=False, return ax plt.show() + + def normalize_price_bases(self): + ''' + Takes a dataFrame from a symbol's 'df' key in the `assets` dictionary of + a Strategy instance (e.g. sim.assets['AAPL']['df']) and adjusts the + dataFrame's 'adj' columns (close, high, low, open) to the basis of the + prices on the Strategy instance's end date. **This makes simulation + results reproducible over time.** + + This is useful because Tiingo's own 'adj' values are adjusted to the + basis of the prices on the date the data were queried. This means the + values for a given query will change over time as more dividend payments + and stock splits occur. To get consistent numbers, one must either use + the unadjusted columns (and ignore dividends and splits), always query + price data until the present day (extra data in order to capture and + factor in subsequent corporate actions), or otherwise adjust the + unadjusted prices in a reproducible manner (this method). + + NOTE: Past dates' 'adj' values won't exactly match Tiingo's originals, + even when a Strategy query includes all corporate actions between the + start date and the present. This is almost entirely because Tiingo's + unadjusted 'close' column is rounded to 2 decimal places while they use + more for their adjustments. However, this is a minuscule discrepancy + that doesn't affect Strategy simulations. For example, the Tiingo- + provided adjClose on the start date of an AAPL query from 1993-12-27 to + 2026-03-30 (conducted on the latter date) was 0.02% different in price + from this method's adjClose. + ''' + for tkr, val in self.assets.items(): + df = val['df'].copy() + cols = ['close', 'high', 'low', 'open'] + + # split factor for each date through reversed cumulative product + # (inspiration from https://stackoverflow.com/questions/62130566/) + tot_splits = df['splitFactor'][::-1].cumprod()[::-1].shift(-1, fill_value=1.0).values + tot_splits_cast = np.tile(tot_splits, (len(cols), 1)).T + + # get prices on dividend ex dates (immediately preceding payday), + # excluding any that aren't present in the dataFrame + div_dts_all = df[df['divCash'] != 0].index + pre_div_inds_all = df.index.get_indexer_for(div_dts_all) + pre_div_inds = pre_div_inds_all[pre_div_inds_all > 0] + pre_div_prices = df.iloc[pre_div_inds - 1][cols] + + # get pay dates and amounts of remaining dividends + div_dts = div_dts_all[pre_div_inds_all > 0] + div_amts = df.loc[div_dts, 'divCash'].values + div_amts_cast = np.tile(div_amts, (len(cols), 1)).T + + # calculate dividend adjustments on relevant price data + # (div_adjs_by_dt[::-1].cumprod()[::-1] == old tot_div_adjs) + div_adjs_by_dt = ((pre_div_prices - div_amts_cast) / pre_div_prices) + + # factor each dividend's adj. into all days preceding its payday + divFactors = pd.DataFrame(index=df.index, columns=cols, + data=1, dtype=np.float64) + for dt in div_adjs_by_dt.index: + divFactors.loc[divFactors.index <= dt] *= div_adjs_by_dt.loc[dt] + + # NOT NEEDED; DIVIDENDS ARE ALREADY BAKED INTO THE ADJUSTMENT + # # calculate each dividend's value as shares of previous (unadj.) close + # divs_in_shares = df.loc[div_dts, 'divCash'] / pre_div_prices['close'].values + + # # scale each dividend to equivalent per-share value for adjusted prices; + # # rename original divCash column and replace with scaled values + # val['df']['OG_divCash'] = val['df']['divCash'].copy() + # for i, dt in enumerate(divs_in_shares.index): + # val['df'].loc[dt, 'divCash'] = ( + # df.loc[df.index[pre_div_inds[i]], 'close'] + # * divs_in_shares.loc[dt] + # ) + + # copy Tiingo's original adj columns to the end of the column list + adj_cols = ['adj' + c.title() for c in cols] + old_adj_cols = ['OG_' + c for c in adj_cols] + val['df'][old_adj_cols] = val['df'][adj_cols].copy() + + # add the readjusted price columns to the original dataFrame + val['df'][adj_cols] = df[cols] / tot_splits_cast * divFactors + + # reset benchmark portfolio starting value to reflect any price changes + # (copied from HistoricalSimulator.__init__()) + self._bench_cash = self.portfolio_value(self.start_date, at_close=False) + self._starting_value = self._bench_cash diff --git a/test_suite.py b/test_suite.py index 05bf026..8d352ca 100644 --- a/test_suite.py +++ b/test_suite.py @@ -133,15 +133,13 @@ def test_bnh(): pf1.add_ticker('CPB', 1/3) pf1.add_ticker('SPY', 1, label='benchmark') - # initialize Strategy and swap price columns + # initialize Strategy and normalize prices bnh = BuyAndHoldStrategy(pf1, start_date=pd.Timestamp(2000, 8, 1), end_date=pd.Timestamp(2016, 1, 1), cash=10000, reinvest_dividends=False, tot_rb_freq=12, target_rb_day=0) - - bnh._rewind_prices = MethodType(_rewind_prices, bnh) - bnh._rewind_prices() + bnh.normalize_price_bases() # append another rebalance date to test the process nu_prices = {'MCD': 117.25, 'TGT': 71.84, 'CPB': 43.83, 'SPY': 200.49} @@ -198,15 +196,13 @@ def test_sma(): pf2.add_ticker('SPY', .6, label='benchmark', track=True) pf2.add_ticker('AGG', .4, label='benchmark') - # initialize Strategy and swap price columns + # initialize Strategy and normalize prices sma = SMAStrategy(pf2, window=100, start_date=pd.Timestamp(2019, 12, 12), end_date=pd.Timestamp(2020, 8, 13), cash=1738.29, reinvest_dividends=True, sat_rb_freq=365.25, tot_rb_freq=12, target_rb_day=8) - - sma._rewind_prices = MethodType(_rewind_prices, sma) - sma._rewind_prices() + sma.normalize_price_bases() # run simulation sma.begin_time_loop() @@ -266,15 +262,13 @@ def test_vlt(): pf3.add_ticker('TLT', label='satellite', in_market=False) pf3.add_ticker('GLD', 1, label='benchmark') - # initialize Strategy and swap price columns + # initialize Strategy and normalize prices vlt = VolTargetStrategy(pf3, window=30, vol_target=.15, start_date=pd.Timestamp(2018, 7, 27), end_date=pd.Timestamp(2019, 7, 31), cash=5500, reinvest_dividends=False, sat_rb_freq=12, tot_rb_freq=4, target_rb_day=-3) - - vlt._rewind_prices = MethodType(_rewind_prices, vlt) - vlt._rewind_prices() + vlt.normalize_price_bases() # run simulation vlt.begin_time_loop() diff --git a/walkthrough.ipynb b/walkthrough.ipynb index f51bbe7..cabc9a6 100755 --- a/walkthrough.ipynb +++ b/walkthrough.ipynb @@ -263,10 +263,26 @@ "list(sim.assets.keys())" ] }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "Let's normalize the price data to make the results of this simulation reproducible and then look at an example asset." + ] + }, { "cell_type": "code", "execution_count": 10, "metadata": {}, + "outputs": [], + "source": [ + "sim.normalize_price_bases()" + ] + }, + { + "cell_type": "code", + "execution_count": 11, + "metadata": {}, "outputs": [ { "data": { @@ -301,6 +317,10 @@ " adjVolume\n", " divCash\n", " splitFactor\n", + " OG_adjClose\n", + " OG_adjHigh\n", + " OG_adjLow\n", + " OG_adjOpen\n", " \n", " \n", " date\n", @@ -316,6 +336,10 @@ " \n", " \n", " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", @@ -326,13 +350,17 @@ " 51.25\n", " 51.79\n", " 62700\n", - " 43.157788\n", - " 43.814372\n", - " 43.140952\n", - " 43.595511\n", + " 45.997665\n", + " 46.729090\n", + " 45.954097\n", + " 46.472783\n", " 62700\n", " 0.0\n", " 1.0\n", + " 41.768858\n", + " 42.404311\n", + " 41.752564\n", + " 42.192493\n", " \n", " \n", " 2006-08-10\n", @@ -341,13 +369,17 @@ " 51.15\n", " 51.15\n", " 53400\n", - " 43.418738\n", - " 43.494498\n", - " 43.056775\n", - " 43.056775\n", + " 46.275786\n", + " 46.387936\n", + " 45.864430\n", + " 45.898491\n", " 53400\n", " 0.0\n", " 1.0\n", + " 42.021410\n", + " 42.094731\n", + " 41.671095\n", + " 41.671095\n", " \n", " \n", " 2006-08-11\n", @@ -356,13 +388,17 @@ " 51.16\n", " 51.56\n", " 90900\n", - " 43.208294\n", - " 43.401903\n", - " 43.065193\n", - " 43.401903\n", + " 46.051495\n", + " 46.289181\n", + " 45.873397\n", + " 46.266397\n", " 90900\n", " 0.0\n", " 1.0\n", + " 41.817739\n", + " 42.005116\n", + " 41.679242\n", + " 42.005116\n", " \n", " \n", " 2006-08-14\n", @@ -371,13 +407,17 @@ " 51.40\n", " 51.75\n", " 53900\n", - " 43.267219\n", - " 43.696524\n", - " 43.267219\n", - " 43.561840\n", + " 46.114296\n", + " 46.603402\n", + " 46.088596\n", + " 46.436890\n", " 53900\n", " 0.0\n", " 1.0\n", + " 41.874766\n", + " 42.290255\n", + " 41.874766\n", + " 42.159906\n", " \n", " \n", " 2006-08-15\n", @@ -386,13 +426,17 @@ " 51.80\n", " 52.10\n", " 81300\n", - " 44.007980\n", - " 44.007980\n", - " 43.603928\n", - " 43.856461\n", + " 46.903802\n", + " 46.935578\n", + " 46.447263\n", + " 46.750956\n", " 81300\n", " 0.0\n", " 1.0\n", + " 42.591689\n", + " 42.591689\n", + " 42.200640\n", + " 42.445045\n", " \n", " \n", "\n", @@ -401,22 +445,30 @@ "text/plain": [ " close high low open volume adjClose adjHigh \\\n", "date \n", - "2006-08-09 51.27 52.05 51.25 51.79 62700 43.157788 43.814372 \n", - "2006-08-10 51.58 51.67 51.15 51.15 53400 43.418738 43.494498 \n", - "2006-08-11 51.33 51.56 51.16 51.56 90900 43.208294 43.401903 \n", - "2006-08-14 51.40 51.91 51.40 51.75 53900 43.267219 43.696524 \n", - "2006-08-15 52.28 52.28 51.80 52.10 81300 44.007980 44.007980 \n", + "2006-08-09 51.27 52.05 51.25 51.79 62700 45.997665 46.729090 \n", + "2006-08-10 51.58 51.67 51.15 51.15 53400 46.275786 46.387936 \n", + "2006-08-11 51.33 51.56 51.16 51.56 90900 46.051495 46.289181 \n", + "2006-08-14 51.40 51.91 51.40 51.75 53900 46.114296 46.603402 \n", + "2006-08-15 52.28 52.28 51.80 52.10 81300 46.903802 46.935578 \n", "\n", - " adjLow adjOpen adjVolume divCash splitFactor \n", - "date \n", - "2006-08-09 43.140952 43.595511 62700 0.0 1.0 \n", - "2006-08-10 43.056775 43.056775 53400 0.0 1.0 \n", - "2006-08-11 43.065193 43.401903 90900 0.0 1.0 \n", - "2006-08-14 43.267219 43.561840 53900 0.0 1.0 \n", - "2006-08-15 43.603928 43.856461 81300 0.0 1.0 " + " adjLow adjOpen adjVolume divCash splitFactor \\\n", + "date \n", + "2006-08-09 45.954097 46.472783 62700 0.0 1.0 \n", + "2006-08-10 45.864430 45.898491 53400 0.0 1.0 \n", + "2006-08-11 45.873397 46.266397 90900 0.0 1.0 \n", + "2006-08-14 46.088596 46.436890 53900 0.0 1.0 \n", + "2006-08-15 46.447263 46.750956 81300 0.0 1.0 \n", + "\n", + " OG_adjClose OG_adjHigh OG_adjLow OG_adjOpen \n", + "date \n", + "2006-08-09 41.768858 42.404311 41.752564 42.192493 \n", + "2006-08-10 42.021410 42.094731 41.671095 41.671095 \n", + "2006-08-11 41.817739 42.005116 41.679242 42.005116 \n", + "2006-08-14 41.874766 42.290255 41.874766 42.159906 \n", + "2006-08-15 42.591689 42.591689 42.200640 42.445045 " ] }, - "execution_count": 10, + "execution_count": 11, "metadata": {}, "output_type": "execute_result" } @@ -436,7 +488,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": { "scrolled": true }, @@ -487,6 +539,39 @@ "sim.plot_results()" ] }, + { + "cell_type": "code", + "execution_count": 13, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "end date main portfolio value: $18,705.81\n", + "end date main portfolio shares: \n", + "VUG: 50.9, VO: 12.4, EFG: 22.7, VBIIX: 147.4, ISHIX: 58.7, SSO: 110.4, TLT: 0.0\n", + "\n", + "end date benchmark portfolio value: $20,389.79\n", + "end date benchmark portfolio shares: \n", + "SPY: 57.7, AGG: 74.3\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "
" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "sim.plot_results()" + ] + }, { "cell_type": "markdown", "metadata": {}, @@ -515,7 +600,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.8" + "version": "3.9.0" } }, "nbformat": 4, From 73d14a3dc7290d08bd4de59b2dc0062f86b1b30c Mon Sep 17 00:00:00 2001 From: ojustino Date: Thu, 2 Apr 2026 20:13:04 -0400 Subject: [PATCH 4/9] Swap dividend arg for clarity (reinvest > cash_out) --- buy_and_hold.ipynb | 4 ++-- simulator.py | 28 +++++++++++++++------------- strategies.py | 6 +++--- walkthrough.ipynb | 2 +- 4 files changed, 21 insertions(+), 19 deletions(-) diff --git a/buy_and_hold.ipynb b/buy_and_hold.ipynb index 0ce5bf4..7229701 100755 --- a/buy_and_hold.ipynb +++ b/buy_and_hold.ipynb @@ -152,7 +152,7 @@ "bnh = BuyAndHoldStrategy(pf,\n", " start_date=pd.Timestamp(2020, 1, 1),\n", " end_date=pd.Timestamp(2020, 3, 31),\n", - " cash=1000, reinvest_dividends=True,\n", + " cash=1000, cash_out_dividends=False,\n", " tot_rb_freq=12, target_rb_day=0)" ] }, @@ -395,7 +395,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.6" + "version": "3.9.0" } }, "nbformat": 4, diff --git a/simulator.py b/simulator.py index 5764d51..ce1c486 100755 --- a/simulator.py +++ b/simulator.py @@ -66,10 +66,12 @@ class HistoricalSimulator(ABC): indexing, so both positive and negative values are acceptable as long as their absolute value is 13 or lower. [default: -2] - reinvest_dividends : boolean, optional - When True, any dividends paid out by an asset are used immediately to - purchase partial shares of that asset. When False, dividends are taken - in as cash and spent on the next rebalance date. [default: False] + cash_out_dividends : boolean, optional + When True, dividends are taken in as cash and spent on the next + rebalance date. When False, any dividends paid out by an asset are used + immediately to purchase partial shares of that asset. Can only be True + when simulation price data is NOT dividend-adjusted. Otherwise, cashing + out isn't possible. [default: False] verbose : boolean, optional Whether or not to print the download's progress. [default: False] @@ -79,7 +81,7 @@ def __init__(self, Portfolio, cash=1e4, start_date=pd.Timestamp(2007, 5, 22), end_date=pd.Timestamp(2015, 5, 22), sat_rb_freq=6, tot_rb_freq=1, target_rb_day=-2, - reinvest_dividends=False, verbose=False): + cash_out_dividends=False, verbose=False): # make sure a PortfolioMaker object is present if not isinstance(Portfolio, PortfolioMaker): raise ValueError('The first argument of HistoricalSimulator() must ' @@ -132,7 +134,7 @@ def __init__(self, Portfolio, cash=1e4, self.rb_info = self._calc_rebalance_info(verbose) # save preference for handling dividend payouts - self.reinvest_dividends = reinvest_dividends + self.cash_out_dividends = cash_out_dividends # track remaining money in main and benchmark portfolios # (are properties, so an error is thrown if they go negative) @@ -1012,7 +1014,7 @@ def _check_dividends(self, main_portfolio=True, verbose=False): Checks whether assets currently held in a portfolio are paying out dividends on a given day. If so, accepts the dividend as partial shares - of that asset if self.reinvest_dividends is True, or as cash if False. + of that asset if self.cash_out_dividends is False, or as cash if True. Note that this check happens before any rebalancing transactions because one needs to have owned an asset on the day before the dividend @@ -1053,7 +1055,7 @@ def _check_dividends(self, main_portfolio=True, verbose=False): continue # barring those, receive the dividend as partial shares or cash - if self.reinvest_dividends: + if not self.cash_out_dividends: tk_price = self.assets[tk]['df'].loc[self.today, 'adjOpen'] partials = shares_held * (div_cash / tk_price) my_pr(f"**** on {self.today.strftime('%Y-%m-%d')}\n" @@ -1306,7 +1308,7 @@ def plot_results(self, show_benchmark=True, logy=False, plt.show() - def plot_assets(self, *tickers, start_value=None, reinvest_dividends=False, + def plot_assets(self, *tickers, start_value=None, cash_out_dividends=True, logy=False, return_plot=False, verbose=True): ''' View a plot of one or more assets' individual performances over the @@ -1324,9 +1326,9 @@ def plot_assets(self, *tickers, start_value=None, reinvest_dividends=False, value is the original value chosen for self.cash when this instance was initialized. - reinvest_dividends : boolean, optional - (Coming soon?) If True, reinvests any dividend income back into the - asset that paid it out. [default: False] + cash_out_dividends : boolean, optional + (Coming soon?) If False, reinvests any dividend income back into the + asset that paid it out. [default: True] logy : boolean, optional If True, the y-axis (account value in dollars) will have a @@ -1349,7 +1351,7 @@ def plot_assets(self, *tickers, start_value=None, reinvest_dividends=False, raise ValueError(f"{tk} is not part of your list of assets.") if start_value is None: start_value = self._starting_value - if reinvest_dividends: + if not cash_out_dividends: raise NotImplementedError('Coming soon...') # make separate colormaps for each ticker label diff --git a/strategies.py b/strategies.py index 6449017..5a7c619 100755 --- a/strategies.py +++ b/strategies.py @@ -730,7 +730,7 @@ def rebalance_satellite(self, day, verbose=False): # decimal.Decimal on self.cash/bench_cash, all entries in # self.assets[tk]['shares'], and can_spend & in/out_mkt_pr here can # prevent that, but it's slower than using floats...) - # (Also, for non-mutual funds, when reinvest_dividends=True, need to + # (Also, for non-mutual funds, when cash_out_dividends=False, need to # disallow all partial share purchases. Need to do the same for sales, # **except** when all shares are being sold.) max_in_sh = int(can_spend / in_mkt_pr) @@ -738,14 +738,14 @@ def rebalance_satellite(self, day, verbose=False): poss_in_fracs = (in_mkt_pr * poss_in_sh) / can_spend in_mkt_ideal = np.argmin(np.abs(poss_in_fracs - new_frac_in)) - if in_mkt_ideal == 0 and self.reinvest_dividends == True: + if in_mkt_ideal == 0 and not self.cash_out_dividends: # also sell partial shares in_mkt_sh = self.assets[in_mkt_tick]['shares'] my_pr('in_mkt partial shares (if any) will be sold!') in_mkt_delta = in_mkt_ideal - in_mkt_sh out_mkt_ideal = int((can_spend - in_mkt_pr * in_mkt_ideal) / out_mkt_pr) - if out_mkt_ideal == 0 and self.reinvest_dividends == True: + if out_mkt_ideal == 0 and not self.cash_out_dividends: # also sell partial shares out_mkt_sh = self.assets[out_mkt_tick]['shares'] my_pr('out_mkt partial shares (if any) will be sold!') diff --git a/walkthrough.ipynb b/walkthrough.ipynb index cabc9a6..c76c47f 100755 --- a/walkthrough.ipynb +++ b/walkthrough.ipynb @@ -233,7 +233,7 @@ " start_date=pd.Timestamp(2007, 5, 30),\n", " end_date=pd.Timestamp(2015, 6, 1),\n", " sat_rb_freq=6, tot_rb_freq=3, target_rb_day=-2,\n", - " reinvest_dividends=True)" + " cash_out_dividends=False)" ] }, { From e616730e233ee15ae99570d8218e279adef71706 Mon Sep 17 00:00:00 2001 From: ojustino Date: Thu, 2 Apr 2026 20:48:17 -0400 Subject: [PATCH 5/9] Give more helpful error on unequal number of dates --- simulator.py | 8 ++++++-- 1 file changed, 6 insertions(+), 2 deletions(-) diff --git a/simulator.py b/simulator.py index ce1c486..a748bae 100755 --- a/simulator.py +++ b/simulator.py @@ -569,8 +569,12 @@ def _validate_assets_dict(self, Portfolio, verbose): info['df'] = df # ensure that each asset has the same number of dates - num_dates = np.unique([len(assets[nm]['df'].index) for nm in assets]) - assert len(num_dates) == 1, 'some ticker DataFrames are missing dates' + num_dates = [tk['df'].size for tk in assets.values()] + if np.unique(num_dates).size != 1: + counts_by_ticker = {tk: num_dates[i] + for i, tk in enumerate(assets.keys())} + raise ValueError('Ticker dataFrames have unequal numbers of dates: ' + f"{counts_by_ticker}") return assets From e658433752eab2a5d2f10a5677143a4108707fe7 Mon Sep 17 00:00:00 2001 From: ojustino Date: Fri, 3 Apr 2026 01:25:04 -0400 Subject: [PATCH 6/9] Allow string start/end_date arguments in simulator --- .gitignore | 1 + binder/requirements.txt | 1 + binder/start | 3 +++ simulator.py | 37 +++++++++++++++++++++---------------- 4 files changed, 26 insertions(+), 16 deletions(-) create mode 100644 .gitignore create mode 100644 binder/start diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..4c49bd7 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.env diff --git a/binder/requirements.txt b/binder/requirements.txt index f55c877..4887671 100644 --- a/binder/requirements.txt +++ b/binder/requirements.txt @@ -3,3 +3,4 @@ matplotlib>=3 numpy<2.3 # up to date as of 1/2025 pandas<2.3 # up to date as of 1/2025 requests>=2.32.2 +python-dotenv diff --git a/binder/start b/binder/start new file mode 100644 index 0000000..727d22e --- /dev/null +++ b/binder/start @@ -0,0 +1,3 @@ +#!/bin/bash +export tiingo="901a2a03f9d57935c22df22ae5a5377cb8de6f22" +exec "$@" \ No newline at end of file diff --git a/simulator.py b/simulator.py index a748bae..6c45643 100755 --- a/simulator.py +++ b/simulator.py @@ -11,8 +11,6 @@ import requests import time -MY_API_KEY = '901a2a03f9d57935c22df22ae5a5377cb8de6f22' - class HistoricalSimulator(ABC): ''' The parent of a Strategy class that does the heavy lifting in simulating @@ -39,15 +37,15 @@ class HistoricalSimulator(ABC): simulation. Note that this is separate from the value of any initial shares held in Portfolio.assets. [default: $10,000] - start_date : `pandas.Timestamp` or `datetime.datetime`, optional + start_date : str or `pandas.Timestamp` or `datetime.datetime`, optional The first trading date in your simulation. If the market wasn't open on - your chosen date, the next market date will be chosen. - [default: pandas.Timestamp(2007, 5, 22)] + your chosen date, the closest market date afterward will be chosen. + [default: '2007-05-22'] - end_date : `pandas.Timestamp` or `datetime.datetime`, optional + end_date : str or `pandas.Timestamp` or `datetime.datetime`, optional The last trading date in your simulation. If the market wasn't open on - your chosen date, the last market date before it will be chosen. - [default: pandas.Timestamp(2015, 5, 22)] + your chosen date, the closest preceding market date will be chosen. + [default: '2015-05-22'] sat_rb_freq : float, optional The number of times per year to rebalance the satellite portion of your @@ -78,8 +76,7 @@ class HistoricalSimulator(ABC): ''' # earliest start dates: 1998-11-22, 2007-05-22, 2012-10-21 def __init__(self, Portfolio, cash=1e4, - start_date=pd.Timestamp(2007, 5, 22), - end_date=pd.Timestamp(2015, 5, 22), + start_date='2007-05-22', end_date='2015-05-22', sat_rb_freq=6, tot_rb_freq=1, target_rb_day=-2, cash_out_dividends=False, verbose=False): # make sure a PortfolioMaker object is present @@ -110,15 +107,15 @@ def __init__(self, Portfolio, cash=1e4, self.sat_rb_freq = sat_rb_freq self.tot_rb_freq = tot_rb_freq + # save dates over which analysis will take place + self.start_date = pd.Timestamp(start_date) + self.end_date = pd.Timestamp(end_date) + # estimate period needed to warm up strategy's statistic(s) (converting # real days to approx. market days) and subtract result from start_date mkt_to_real_days = 365.25 / 252.75 # denominator is avg mkt days in year buffer_days = int(self.window * mkt_to_real_days) + 5 - self.open_date = pd.Timestamp(start_date - timedelta(buffer_days)) - - # save dates over which analysis will take place - self.start_date = pd.Timestamp(start_date) - self.end_date = pd.Timestamp(end_date) + self.open_date = pd.Timestamp(self.start_date - timedelta(buffer_days)) # track the current simulation date self.today = self.open_date @@ -356,7 +353,7 @@ def call_tiingo(self, tick, open_date, 'endDate': end_date, 'format': 'json', 'resampleFreq': 'daily', - 'token': MY_API_KEY, + 'token': for_tiingo, } resp = requests.get(url, params=params, headers=headers) @@ -1508,3 +1505,11 @@ def normalize_price_bases(self): # (copied from HistoricalSimulator.__init__()) self._bench_cash = self.portfolio_value(self.start_date, at_close=False) self._starting_value = self._bench_cash + + +try: + from dotenv import dotenv_values, load_dotenv + for_tiingo = dotenv_values()['tiingo'] +except KeyError: + import os + for_tiingo = os.getenv('tiingo') From b0d4a1928890b6d5b84a101c0cf21b8c5ef15825 Mon Sep 17 00:00:00 2001 From: ojustino Date: Fri, 3 Apr 2026 01:41:59 -0400 Subject: [PATCH 7/9] Allow AttrDict tab completion; reserve OG attrs --- attr_dict.py | 18 ++++++++++++++++++ 1 file changed, 18 insertions(+) diff --git a/attr_dict.py b/attr_dict.py index 52cad55..3a20054 100644 --- a/attr_dict.py +++ b/attr_dict.py @@ -1,5 +1,7 @@ #!/usr/bin/python3 +reserved_dict_attrs = set(dir(dict)) | {'__dict__'} + class AttrDict(dict): ''' Allow keys of a dictionary to also be called like class attributes: @@ -25,6 +27,8 @@ def __init__(self, *args, **kwargs): # Handle setting new keys, turning any nested dicts into AttrDicts as well def __setitem__(self, key, val): + if isinstance(key, str) and key in reserved_dict_attrs: + raise KeyError(f"Key '{key}' reserved as original dict attribute") if isinstance(val, dict) and not isinstance(val, AttrDict): val = AttrDict(val) super().__setitem__(key, val) @@ -36,6 +40,8 @@ def update(self, *args, **kwargs): # Allow dict keys to be called, set, and deleted like class attributes def __getattr__(self, name): try: + # not concerned with reserved attrs since __getattr__ is only called + # when __getattribute__ (which will find them in dict) fails return self[name] except KeyError: raise AttributeError(name) @@ -51,3 +57,15 @@ def __delattr__(self, name): del self[name] except KeyError: raise AttributeError(name) + + # Allow tab completion + def __dir__(self): + # include normal dict attrs and methods + attrs = set(super().__dir__()) + + # include AttrDict keys that are valid variable names + # (e.g., no fully numeric or hyphen-containing keys) + attrs.update([key for key in self.keys() + if isinstance(key, str) and key.isidentifier()]) + + return sorted(attrs) From 194edec06ba61fdb31459adc36e2267f7e330206 Mon Sep 17 00:00:00 2001 From: ojustino Date: Fri, 3 Apr 2026 01:25:04 -0400 Subject: [PATCH 8/9] Allow string start/end_date arguments in simulator --- binder/start | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-) diff --git a/binder/start b/binder/start index 727d22e..50c454b 100644 --- a/binder/start +++ b/binder/start @@ -1,3 +1,3 @@ #!/bin/bash export tiingo="901a2a03f9d57935c22df22ae5a5377cb8de6f22" -exec "$@" \ No newline at end of file +exec "$@" From d6cbc957c7a84119cd3c5c93f7f02012645ec64b Mon Sep 17 00:00:00 2001 From: ojustino Date: Wed, 8 Apr 2026 18:55:59 -0400 Subject: [PATCH 9/9] Normalize/simulate splits+dividends more correctly --- .github/workflows/cron_sim_tests.yml | 2 +- .github/workflows/push_sim_tests.yml | 2 +- README.md | 1 - binder/requirements.txt | 4 +- simulator.py | 205 ++++++++++++++++++++++----- test_suite.py | 12 +- walkthrough.ipynb | 3 +- 7 files changed, 177 insertions(+), 52 deletions(-) diff --git a/.github/workflows/cron_sim_tests.yml b/.github/workflows/cron_sim_tests.yml index 9960412..596f06b 100644 --- a/.github/workflows/cron_sim_tests.yml +++ b/.github/workflows/cron_sim_tests.yml @@ -14,7 +14,7 @@ jobs: strategy: fail-fast: false matrix: - python-version: [3.9, "3.10"] + python-version: ["3.10", 3.12] steps: - name: Set up Python diff --git a/.github/workflows/push_sim_tests.yml b/.github/workflows/push_sim_tests.yml index 944a946..cdd417a 100644 --- a/.github/workflows/push_sim_tests.yml +++ b/.github/workflows/push_sim_tests.yml @@ -18,7 +18,7 @@ jobs: strategy: fail-fast: false matrix: - python-version: [3.9, "3.10"] + python-version: ["3.10", 3.12] steps: - name: Set up Python diff --git a/README.md b/README.md index 7c292a2..d0e7b4b 100644 --- a/README.md +++ b/README.md @@ -36,7 +36,6 @@ Now, I actually use a `Strategy` class to make decisions for my IRA. **Skills used:**
-_(bear with me; I'm job-hunting)_ data(Frame) manipulation with `pandas`, fetching data over HTTP with `requests`, object-oriented programming with abstract base classes, visualization with diff --git a/binder/requirements.txt b/binder/requirements.txt index 4887671..a0e20f3 100644 --- a/binder/requirements.txt +++ b/binder/requirements.txt @@ -1,6 +1,6 @@ # required packages for backstroke matplotlib>=3 -numpy<2.3 # up to date as of 1/2025 -pandas<2.3 # up to date as of 1/2025 +numpy<2.3 # up to date as of 1/2025. v2.3 requires py >3.10. seems OK otherwise +pandas<2.3 # up to date as of 1/2025. v2.3 looks OK if no copy-on-write issues. v3 requires py >3.10 but seems OK otherwise requests>=2.32.2 python-dotenv diff --git a/simulator.py b/simulator.py index 6c45643..8826d53 100755 --- a/simulator.py +++ b/simulator.py @@ -161,6 +161,10 @@ def __init__(self, Portfolio, cash=1e4, self.bench_names = [key for key, info in self.assets.items() if info['label'] == 'benchmark'] + # track whether prices have been normalized by user + self._div_scaled_prices = None + self._split_scaled_prices = None + # run the loop? @property @@ -1011,7 +1015,9 @@ def rebalance_portfolio(self, day, verbose=False): def _check_dividends(self, main_portfolio=True, verbose=False): ''' - Called in self.begin_time_loop(). + Called in self.begin_time_loop(). Only relevant when price data does not + inherently include the effects of dividends [e.g., user called + normalize_price_data(by_dividends=False) before simulation]. Checks whether assets currently held in a portfolio are paying out dividends on a given day. If so, accepts the dividend as partial shares @@ -1073,6 +1079,49 @@ def _check_dividends(self, main_portfolio=True, verbose=False): else: self.bench_cash += add_cash + def _check_splits(self, main_portfolio=True, verbose=False): + ''' + Called in self.begin_time_loop(). Only relevant when price data does not + inherently include the effects of stock splits [e.g., user called normalize_price_data(by_splits=False) before simulation]. + + Checks whether assets currently held in a portfolio are undergoing a + stock split on a given day. If so, adjusts the portfolio's number of + shares held accordingly. + + Arguments + --------- + + main_portfolio : boolean, optional + If True, checks the main strategy's core/satellite portfolio. + If False, checks the benchmark portfolio. [default: True] + + verbose : boolean, optional + If True, prints information when splits occur in the simulation. + [default: False] + ''' + my_pr = lambda *args, **kwargs: (print(*args, **kwargs) + if verbose else None) + + # choose assets to check for stock splits + tickers = (self.core_names + self.sat_names if main_portfolio + else self.bench_names) + + # check each asset for a stock split on the indicated day + for tk in tickers: + # if there's none, skip to the next ticker + split_factor = self.assets[tk]['df'].loc[self.today, 'splitFactor'] + if split_factor == 1: + continue + + # if this ticker isn't currently in the portfolio, skip to the next + shares_held = self.assets[tk]['shares'] + if shares_held == 0: + continue + + # barring those, adjust the number of shares + # (e.g., for a 4-to-1 split, splitFactor == 0.25) + self.assets[tk]['shares'] *= split_factor + def begin_time_loop(self, verbose=False): ''' Called in __init__ of HistoricalSimulator or by user???? @@ -1094,6 +1143,30 @@ def begin_time_loop(self, verbose=False): my_pr = lambda *args, **kwargs: (print(*args, **kwargs) if verbose else None) + # ensure dividend reinvestment choice makes sense + if self._div_scaled_prices is None: + # using Tiingo-adjusted prices, which include effects of dividends + implicit_dividends = True + else: + # normalize_price_bases() used; maybe includes dividend effects + implicit_dividends = self._div_scaled_prices + + if self.cash_out_dividends and implicit_dividends: + raise ValueError("cash_out_dividends is True, but loop cannot " + "cash them out when adjusted price data " + "inherently includes dividend effects. Either a) " + "set cash_out_dividends to False, or b) call " + "`normalize_price_bases(by_dividends=False)`. " + "Then, try begin_time_loop() again.") + + # decide whether the simulator should handle splits manually (UNCOMMON) + if self._split_scaled_prices is None: + # using Tiingo-adjusted prices, which include effects of splits + implicit_splits = True + else: + # normalize_price_bases() used; maybe includes split effects + implicit_splits = self._split_scaled_prices + # make lists to track values over time to_strategy_results = [] to_bench_results = [] @@ -1107,12 +1180,18 @@ def begin_time_loop(self, verbose=False): if self.today >= self.start_date: self.on_new_day() - # "PRE-OPEN": cash in dividends from ex-date (YESTERDAY's) holdings, - # once for main portfolio and once for benchmark - if self.today >= self.start_date: + # "PRE-OPEN": if simulator handles dividends, cash them based on ex- + # date (YESTERDAY's) holdings. main portfolio first, then benchmark + if self.today >= self.start_date and not implicit_dividends: self._check_dividends(verbose=verbose) self._check_dividends(main_portfolio=False, verbose=False) + # "PRE-OPEN": if simulator handles stock splits (UNCOMMON), update + # portfolio share counts if any occurred today + if self.today >= self.start_date and not implicit_splits: + self._check_splits(verbose=verbose) + self._check_splits(main_portfolio=False, verbose=False) + # AT OPEN: rebalance if needed if self.today in self.rb_info.index: # 2x faster than check by index # make rebalance calculations based on YESTERDAY'S STATS @@ -1422,13 +1501,31 @@ def plot_assets(self, *tickers, start_value=None, cash_out_dividends=True, plt.show() - def normalize_price_bases(self): + def normalize_price_bases(self, by_dividends=True, by_splits=True): ''' - Takes a dataFrame from a symbol's 'df' key in the `assets` dictionary of - a Strategy instance (e.g. sim.assets['AAPL']['df']) and adjusts the - dataFrame's 'adj' columns (close, high, low, open) to the basis of the - prices on the Strategy instance's end date. **This makes simulation - results reproducible over time.** + Adjusts all dataFrames in the `assets` dictionary of a Strategy instance + (e.g. sim.assets['AAPL']['df']) so their 'adj' columns (close, high, + low, open) are normalized to the bases of the prices on the Strategy + instance's end date. **This makes simulation results reproducible over + time.** + + For desired behavior, run before self.begin_time_loop(). + + Arguments + --------- + + by_dividends : boolean, optional + Whether to normalize by dividend payments. If True, dividend + payments will be ignored in the simulation since the adjustment will + already account for them (same as default behavior with Tiingo + adjustments). If False, the simulation will account for dividends. + [default: True] + + by_splits : boolean, optional + Whether to normalize by stock splits. If True, stock splits will be + ignored in the simulation since the adjustment will already account + for them (same as default behavior with Tiingo adjustments). If + False, the simulation will account for splits. [default: True] This is useful because Tiingo's own 'adj' values are adjusted to the basis of the prices on the date the data were queried. This means the @@ -1449,36 +1546,43 @@ def normalize_price_bases(self): 2026-03-30 (conducted on the latter date) was 0.02% different in price from this method's adjClose. ''' + cols = ['close', 'high', 'low', 'open'] for tkr, val in self.assets.items(): df = val['df'].copy() - cols = ['close', 'high', 'low', 'open'] - - # split factor for each date through reversed cumulative product - # (inspiration from https://stackoverflow.com/questions/62130566/) - tot_splits = df['splitFactor'][::-1].cumprod()[::-1].shift(-1, fill_value=1.0).values - tot_splits_cast = np.tile(tot_splits, (len(cols), 1)).T - - # get prices on dividend ex dates (immediately preceding payday), - # excluding any that aren't present in the dataFrame - div_dts_all = df[df['divCash'] != 0].index - pre_div_inds_all = df.index.get_indexer_for(div_dts_all) - pre_div_inds = pre_div_inds_all[pre_div_inds_all > 0] - pre_div_prices = df.iloc[pre_div_inds - 1][cols] - - # get pay dates and amounts of remaining dividends - div_dts = div_dts_all[pre_div_inds_all > 0] - div_amts = df.loc[div_dts, 'divCash'].values - div_amts_cast = np.tile(div_amts, (len(cols), 1)).T - - # calculate dividend adjustments on relevant price data - # (div_adjs_by_dt[::-1].cumprod()[::-1] == old tot_div_adjs) - div_adjs_by_dt = ((pre_div_prices - div_amts_cast) / pre_div_prices) - - # factor each dividend's adj. into all days preceding its payday - divFactors = pd.DataFrame(index=df.index, columns=cols, - data=1, dtype=np.float64) - for dt in div_adjs_by_dt.index: - divFactors.loc[divFactors.index <= dt] *= div_adjs_by_dt.loc[dt] + + if by_splits: + # split factor for each date through reversed cumulative product + # (inspiration from https://stackoverflow.com/q/62130566/) + tot_splits = df['splitFactor'][::-1].cumprod()[::-1].shift(-1, fill_value=1.0).values + tot_splits_cast = np.tile(tot_splits, (len(cols), 1)).T + else: + tot_splits_cast = 1.0 + + if by_dividends: + # get prices on dividend ex dates (immediately preceding payday) + # while excluding any that aren't present in the dataFrame + div_dts_all = df[df['divCash'] != 0].index + pre_div_inds_all = df.index.get_indexer_for(div_dts_all) + pre_div_inds = pre_div_inds_all[pre_div_inds_all > 0] + pre_div_prices = df.iloc[pre_div_inds - 1][cols] + + # get pay dates and amounts of remaining dividends + div_dts = div_dts_all[pre_div_inds_all > 0] + div_amts = df.loc[div_dts, 'divCash'].values + div_amts_cast = np.tile(div_amts, (len(cols), 1)).T + + # calculate dividend adjustments on relevant price data + # (div_adjs_by_dt[::-1].cumprod()[::-1] == old tot_div_adjs) + div_adjs_by_dt = ((pre_div_prices - div_amts_cast) + / pre_div_prices) + + # factor each dividend's adj. into all days preceding its payday + divFactors = pd.DataFrame(index=df.index, columns=cols, + data=1, dtype=np.float64) + for dt in div_adjs_by_dt.index: + divFactors.loc[divFactors.index <= dt] *= div_adjs_by_dt.loc[dt] + else: + divFactors = 1.0 # NOT NEEDED; DIVIDENDS ARE ALREADY BAKED INTO THE ADJUSTMENT # # calculate each dividend's value as shares of previous (unadj.) close @@ -1496,16 +1600,39 @@ def normalize_price_bases(self): # copy Tiingo's original adj columns to the end of the column list adj_cols = ['adj' + c.title() for c in cols] old_adj_cols = ['OG_' + c for c in adj_cols] - val['df'][old_adj_cols] = val['df'][adj_cols].copy() + if not any(col in df.columns for col in old_adj_cols): + # don't overwrite if cols exist from a previous standardization + val['df'][old_adj_cols] = val['df'][adj_cols].copy() # add the readjusted price columns to the original dataFrame val['df'][adj_cols] = df[cols] / tot_splits_cast * divFactors + # update price adjustment trackers + self._div_scaled_prices = by_dividends + self._split_scaled_prices = by_splits + # reset benchmark portfolio starting value to reflect any price changes # (copied from HistoricalSimulator.__init__()) self._bench_cash = self.portfolio_value(self.start_date, at_close=False) self._starting_value = self._bench_cash + def undo_normalize_price_bases(self): + ''' + Reverse the effects of self.normalize_price_bases(), restoring 'adj' + columns (close, high, low, open) of the dataFrames in the `assets` + dictionary of a Strategy instance to original values from the download + (which follow Tiingo's adjustments). + ''' + adj_cols = ['adjClose', 'adjHigh', 'adjLow', 'adjOpen'] + for tkr, val in self.assets.items(): + old_adj_cols = ['OG_' + c for c in adj_cols] + val['df'][adj_cols] = val['df'][old_adj_cols].copy() + val['df'].drop(columns=old_adj_cols) + + # update price adjustment trackers + self._div_scaled_prices = None + self._split_scaled_prices = None + try: from dotenv import dotenv_values, load_dotenv diff --git a/test_suite.py b/test_suite.py index 8d352ca..9b5d138 100644 --- a/test_suite.py +++ b/test_suite.py @@ -137,9 +137,9 @@ def test_bnh(): bnh = BuyAndHoldStrategy(pf1, start_date=pd.Timestamp(2000, 8, 1), end_date=pd.Timestamp(2016, 1, 1), - cash=10000, reinvest_dividends=False, + cash=10000, cash_out_dividends=True, tot_rb_freq=12, target_rb_day=0) - bnh.normalize_price_bases() + bnh.normalize_price_bases(by_dividends=False) # append another rebalance date to test the process nu_prices = {'MCD': 117.25, 'TGT': 71.84, 'CPB': 43.83, 'SPY': 200.49} @@ -200,7 +200,7 @@ def test_sma(): sma = SMAStrategy(pf2, window=100, start_date=pd.Timestamp(2019, 12, 12), end_date=pd.Timestamp(2020, 8, 13), - cash=1738.29, reinvest_dividends=True, + cash=1738.29, cash_out_dividends=False, sat_rb_freq=365.25, tot_rb_freq=12, target_rb_day=8) sma.normalize_price_bases() @@ -248,7 +248,7 @@ def test_vlt(): Deals with VolTargetStrategy. In addition to common focuses, also tests HistoricalSimulator's plot_results. - NOTE: VolTargetStrategy has problems when reinvest_dividends=True because + NOTE: VolTargetStrategy has problems when cash_out_dividends=False because it can mostly only sell whole shares. When fractions build up, it thinks there's $$ to spend that actually can't be touched unless it's entirely liquidating an asset that has fractional shares. it could really use a @@ -266,9 +266,9 @@ def test_vlt(): vlt = VolTargetStrategy(pf3, window=30, vol_target=.15, start_date=pd.Timestamp(2018, 7, 27), end_date=pd.Timestamp(2019, 7, 31), - cash=5500, reinvest_dividends=False, + cash=5500, cash_out_dividends=True, sat_rb_freq=12, tot_rb_freq=4, target_rb_day=-3) - vlt.normalize_price_bases() + vlt.normalize_price_bases(by_dividends=False) # run simulation vlt.begin_time_loop() diff --git a/walkthrough.ipynb b/walkthrough.ipynb index c76c47f..ed50d7a 100755 --- a/walkthrough.ipynb +++ b/walkthrough.ipynb @@ -230,8 +230,7 @@ "outputs": [], "source": [ "sim = SMAStrategy(pf, window=200, cash=1e4,\n", - " start_date=pd.Timestamp(2007, 5, 30),\n", - " end_date=pd.Timestamp(2015, 6, 1),\n", + " start_date='2007-05-30', end_date='2015-06-01',\n", " sat_rb_freq=6, tot_rb_freq=3, target_rb_day=-2,\n", " cash_out_dividends=False)" ]