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/.gitignore b/.gitignore new file mode 100644 index 0000000..4c49bd7 --- /dev/null +++ b/.gitignore @@ -0,0 +1 @@ +.env 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/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) diff --git a/binder/requirements.txt b/binder/requirements.txt index f55c877..a0e20f3 100644 --- a/binder/requirements.txt +++ b/binder/requirements.txt @@ -1,5 +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/binder/start b/binder/start new file mode 100644 index 0000000..50c454b --- /dev/null +++ b/binder/start @@ -0,0 +1,3 @@ +#!/bin/bash +export tiingo="901a2a03f9d57935c22df22ae5a5377cb8de6f22" +exec "$@" 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 e56840a..8826d53 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 @@ -66,20 +64,21 @@ 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] ''' # 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, - 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 ' @@ -108,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 @@ -132,7 +131,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) @@ -162,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 @@ -354,7 +357,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) @@ -567,8 +570,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 @@ -1008,11 +1015,13 @@ 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 - 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 +1062,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" @@ -1070,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???? @@ -1091,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 = [] @@ -1104,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 @@ -1306,7 +1388,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 +1406,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 +1431,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 @@ -1418,3 +1500,143 @@ def plot_assets(self, *tickers, start_value=None, reinvest_dividends=False, return ax plt.show() + + def normalize_price_bases(self, by_dividends=True, by_splits=True): + ''' + 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 + 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. + ''' + cols = ['close', 'high', 'low', 'open'] + for tkr, val in self.assets.items(): + df = val['df'].copy() + + 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 + # 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] + 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 + for_tiingo = dotenv_values()['tiingo'] +except KeyError: + import os + for_tiingo = os.getenv('tiingo') 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/test_suite.py b/test_suite.py index 563d04b..9b5d138 100644 --- a/test_suite.py +++ b/test_suite.py @@ -17,75 +17,90 @@ 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. ''' - for _, val in self.assets.items(): + for tkr, val in self.assets.items(): 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__()) + self._bench_cash = self.portfolio_value(self.start_date, at_close=False) + self._starting_value = self._bench_cash def _compare_figs(ax, img_root): ''' @@ -118,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, + cash=10000, cash_out_dividends=True, tot_rb_freq=12, target_rb_day=0) - - bnh._rewind_prices = MethodType(_rewind_prices, bnh) - bnh._rewind_prices() + 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} @@ -177,28 +190,26 @@ 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) 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, + cash=1738.29, cash_out_dividends=False, 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() # 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 +219,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,14 +239,16 @@ 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(): ''' 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 @@ -244,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, + cash=5500, cash_out_dividends=True, 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(by_dividends=False) # run simulation vlt.begin_time_loop() diff --git a/walkthrough.ipynb b/walkthrough.ipynb index f51bbe7..ed50d7a 100755 --- a/walkthrough.ipynb +++ b/walkthrough.ipynb @@ -230,10 +230,9 @@ "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", - " reinvest_dividends=True)" + " cash_out_dividends=False)" ] }, { @@ -263,10 +262,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 +316,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 +335,10 @@ " \n", " \n", " \n", + " \n", + " \n", + " \n", + " \n", " \n", " \n", " \n", @@ -326,13 +349,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 +368,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 +387,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 +406,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 +425,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 +444,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 +487,7 @@ }, { "cell_type": "code", - "execution_count": 11, + "execution_count": 12, "metadata": { "scrolled": true }, @@ -487,6 +538,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 +599,7 @@ "name": "python", "nbconvert_exporter": "python", "pygments_lexer": "ipython3", - "version": "3.7.8" + "version": "3.9.0" } }, "nbformat": 4,