From: Scott Gasch Date: Sat, 9 Apr 2022 15:37:41 +0000 (-0700) Subject: Updated. X-Git-Url: https://wannabe.guru.org/gitweb/?a=commitdiff_plain;p=retire.git Updated. --- diff --git a/.gitignore b/.gitignore deleted file mode 100644 index 18edfe2..0000000 --- a/.gitignore +++ /dev/null @@ -1,2 +0,0 @@ -*.pyc -*secret* diff --git a/account.py b/account.py new file mode 100644 index 0000000..78035a3 --- /dev/null +++ b/account.py @@ -0,0 +1,417 @@ +#!/usr/bin/env python3 + +from abc import abstractmethod +import logging +from typing import Optional + +from type.money import Money + +from person import Person +import data +from taxman import TaxCollector + + +logger = logging.getLogger(__name__) + + +class Account(object): + def __init__(self, name: str, owner: Person): + self.name = name + self.owner = owner + + def get_name(self) -> str: + return self.name + + def get_owner(self) -> Person: + return self.owner + + def belongs_to_scott(self) -> bool: + return self.get_owner() == Person.SCOTT + + def belongs_to_lynn(self) -> bool: + return self.get_owner() == Person.LYNN + + @abstractmethod + def get_balance(self) -> Money: + """Returns the account's current balance""" + pass + + @abstractmethod + def appreciate(self, rate: float) -> Money: + """Grow/shrink the balance using rate (<1 = shrink, 1.0=identity, >1 = + grow). Return the new balance. Raise on error. + """ + pass + + @abstractmethod + def withdraw( + self, amount: Money, taxes: Optional[TaxCollector] = None + ) -> Money: + """Withdraw money from the account and return the Money. Raise + on error. If the TaxCollector is passed, the money will be + recorded as income if applicable per the account type. + """ + pass + + @abstractmethod + def is_age_restricted(self) -> bool: + """Is this account age restricted. Subclasses should implement.""" + pass + + @abstractmethod + def has_rmd(self) -> bool: + """Does this account have a required minimum distribution? Sub- + classes should implement.""" + pass + + @abstractmethod + def do_rmd_withdrawal(self, owner_age: int, taxes: Optional[TaxCollector]) -> Money: + """Compute the magnitude of any RMD, withdraw it from the account and + return it. If TaxCollector is provided, record the distribution as + income if applicable. Raise on error.""" + pass + + @abstractmethod + def has_roth(self) -> bool: + """Does this account have a Roth balance?""" + pass + + @abstractmethod + def dump_final_report(self) -> None: + """Produce a simulation final report.""" + pass + + +class AgeRestrictedTaxDeferredAccount(Account): + """Account object used to represent an age-restricted tax deferred + account such as a 401(k), IRA or annuity.""" + + def __init__(self, + name: str, + owner: Person, + *, + total_balance: Money = Money(0), + roth_subbalance: Money = Money(0)): + """C'tor for this class takes a roth_amount, the number of dollars + in the account that are in-plan Roth and can be taken out tax + free. It keeps this pile separate from the pretax pile and + tries to estimate taxes.""" + super().__init__(name, owner) + self.roth: Money = roth_subbalance + self.pretax: Money = total_balance - roth_subbalance + self.total_roth_withdrawals: Money = 0 + self.total_pretax_withdrawals: Money = 0 + self.total_investment_gains: Money = 0 + self.total_roth_conversions: Money = 0 + + def is_age_restricted(self) -> bool: + return True + + def withdraw(self, amount: Money, taxes: Optional[TaxCollector]) -> Money: + """Assume that money withdrawn from this account will be a mixture + of pretax funds (which count as ordinary income) and Roth funds + (which are available tax-free). Assume that the ratio of pretax + to Roth in this overall account determines the amount from each + partition in this withdrawal.""" + balance = self.get_balance() + if balance < amount: + raise Exception("Insufficient funds") + + ratio = float(self.roth) / float(balance) + roth_part = amount * ratio + pretax_part = amount - roth_part + if roth_part > 0: + self.roth -= roth_part + self.total_roth_withdrawals += roth_part + logger.debug( + f'Account {self.name} satisfying {amount} with {roth_part} Roth.' + ) + taxes.record_roth_income(roth_part) + + self.pretax -= pretax_part + self.total_pretax_withdrawals += pretax_part + logger.debug( + f'Account {self.name} satisfying {amount} with {pretax_part} pretax.' + ) + taxes.record_ordinary_income(pretax_part) + return amount + + def appreciate(self, rate: float) -> Money: + """In this class we basically ignore the balance field in favor of + just using pretax and roth so that we can track them separately.""" + old_pretax = self.pretax + self.pretax *= rate + delta = self.pretax - old_pretax + self.total_investment_gains += delta + old_roth = self.roth + self.roth *= rate + delta = self.roth - old_roth + self.total_investment_gains += delta + return self.get_balance() + + def get_balance(self): + """In this class we basically ignore the balance field in favor of + just using pretax and roth so that we can track them separately.""" + return self.pretax + self.roth + + def has_rmd(self): + return True + + def do_rmd_withdrawal(self, owner_age, taxes): + balance = self.get_balance() + if balance > 0 and owner_age >= 72: + rmd_factor = data.get_actuary_number_years_to_live(owner_age) + amount = balance / rmd_factor + self.withdraw(amount, taxes) + return amount + return 0 + + def has_roth(self): + return True + + def do_roth_conversion(self, amount: Money) -> Money: + if amount <= 0: + return Money(0) + if self.pretax >= amount: + self.roth += amount + self.pretax -= amount + self.total_roth_conversions += amount + logger.debug( + f'Account {self.name} executed pre-tax --> Roth conversion of {amount}' + ) + return amount + elif self.pretax > 0: + actual_amount = self.pretax + self.roth += actual_amount + self.pretax = 0 + self.total_roth_conversions += actual_amount + logger.debug( + f'Account {self.name} executed pre-tax --> Roth conversion of ' + + f'{actual_amount}' + ) + return actual_amount + return Money(0) + + def dump_final_report(self): + print(f'Account: {self.name}:') + print(" %-50s: %18s" % ("Ending balance", self.get_balance())) + print(" %-50s: %18s" % ("Total investment gains", + self.total_investment_gains)) + print(" %-50s: %18s" % ("Total Roth withdrawals", + self.total_roth_withdrawals)) + print(" %-50s: %18s" % ("Total pre-tax withdrawals", + self.total_pretax_withdrawals)) + print(" %-50s: %18s" % ("Total pre-tax converted to Roth", + self.total_roth_conversions)) + + +class AgeRestrictedRothAccount(AgeRestrictedTaxDeferredAccount): + """This is an object to represent a Roth account like a Roth IRA. All + money in here is tax free. Most of the base account class works here + including the implementation of withdraw() which says that none of the + money withdrawn was taxable.""" + + def __init__(self, + name: str, + owner: Person, + *, + total_balance: Money = 0): + super().__init__( + name, + owner, + total_balance=total_balance, + roth_subbalance=total_balance + ) + + def has_rmd(self): + return False + + def do_rmd_withdrawal(self, owner_age, taxes): + raise Exception("This account has no RMDs") + + def do_roth_conversion(self, amount) -> Money: + return Money(0) + + +class BrokerageAccount(Account): + """A class to represent money in a taxable brokerage account.""" + + def __init__(self, + name: str, + owner: Person, + *, + total_balance = Money(0), + cost_basis = Money(0)): + """The c'tor of this class partitions balance into three pieces: + the cost_basis (i.e. how much money was invested in the account), + the short_term_gain (i.e. appreciation that has been around for + less than a year) and long_term_gain (i.e. appreciation that has + been around for more than a year). We separate these because + taxes on long_term_gain (and qualified dividends, which are not + modeled) are usually lower than short_term_gain. Today those + are taxed at 15% and as ordinary income, respectively.""" + super().__init__(name, owner) + self.cost_basis = cost_basis + self.short_term_gain = Money(0) + self.long_term_gain = total_balance - cost_basis + self.total_cost_basis_withdrawals = Money(0) + self.total_long_term_gain_withdrawals = Money(0) + self.total_short_term_gain_withdrawals = Money(0) + self.total_investment_gains = Money(0) + + def withdraw(self, amount: Money, taxes: Optional[TaxCollector]) -> Money: + """Override the base class' withdraw implementation since we're + dealing with three piles of money instead of one. When you sell + securities to get money out of this account the gains are taxed + (and the cost_basis part isn't). Assume that the ratio of + cost_basis to overall balance can be used to determine how much + of the withdrawal will be taxed (and how).""" + balance = self.get_balance() + if balance < amount: + raise Exception("Insufficient funds") + + if self.cost_basis > 0 and (self.short_term_gain + self.long_term_gain) > 0: + return self._withdraw_with_ratio(amount, taxes) + else: + return self._withdraw_waterfall(amount, taxes) + + def _withdraw_short_term_gain(self, amount: Money, taxes: Optional[TaxCollector]) -> Money: + if self.short_term_gain >= amount: + self.short_term_gain -= amount + self.total_short_term_gain_withdrawals += amount + if taxes is not None: + taxes.record_short_term_gain(amount) + return amount + raise Exception('Insufficient funds') + + def _withdraw_long_term_gain(self, amount: Money, taxes: Optional[TaxCollector]) -> Money: + if self.long_term_gain >= amount: + self.long_term_gain -= amount + self.total_long_term_gain_withdrawals += amount + if taxes is not None: + taxes.record_dividend_or_long_term_gain(amount) + return amount + raise Exception('Insufficient funds') + + def _withdraw_cost_basis(self, amount: Money, taxes: Optional[TaxCollector]) -> Money: + if self.cost_basis >= amount: + self.cost_basis -= amount + self.total_cost_basis_withdrawals += amount + return amount + raise Exception('Insufficient funds') + + def _withdraw_with_ratio(self, amount: Money, taxes: Optional[TaxCollector]) -> Money: + ratio = float(self.cost_basis) / float(self.get_balance()) + invested_capital_part = amount * ratio + invested_capital_part.truncate_fractional_cents() + gains_part = amount - invested_capital_part + gains_part -= 0.01 + if self.cost_basis >= invested_capital_part: + self._withdraw_cost_basis(invested_capital_part, taxes) + logger.debug( + f'Account {self.name}: satisfying {invested_capital_part} from cost basis funds.' + ) + logger.debug( + f'Account {self.name}: satisfying {gains_part} from investment gains...' + ) + self._withdraw_from_gains(gains_part, taxes) + else: + logger.debug( + f'Account {self.name}: satisfying {gains_part} from investment gains...' + ) + self._withdraw_from_gains(amount, taxes) + return amount + + def _withdraw_waterfall(self, amount: Money, taxes: Optional[TaxCollector]) -> Money: + to_find = amount + if self.short_term_gain > 0: + if to_find < self.short_term_gain: + self.short_term_gain -= to_find + self.total_short_term_gain_withdrawals += to_find + to_find = Money(0) + else: + to_find -= self.short_term_gain + self.total_short_term_gain_withdrawals += self.short_term_gain + self.short_term_gain = Money(0) + if self.long_term_gain > 0: + if to_find < self.long_term_gain: + self.long_term_gain -= to_find + self.total_long_term_gain_withdrawals += to_find + to_find = Money(0) + else: + to_find -= self.long_term_gain + self.total_long_term_gain_withdrawals += self.long_term_gain + self.long_term_gain = Money(0) + if self.cost_basis > 0: + if to_find < self.cost_basis: + self.cost_basis -= to_find + to_find = Money(0) + else: + to_find -= self.cost_basis + self.cost_basis = Money(0) + assert(to_find == Money(0)) + + def _withdraw_from_gains(self, amount: Money, taxes: Optional[TaxCollector]) -> Money: + """Withdraw some money from gains. Prefer the long term ones if + possible.""" + to_find = amount + if to_find > (self.long_term_gain + self.short_term_gain): + raise Exception("Insufficient funds") + + if self.long_term_gain >= to_find: + self._withdraw_long_term_gain(to_find, taxes) + logger.debug( + f'Account {self.name}: satisfying {to_find} from long term gains.' + ) + return to_find + + logger.debug( + f'Account {self.name}: satisfying {self.long_term_gain} from long term gains ' + + '(exhausting long term gains)' + ) + self._withdraw_long_term_gain(self.long_term_gain, taxes) + to_find -= self.long_term_gain + self._withdraw_short_term_gain(to_find, taxes) + logger.debug( + f'Account {self.name}: satisfying {to_find} from short term gains' + ) + return amount + + def get_balance(self) -> Money: + """We're ignoring the base class' balance field in favor of tracking + it as three separate partitions of money.""" + return self.cost_basis + self.long_term_gain + self.short_term_gain + + def appreciate(self, rate: float) -> Money: + """Appreciate... another year has passed so short_term_gains turn into + long_term_gains and the appreciation is our new short_term_gains.""" + balance = self.get_balance() + gain = balance * (rate - 1.0) # Note: rate is something like 1.04 + self.total_investment_gains += gain + self.long_term_gain += self.short_term_gain + self.short_term_gain = gain + return self.get_balance() + + def is_age_restricted(self) -> bool: + return False + + def has_rmd(self) -> bool: + return False + + def has_roth(self) -> bool: + return False + + def do_roth_conversion(self, amount): + return Money(0) + + def dump_final_report(self): + print(f'Account {self.name}:') + print(" %-50s: %18s" % ("Ending balance", self.get_balance())) + print(" %-50s: %18s" % ("Total investment gains", + self.total_investment_gains)) + print(" %-50s: %18s" % ("Total cost basis withdrawals", + self.total_cost_basis_withdrawals)) + print(" %-50s: %18s" % ("Total long term gain withdrawals", + self.total_long_term_gain_withdrawals)) + print(" %-50s: %18s" % ("Total short term gain withdrawals", + self.total_short_term_gain_withdrawals)) diff --git a/accounts.py b/accounts.py deleted file mode 100644 index 2ff804d..0000000 --- a/accounts.py +++ /dev/null @@ -1,428 +0,0 @@ -import constants -import utils -from money import * - -class account(object): - """This defines an account base class which inherits from object, the - default base class in python. This is not a 100% abstract class, it - includes some default fields (like balance and name) and methods that - define behaviors (withdraw, appreciate, etc...). Several subclasses - are defined below.""" - - def __init__(self, name, owner): - """Constructor for account object takes a name and owner""" - self.name = name - assert constants.is_valid_owner(owner), "Bad account owner" - self.owner = owner - - def get_name(self): - return self.name - - def get_owner(self): - return self.owner - - def belongs_to_scott(self): - return self.get_owner() == constants.SCOTT - - def belongs_to_lynn(self): - return self.get_owner() == constants.LYNN - - def get_balance(self): - """Return the current account balance.""" - pass - - def appreciate(self, multiplier): - """Grow the balance using rate.""" - pass - - def withdraw(self, amount, taxes): - """Withdraw money from the account if possible. Throws otherwise. - Money should be registered with taxes so that we can approximate - taxes due, too.""" - pass - - def deposit(self, amount): - """Deposit money into the account.""" - pass - - def is_age_restricted(self): - """Is this account age restricted. Subclasses should implement.""" - pass - - def has_rmd(self): - """Does this account have a required minimum distribution? Sub- - classes should implement.""" - pass - - def do_rmd_withdrawal(self, owner_age, taxes): - """Handle RMD withdrawals for account.""" - pass - - def has_roth(self): - """Does this account have a Roth part?""" - pass - - def dump_final_report(self): - """Output account-specific info for the final simulation report.""" - print " " + self.name + ":" - -class age_restricted_tax_deferred_account(account): - """Account object used to represent an age-restricted tax deferred - account such as a 401(k), IRA or annuity.""" - - def __init__(self, total_balance, roth_amount_subset, name, owner): - """C'tor for this class takes a roth_amount, the number of dollars - in the account that are in-plan Roth and can be taken out tax - free. It keeps this pile separate from the pretax pile and - tries to estimate taxes.""" - assert total_balance >= 0, "Initial balance must be >= 0" - assert roth_amount_subset <= total_balance, "Roth subset too high!" - self.roth = money(roth_amount_subset) - self.pretax = total_balance - money(roth_amount_subset) - self.total_roth_withdrawals = money(0) - self.total_pretax_withdrawals = money(0) - self.total_investment_gains = money(0) - self.total_roth_conversions = money(0) - self.initial_balance = self.get_balance() - assert self.initial_balance >= 0, "Bad initial balance" - - # This calls the super class' c'tor. - account.__init__(self, name, owner) - - # These accounts are all age-restricted - def is_age_restricted(self): - return True - - def withdraw(self, amount, taxes): - """Assume that money withdrawn from this account will be a mixture - of pretax funds (which count as ordinary income) and Roth funds - (which are available tax-free). Assume that the ratio of pretax - to Roth in this overall account determines the amount from each - partition in this withdrawal.""" - if amount <= 0: return 0 - balance = self.get_balance() - if balance < amount: raise Exception("Insufficient funds") - - ratio = self.roth / balance - roth_part = amount * ratio - pretax_part = amount - roth_part - if roth_part > 0: - self.roth -= roth_part - self.total_roth_withdrawals += roth_part - print "## Satisfying %s from %s with Roth money." % (roth_part, - self.name) - taxes.record_roth_income(roth_part) - if pretax_part > 0: - self.pretax -= pretax_part - self.total_pretax_withdrawals += pretax_part - print "## Satisfying %s from %s with pre-tax money." % (pretax_part, - self.name) - taxes.record_ordinary_income(pretax_part) - - def deposit(self, amount): - self.pretax += amount - - def appreciate(self, multiplier): - old_pretax = self.pretax - self.pretax *= multiplier - self.total_investment_gains += self.pretax - old_pretax - old_roth = self.roth - self.roth *= multiplier - self.total_investment_gains += self.roth - old_roth - - def get_balance(self): - """In this class we keep the balance in two parts.""" - return self.pretax + self.roth - - def has_rmd(self): - return True - - # Used to compute RMDs. Source: - # https://www.irs.gov/publications/p590b#en_US_2018_publink1000231258 - def get_actuary_number_years_to_live(self, age): - if age < 70: - return 27.4 + age - elif age == 70: - return 27.4 - elif age == 71: - return 26.5 - elif age == 72: - return 25.6 - elif age == 73: - return 24.7 - elif age == 74: - return 23.8 - elif age == 75: - return 22.9 - elif age == 76: - return 22.0 - elif age == 77: - return 21.2 - elif age == 78: - return 20.3 - elif age == 79: - return 19.5 - elif age == 80: - return 18.7 - elif age == 81: - return 17.9 - elif age == 82: - return 17.1 - elif age == 83: - return 16.3 - elif age == 84: - return 15.5 - elif age == 85: - return 14.8 - elif age == 86: - return 14.1 - elif age == 87: - return 13.4 - elif age == 88: - return 12.7 - elif age == 89: - return 12.0 - elif age == 90: - return 11.4 - elif age == 91: - return 10.8 - elif age == 92: - return 10.2 - elif age == 93: - return 9.6 - elif age == 94: - return 9.1 - elif age == 95: - return 8.6 - elif age == 96: - return 8.1 - elif age == 97: - return 7.6 - elif age == 98: - return 7.1 - elif age == 99: - return 6.7 - elif age == 100: - return 6.3 - elif age == 101: - return 5.9 - elif age == 102: - return 5.5 - elif age == 103: - return 5.2 - elif age == 104: - return 4.9 - elif age == 105: - return 4.5 - elif age == 106: - return 4.2 - elif age == 107: - return 3.9 - elif age == 108: - return 3.7 - elif age == 109: - return 3.4 - elif age == 110: - return 3.1 - elif age == 111: - return 2.9 - elif age == 112: - return 2.6 - elif age == 113: - return 2.4 - elif age == 114: - return 2.1 - else: - return 1.9 - - def do_rmd_withdrawal(self, owner_age, taxes): - balance = self.get_balance() - if balance > 0 and owner_age >= 72: - rmd_factor = self.get_actuary_number_years_to_live(owner_age) - amount = balance / rmd_factor - self.withdraw(amount, taxes) - return amount - return 0 - - def has_roth(self): - return True - - def do_roth_conversion(self, amount, taxes): - if amount <= 0: return 0 - amount = min(amount, self.pretax) - self.roth += amount - self.pretax -= amount - assert self.pretax >= 0, "Somehow exhausted more than all pretax money" - self.total_roth_conversions += amount - taxes.record_ordinary_income(amount) - print "## Executed pre-tax --> Roth conversion of %s in %s" % ( - amount, self.get_name()) - return amount - - def dump_final_report(self): - super(age_restricted_tax_deferred_account, self).dump_final_report() - print " {:<50}: {:>14}".format("Initial balance", - self.initial_balance) - print " {:<50}: {:>14}".format("Ending balance", - self.get_balance()) - print " {:<50}: {:>14}".format("Total investment gains", - self.total_investment_gains) - print " {:<50}: {:>14}".format("Total Roth withdrawals", - self.total_roth_withdrawals) - print " {:<50}: {:>14}".format("Total pre-tax withdrawals", - self.total_pretax_withdrawals) - print " {:<50}: {:>14}".format("Total pre-tax converted to Roth", - self.total_roth_conversions) - -class age_restricted_roth_account(age_restricted_tax_deferred_account): - """This is an object to represent a Roth account like a Roth IRA. All - money in here is tax free. Most of the base account class works here - including the implementation of withdraw() which says that none of the - money withdrawn was taxable.""" - - def __init__(self, total_balance, name, owner): - """C'tor for this class takes a roth_amount, the number of dollars - in the account that are in-plan Roth and can be taken out tax - free. It keeps this pile separate from the pretax pile and - tries to estimate taxes.""" - assert total_balance >= 0, "Initial balance must be >= 0" - age_restricted_tax_deferred_account.__init__( - self, total_balance, total_balance, name, owner) - - # Override - def has_rmd(self): - return False - - # Override - def do_rmd_withdrawal(self, owner_age, taxes): - raise Exception("This account has no RMDs") - - # Override - def do_roth_conversion(self, amount, taxes): - return 0 - -class brokerage_account(account): - """A class to represent money in a taxable brokerage account.""" - - def __init__(self, total_balance, cost_basis, name, owner): - """The c'tor of this class partitions balance into three pieces: - the cost_basis (i.e. how much money was invested in the account), - the short_term_gain (i.e. appreciation that has been around for - less than a year) and long_term_gain (i.e. appreciation that has - been around for more than a year). We separate these because - taxes on long_term_gain (and qualified dividends, which are not - modeled) are usually lower than short_term_gain. Today those - are taxed at 15% and as ordinary income, respectively.""" - assert total_balance >= 0, "Initial balance must be >= 0" - assert cost_basis <= total_balance, "Bad initial cost basis" - self.cost_basis = money(cost_basis) - self.short_term_gain = money(0) - self.long_term_gain = money(total_balance - cost_basis) - self.total_cost_basis_withdrawals = money(0) - self.total_long_term_gain_withdrawals = money(0) - self.total_short_term_gain_withdrawals = money(0) - self.total_investment_gains = money(0) - self.initial_balance = self.get_balance() - - # Call the base class' c'tor as well to set up the name. - account.__init__(self, name, owner) - - def withdraw(self, amount, taxes): - """Override the base class' withdraw implementation since we're - dealing with three piles of money instead of one. When you sell - securities to get money out of this account the gains are taxed - (and the cost_basis part isn't). Assume that the ratio of - cost_basis to overall balance can be used to determine how much - of the withdrawal will be taxed (and how).""" - if amount <= 0: return 0 - balance = self.get_balance() - if balance < amount: raise Exception("Insufficient funds") - - ratio = self.cost_basis / balance - invested_capital_part = amount * ratio - gains_part = amount - invested_capital_part - - if self.cost_basis >= invested_capital_part: - self.cost_basis -= invested_capital_part - self.total_cost_basis_withdrawals += invested_capital_part - print "## Satisfying %s from %s as cost basis." % (invested_capital_part, - self.name) - self.withdraw_from_gains(gains_part, taxes) - else: - self.withdraw_from_gains(amount, taxes) - - def withdraw_from_gains(self, amount, taxes): - """Withdraw some money from gains. Prefer the long term ones if - possible.""" - if amount <= 0: return 0 - if amount > (self.long_term_gain + self.short_term_gain): - raise Exception("Insufficient funds") - - if self.long_term_gain >= amount: - self.long_term_gain -= amount - self.total_long_term_gain_withdrawals += amount - print "## Satisfying %s from %s as long term gains." % ( - amount, self.name) - taxes.record_dividend_or_long_term_gain(amount) - return - - else: - print "## Satisfying %s from %s as long term gains (exhausting all current long term gains in account)." % ( - self.long_term_gain, self.name) - amount -= self.long_term_gain - self.total_long_term_gain_withdrawals += self.long_term_gain - taxes.record_dividend_or_long_term_gain(self.long_term_gain) - self.long_term_gain = 0 - # Get the rest of amount from short term gains... - - self.short_term_gain -= amount - self.total_short_term_gain_withdrawals += amount - print "## Satisfying %s from %s as short term gains." % ( - amount, self.name) - taxes.record_short_term_gain(amount) - - def deposit(self, amount): - assert amount >= 0, "Can't deposit negative amounts" - self.cost_basis += amount - - def get_balance(self): - """We're ignoring the base class' balance field in favor of tracking - it as three separate partitions of money.""" - return self.cost_basis + self.long_term_gain + self.short_term_gain - - def appreciate(self, multiplier): - """Appreciate... another year has passed so short_term_gains turn into - long_term_gains and the appreciation is our new short_term_gains.""" - balance = self.get_balance() - balance *= multiplier - gain_or_loss = balance - self.get_balance() - self.total_investment_gains += gain_or_loss - self.long_term_gain += self.short_term_gain - self.short_term_gain = gain_or_loss - - def is_age_restricted(self): - return False - - def has_rmd(self): - return False - - def has_roth(self): - return False - - def do_roth_conversion(self, amount, taxes): - return 0 - - def dump_final_report(self): - super(brokerage_account, self).dump_final_report() - print " {:<50}: {:>14}".format("Initial balance", - self.initial_balance) - print " {:<50}: {:>14}".format("Ending balance", - self.get_balance()) - print " {:<50}: {:>14}".format("Total investment gains", - self.total_investment_gains) - print " {:<50}: {:>14}".format("Total cost basis withdrawals", - self.total_cost_basis_withdrawals) - print " {:<50}: {:>14}".format("Total long term gain withdrawals", - self.total_long_term_gain_withdrawals) - print " {:<50}: {:>14}".format("Total short term gain withdrawals", - self.total_short_term_gain_withdrawals) diff --git a/constants.py b/constants.py deleted file mode 100644 index d31b041..0000000 --- a/constants.py +++ /dev/null @@ -1,36 +0,0 @@ -from money import money - -# Consts -DEFAULT = 0 -SCOTT = 1 -LYNN = 2 - -def is_valid_owner(owner): - """Is an owner valid?""" - return (owner >= DEFAULT and owner <= LYNN) - -PESSIMISTIC_FEDERAL_INCOME_TAX_BRACKETS = [ - [ money(612351), 0.50 ], - [ money(408201), 0.45 ], - [ money(321451), 0.35 ], - [ money(168401), 0.25 ], - [ money( 78951), 0.22 ], - [ money( 19401), 0.15 ], - [ money( 1), 0.12 ] -] -CURRENT_FEDERAL_INCOME_TAX_BRACKETS = [ - [ money(612351), 0.37 ], - [ money(408201), 0.35 ], - [ money(321451), 0.32 ], - [ money(168401), 0.24 ], - [ money( 78951), 0.22 ], - [ money( 19401), 0.12 ], - [ money( 1), 0.10 ] -] -CURRENT_LONG_TERM_GAIN_FEDERAL_TAX_BRACKETS = [ - [ money(488851), 0.20 ], - [ money( 78751), 0.15 ], - [ money( 1), 0.00 ] -] -PESSIMISTIC_LONG_TERM_GAIN_FEDERAL_TAX_BRACKETS = ( - PESSIMISTIC_FEDERAL_INCOME_TAX_BRACKETS) diff --git a/data.py b/data.py new file mode 100644 index 0000000..d2cddb8 --- /dev/null +++ b/data.py @@ -0,0 +1,189 @@ +#!/usr/bin/env python3 + +from dataclasses import dataclass +from typing import Dict + +from type.rate import Rate + + +# Used to compute RMDs. Source: +# https://www.irs.gov/publications/p590b#en_US_2018_publink1000231258 +IRS_ACTUARY_TABLES = { + 70: 27.4, + 71: 26.5, + 72: 25.6, + 73: 24.7, + 74: 23.8, + 75: 22.9, + 76: 22.0, + 77: 21.2, + 78: 20.3, + 79: 19.5, + 80: 18.7, + 81: 17.9, + 82: 17.1, + 83: 16.3, + 84: 15.5, + 85: 14.8, + 86: 14.1, + 87: 13.4, + 88: 12.7, + 89: 12.0, + 90: 11.4, + 91: 10.8, + 92: 10.2, + 93: 9.6, + 94: 9.1, + 95: 8.6, + 96: 8.1, + 97: 7.6, + 98: 7.1, + 99: 6.7, + 100: 6.3, + 101: 5.9, + 102: 5.5, + 103: 5.2, + 104: 4.9, + 105: 4.5, + 106: 4.2, + 107: 3.9, + 108: 3.7, + 109: 3.4, + 110: 3.1, + 111: 2.9, + 112: 2.6, + 113: 2.4, + 114: 2.1, +} + + +def get_actuary_number_years_to_live(age: int): + if age < 70: + return 27.4 + age + if age > 114: + return 1.9 + return IRS_ACTUARY_TABLES[age] + + +def make_multiplier(percent: float) -> Rate: + percent /= 100 + if percent > 0: + percent += 1.0 + else: + percent = 1.0 - percent + return percent + + +# year s&p 10y infla- +# 500 bond tion +# +# source: https://www.multpl.com/inflation/table/by-year +# source: http://pages.stern.nyu.edu/~adamodar/New_Home_Page/datafile/histretSP.html + +@dataclass +class StocksBondsAndInflation: + snp_500_return: Rate + us_10y_bond_return: Rate + inflation: Rate + + def __init__(self, snp: Rate, bonds: Rate, inflation: Rate): + self.snp_500_return = snp + self.us_10y_bond_return = bonds + self.inflation = inflation + + +ROIs_AND_INFLATION: Dict[int, StocksBondsAndInflation] = { + 2020: StocksBondsAndInflation(Rate(percent_change=18.01), Rate(percent_change=11.33), Rate(percent_change=2.49)), + 2019: StocksBondsAndInflation(Rate(percent_change=31.21), Rate(percent_change=9.64), Rate(percent_change=1.55)), + 2018: StocksBondsAndInflation(Rate(percent_change=-4.23), Rate(percent_change=-0.02), Rate(percent_change=2.07)), + 2017: StocksBondsAndInflation(Rate(percent_change=21.61), Rate(percent_change=2.80), Rate(percent_change=2.50)), + 2016: StocksBondsAndInflation(Rate(percent_change=11.77), Rate(percent_change=0.69), Rate(percent_change=1.37)), + 2015: StocksBondsAndInflation(Rate(percent_change=1.38), Rate(percent_change=1.28), Rate(percent_change=-0.09)), + 2014: StocksBondsAndInflation(Rate(percent_change=13.52), Rate(percent_change=10.75), Rate(percent_change=1.58)), + 2013: StocksBondsAndInflation(Rate(percent_change=32.15), Rate(percent_change=-9.10), Rate(percent_change=1.59)), + 2012: StocksBondsAndInflation(Rate(percent_change=15.89), Rate(percent_change=2.97), Rate(percent_change=2.93)), + 2011: StocksBondsAndInflation(Rate(percent_change=2.10), Rate(percent_change=16.04), Rate(percent_change=1.63)), + 2010: StocksBondsAndInflation(Rate(percent_change=14.82), Rate(percent_change=8.46), Rate(percent_change=2.63)), + 2009: StocksBondsAndInflation(Rate(percent_change=25.94), Rate(percent_change=-11.12), Rate(percent_change=0.03)), + 2008: StocksBondsAndInflation(Rate(percent_change=-36.55), Rate(percent_change=20.10), Rate(percent_change=4.28)), + 2007: StocksBondsAndInflation(Rate(percent_change=5.48), Rate(percent_change=10.21), Rate(percent_change=2.08)), + 2006: StocksBondsAndInflation(Rate(percent_change=15.61), Rate(percent_change=1.96), Rate(percent_change=3.99)), + 2005: StocksBondsAndInflation(Rate(percent_change=4.83), Rate(percent_change=2.87), Rate(percent_change=2.97)), + 2004: StocksBondsAndInflation(Rate(percent_change=10.74), Rate(percent_change=4.49), Rate(percent_change=1.93)), + 2003: StocksBondsAndInflation(Rate(percent_change=28.36), Rate(percent_change=0.38), Rate(percent_change=2.60)), + 2002: StocksBondsAndInflation(Rate(percent_change=-21.97), Rate(percent_change=15.12), Rate(percent_change=1.14)), + 2001: StocksBondsAndInflation(Rate(percent_change=-11.85), Rate(percent_change=5.57), Rate(percent_change=3.73)), + 2000: StocksBondsAndInflation(Rate(percent_change=-9.03), Rate(percent_change=16.66), Rate(percent_change=2.74)), + 1999: StocksBondsAndInflation(Rate(percent_change=20.89), Rate(percent_change=-8.25), Rate(percent_change=1.67)), + 1998: StocksBondsAndInflation(Rate(percent_change=28.34), Rate(percent_change=14.92), Rate(percent_change=1.57)), + 1997: StocksBondsAndInflation(Rate(percent_change=33.10), Rate(percent_change=9.94), Rate(percent_change=3.04)), + 1996: StocksBondsAndInflation(Rate(percent_change=22.68), Rate(percent_change=1.43), Rate(percent_change=2.73)), + 1995: StocksBondsAndInflation(Rate(percent_change=37.20), Rate(percent_change=23.48), Rate(percent_change=2.80)), + 1994: StocksBondsAndInflation(Rate(percent_change=1.33), Rate(percent_change=-8.04), Rate(percent_change=2.52)), + 1993: StocksBondsAndInflation(Rate(percent_change=9.97), Rate(percent_change=14.21), Rate(percent_change=3.26)), + 1992: StocksBondsAndInflation(Rate(percent_change=7.49), Rate(percent_change=9.36), Rate(percent_change=2.60)), + 1991: StocksBondsAndInflation(Rate(percent_change=30.23), Rate(percent_change=15.00), Rate(percent_change=5.65)), + 1990: StocksBondsAndInflation(Rate(percent_change=-3.06), Rate(percent_change=6.24), Rate(percent_change=5.20)), + 1989: StocksBondsAndInflation(Rate(percent_change=31.48), Rate(percent_change=17.69), Rate(percent_change=4.67)), + 1988: StocksBondsAndInflation(Rate(percent_change=16.54), Rate(percent_change=8.22), Rate(percent_change=4.05)), + 1987: StocksBondsAndInflation(Rate(percent_change=5.81), Rate(percent_change=-4.96), Rate(percent_change=1.46)), + 1986: StocksBondsAndInflation(Rate(percent_change=18.49), Rate(percent_change=24.28), Rate(percent_change=3.89)), + 1985: StocksBondsAndInflation(Rate(percent_change=31.24), Rate(percent_change=25.71), Rate(percent_change=3.53)), + 1984: StocksBondsAndInflation(Rate(percent_change=6.15), Rate(percent_change=13.73), Rate(percent_change=4.19)), + 1983: StocksBondsAndInflation(Rate(percent_change=22.34), Rate(percent_change=3.20), Rate(percent_change=3.71)), + 1982: StocksBondsAndInflation(Rate(percent_change=20.42), Rate(percent_change=32.81), Rate(percent_change=8.39)), + 1981: StocksBondsAndInflation(Rate(percent_change=-4.70), Rate(percent_change=8.20), Rate(percent_change=11.83)), + 1980: StocksBondsAndInflation(Rate(percent_change=31.74), Rate(percent_change=-2.99), Rate(percent_change=13.91)), + 1979: StocksBondsAndInflation(Rate(percent_change=18.52), Rate(percent_change=0.67), Rate(percent_change=9.28)), + 1978: StocksBondsAndInflation(Rate(percent_change=6.51), Rate(percent_change=-0.78), Rate(percent_change=6.84)), + 1977: StocksBondsAndInflation(Rate(percent_change=-6.98), Rate(percent_change=1.29), Rate(percent_change=5.22)), + 1976: StocksBondsAndInflation(Rate(percent_change=23.83), Rate(percent_change=15.98), Rate(percent_change=6.72)), + 1975: StocksBondsAndInflation(Rate(percent_change=37.00), Rate(percent_change=3.61), Rate(percent_change=11.80)), + 1974: StocksBondsAndInflation(Rate(percent_change=-25.90), Rate(percent_change=1.99), Rate(percent_change=9.39)), + 1973: StocksBondsAndInflation(Rate(percent_change=-14.31), Rate(percent_change=3.66), Rate(percent_change=3.65)), + 1972: StocksBondsAndInflation(Rate(percent_change=18.76), Rate(percent_change=2.82), Rate(percent_change=3.27)), + 1971: StocksBondsAndInflation(Rate(percent_change=14.22), Rate(percent_change=9.79), Rate(percent_change=5.29)), + 1970: StocksBondsAndInflation(Rate(percent_change=3.56), Rate(percent_change=16.75), Rate(percent_change=6.18)), + 1969: StocksBondsAndInflation(Rate(percent_change=-8.24), Rate(percent_change=-5.01), Rate(percent_change=4.40)), + 1968: StocksBondsAndInflation(Rate(percent_change=10.81), Rate(percent_change=3.27), Rate(percent_change=3.65)), + 1967: StocksBondsAndInflation(Rate(percent_change=23.80), Rate(percent_change=-1.58), Rate(percent_change=3.46)), + 1966: StocksBondsAndInflation(Rate(percent_change=-9.97), Rate(percent_change=2.91), Rate(percent_change=1.92)), + 1965: StocksBondsAndInflation(Rate(percent_change=12.40), Rate(percent_change=0.72), Rate(percent_change=0.97)), + 1964: StocksBondsAndInflation(Rate(percent_change=16.42), Rate(percent_change=3.73), Rate(percent_change=1.64)), + 1963: StocksBondsAndInflation(Rate(percent_change=22.61), Rate(percent_change=1.68), Rate(percent_change=1.33)), + 1962: StocksBondsAndInflation(Rate(percent_change=-8.81), Rate(percent_change=5.69), Rate(percent_change=0.67)), + 1961: StocksBondsAndInflation(Rate(percent_change=26.64), Rate(percent_change=2.06), Rate(percent_change=1.71)), + 1960: StocksBondsAndInflation(Rate(percent_change=0.34), Rate(percent_change=11.64), Rate(percent_change=1.03)), + 1959: StocksBondsAndInflation(Rate(percent_change=12.06), Rate(percent_change=-2.65), Rate(percent_change=1.40)), + 1958: StocksBondsAndInflation(Rate(percent_change=43.72), Rate(percent_change=-2.10), Rate(percent_change=3.62)), + 1957: StocksBondsAndInflation(Rate(percent_change=-10.46), Rate(percent_change=6.80), Rate(percent_change=2.99)), + 1956: StocksBondsAndInflation(Rate(percent_change=7.44), Rate(percent_change=-2.26), Rate(percent_change=0.37)), + 1955: StocksBondsAndInflation(Rate(percent_change=32.60), Rate(percent_change=-1.34), Rate(percent_change=-0.74)), + 1954: StocksBondsAndInflation(Rate(percent_change=52.56), Rate(percent_change=3.29), Rate(percent_change=1.13)), + 1953: StocksBondsAndInflation(Rate(percent_change=-1.21), Rate(percent_change=4.14), Rate(percent_change=0.38)), + 1952: StocksBondsAndInflation(Rate(percent_change=18.15), Rate(percent_change=2.27), Rate(percent_change=4.33)), + 1951: StocksBondsAndInflation(Rate(percent_change=23.68), Rate(percent_change=-0.30), Rate(percent_change=8.09)), + 1950: StocksBondsAndInflation(Rate(percent_change=30.81), Rate(percent_change=0.43), Rate(percent_change=-2.08)), + 1949: StocksBondsAndInflation(Rate(percent_change=18.30), Rate(percent_change=4.66), Rate(percent_change=1.27)), + 1948: StocksBondsAndInflation(Rate(percent_change=5.70), Rate(percent_change=1.95), Rate(percent_change=10.23)), + 1947: StocksBondsAndInflation(Rate(percent_change=5.20), Rate(percent_change=0.92), Rate(percent_change=18.13)), + 1946: StocksBondsAndInflation(Rate(percent_change=-8.43), Rate(percent_change=3.13), Rate(percent_change=2.25)), + 1945: StocksBondsAndInflation(Rate(percent_change=35.82), Rate(percent_change=3.80), Rate(percent_change=2.30)), + 1944: StocksBondsAndInflation(Rate(percent_change=19.03), Rate(percent_change=2.58), Rate(percent_change=2.96)), + 1943: StocksBondsAndInflation(Rate(percent_change=25.06), Rate(percent_change=2.49), Rate(percent_change=7.64)), + 1942: StocksBondsAndInflation(Rate(percent_change=19.17), Rate(percent_change=2.29), Rate(percent_change=11.35)), + 1941: StocksBondsAndInflation(Rate(percent_change=-12.77), Rate(percent_change=-2.02), Rate(percent_change=1.44)), + 1940: StocksBondsAndInflation(Rate(percent_change=-10.67), Rate(percent_change=5.40), Rate(percent_change=-0.71)), + 1939: StocksBondsAndInflation(Rate(percent_change=-1.10), Rate(percent_change=4.41), Rate(percent_change=-1.41)), + 1938: StocksBondsAndInflation(Rate(percent_change=29.28), Rate(percent_change=4.21), Rate(percent_change=0.71)), + 1937: StocksBondsAndInflation(Rate(percent_change=-35.34), Rate(percent_change=1.38), Rate(percent_change=2.17)), + 1936: StocksBondsAndInflation(Rate(percent_change=31.94), Rate(percent_change=5.02), Rate(percent_change=1.47)), + 1935: StocksBondsAndInflation(Rate(percent_change=46.74), Rate(percent_change=4.47), Rate(percent_change=3.03)), + 1934: StocksBondsAndInflation(Rate(percent_change=-1.19), Rate(percent_change=7.96), Rate(percent_change=2.33)), + 1933: StocksBondsAndInflation(Rate(percent_change=49.98), Rate(percent_change=1.86), Rate(percent_change=-9.79)), + 1932: StocksBondsAndInflation(Rate(percent_change=-8.64), Rate(percent_change=8.79), Rate(percent_change=-10.06)), + 1931: StocksBondsAndInflation(Rate(percent_change=-43.84), Rate(percent_change=-2.56), Rate(percent_change=-7.02)), + 1930: StocksBondsAndInflation(Rate(percent_change=-25.12), Rate(percent_change=4.54), Rate(percent_change=0.00)), + 1929: StocksBondsAndInflation(Rate(percent_change=-8.30), Rate(percent_change=4.20), Rate(percent_change=-1.16)), + 1928: StocksBondsAndInflation(Rate(percent_change=43.81), Rate(percent_change=0.84), Rate(percent_change=-1.14)), +} diff --git a/money.py b/money.py deleted file mode 100644 index 848d972..0000000 --- a/money.py +++ /dev/null @@ -1,154 +0,0 @@ -import decimal - -class money(object): - def __init__(self, amount="0"): - try: - if isinstance(amount, money): - amount = amount.amount - self.amount = decimal.Decimal(amount) - except decimal.InvalidOperation: - raise ValueError("amount value could not be converted to " - "Decimal(): '{}'".format(amount)) - - def amount(self): - return self.amount - - def __hash__(self): - return hash(self.amount) - - def __repr__(self): - return "{}".format(self.amount) - - def __str__(self): - return self.__unicode__().encode('utf-8') - - def __unicode__(self): - return u"${:,.2f}".format(self.amount) - - def __lt__(self, other): - if not isinstance(other, money): - other = money(other) - return self.amount < other.amount - - def __le__(self, other): - if not isinstance(other, money): - other = money(other) - return self.amount <= other.amount - - def __eq__(self, other): - if isinstance(other, money): - return self.amount == other.amount - return False - - def __ne__(self, other): - return not self == other - - def __gt__(self, other): - if not isinstance(other, money): - other = money(other) - return self.amount > other.amount - - def __ge__(self, other): - if not isinstance(other, money): - other = money(other) - return self.amount >= other.amount - - def __add__(self, other): - if not isinstance(other, money): - other = money(other) - other = other.amount - amount = self.amount + other - return self.__class__(amount) - - def __radd__(self, other): - return self.__add__(other) - - def __sub__(self, other): - if not isinstance(other, money): - other = money(other) - other = other.amount - amount = self.amount - other - return self.__class__(amount) - - def __rsub__(self, other): - return (-self).__add__(other) - - def __mul__(self, other): - if isinstance(other, money): - other = other.amount() - amount = self.amount * decimal.Decimal(other) - return self.__class__(amount) - - def __rmul__(self, other): - return self.__mul__(other) - - def __div__(self, other): - return self.__truediv__(other) - - def __truediv__(self, other): - if isinstance(other, money): - if other.amount == 0: - raise ZeroDivisionError() - return self.amount / other.amount - else: - if other == 0: - raise ZeroDivisionError() - amount = self.amount / decimal.Decimal(other) - return self.__class__(amount) - - def __floordiv__(self, other): - if isinstance(other, money): - if other.amount == 0: - raise ZeroDivisionError() - return self.amount // other.amount - else: - if other == 0: - raise ZeroDivisionError() - amount = self.amount // other - return self.__class__(amount) - - def __mod__(self, other): - if isinstance(other, money): - raise TypeError("modulo is unsupported between two '{}' " - "objects".format(self.__class__.__name__)) - if other == 0: - raise ZeroDivisionError() - amount = self.amount % other - return self.__class__(amount) - - def __divmod__(self, other): - if isinstance(other, money): - if other.amount == 0: - raise ZeroDivisionError() - return divmod(self.amount, other.amount) - else: - if other == 0: - raise ZeroDivisionError() - whole, remainder = divmod(self.amount, other) - return (self.__class__(whole), - self.__class__(remainder)) - - def __pow__(self, other): - if isinstance(other, money): - raise TypeError("power operator is unsupported between two '{}' " - "objects".format(self.__class__.__name__)) - amount = self.amount ** other - return self.__class__(amount) - - def __neg__(self): - return self.__class__(-self.amount) - - def __pos__(self): - return self.__class__(+self.amount) - - def __abs__(self): - return self.__class__(abs(self.amount)) - - def __int__(self): - return int(self.amount) - - def __float__(self): - return float(self.amount) - - def __round__(self, ndigits=0): - return self.__class__(round(self.amount, ndigits)) diff --git a/parameters.py b/parameters.py deleted file mode 100644 index 1d6443c..0000000 --- a/parameters.py +++ /dev/null @@ -1,332 +0,0 @@ -import constants -import utils -from tax_brackets import tax_brackets -from money import money -from numpy import random - -class parameters(object): - def get_initial_annual_expenses(self): - pass - - def get_average_inflation_multiplier(self): - pass - - def get_average_social_security_multiplier(self): - pass - - def get_average_investment_return_multiplier(self): - pass - - def get_initial_social_security_age(self, person): - pass - - def get_initial_social_security_benefit(self, person): - pass - - def get_federal_standard_deduction(self): - pass - - def get_federal_ordinary_income_tax_brackets(self): - pass - - def get_federal_dividends_and_long_term_gains_income_tax_brackets(self): - pass - - def dump(self): - pass - - def report_year(self, year): - pass - -class mutable_default_parameters(parameters): - """A container to hold the initial states of several simulation - parameters. Play with them as you see fit and see what happens.""" - - def __init__(self): - self.with_default_values() - - def with_default_values(self): - # Annual expenses in USD at the start of the simulation. This - # will be adjusted upwards with inflation_multiplier every year. - self.initial_annual_expenses = money(144300) - - # The average US inflation rate during the simulation. The - # Fed's target rate is 2.0% as of 2020. The long term observed - # average historical inflation rate in the US is 2.1%. - # - # Note this is a multiplier... so 1.0 would be no inflation, - # 1.21 is 2.1% inflation, 0.9 is deflation, etc... - self.inflation_multiplier = 1.03 - - # We want to be able to model social security payments not - # keeping pace with inflation. Like the inflation_multiplier - # above, this is a multiplier. It affect the magnitide of - # social security payments year over year. - self.social_security_multiplier = 1.02 - - # This is the average investment return rate. Asset allocation has - # a large effect on this as does the overall economy. That said, - # the US stock market has returned 10%/year over a large enough - # time window. Our investments at Fidelity have returned 6.91% - # in the lifetime they have been there. The expected return of a - # 50/50 stock/bond investment mix based on historical data is 8.3%. - self.investment_multiplier = 1.04 - - # The age at which each person will take social security - # benefits in this simulation and how much she will get the - # first year. Note, this benefit size increases year over - # year at social_security_multiplier. This is what the social - # security website estimates if we both earn $0 from 2020 on: - # - # Lynn's benefits: Scott's benefits: - # age 62 - $21,120 age 62 - $21,420 - # age 67 - $30,000 age 67 - $30,420 - # age 70 - $37,200 age 70 - $37,728 - # - # X SCOTT LYNN - self.social_security_age = [0, 62, 62 ] - self.initial_social_security_dollars = [0, money(21000), money(21000) ] - - # Tax details... the standard deduction amount and tax - # brackets for ordinary income and long term capital gains. - self.federal_standard_deduction_dollars = 24800 - self.federal_ordinary_income_tax_brackets = tax_brackets( - constants.PESSIMISTIC_FEDERAL_INCOME_TAX_BRACKETS) - self.federal_dividends_and_long_term_gains_brackets = tax_brackets( - constants.CURRENT_LONG_TERM_GAIN_FEDERAL_TAX_BRACKETS) - return self - - def set_initial_annual_expenses(self, expenses): - assert expenses >= 0, "You can't have negative expenses" - self.initial_annual_expenses = expenses - return self - - def get_initial_annual_expenses(self): - return self.initial_annual_expenses - - def set_average_inflation_multiplier(self, multiplier): - self.inflation_multiplier = multiplier - return self - - def get_average_inflation_multiplier(self): - return self.inflation_multiplier - - def set_average_social_security_multiplier(self, multiplier): - self.social_security_multiplier = multiplier - return self - - def get_average_social_security_multiplier(self): - return self.social_security_multiplier - - def set_average_investment_return_multiplier(self, multiplier): - self.investment_multiplier = multiplier - return self - - def get_average_investment_return_multiplier(self): - return self.investment_multiplier - - def set_initial_social_security_age_and_benefits(self, - person, - age, - amount): - assert age >= 60 and age <= 70, "age should be between 60 and 70" - self.social_security_age[person] = age - assert amount >= 0, "Social security won't pay negative dollars" - self.initial_social_security_dollars[person] = amount - return self - - def get_initial_social_security_age(self, person): - return self.social_security_age[person] - - def get_initial_social_security_benefit(self, person): - return self.initial_social_security_dollars[person] - - def set_federal_standard_deduction(self, deduction): - assert deduction >= 0, "Standard deduction should be non-negative" - self.federal_standard_deduction_dollars = deduction - return self - - def get_federal_standard_deduction(self): - return self.federal_standard_deduction_dollars - - def set_federal_ordinary_income_tax_brackets(self, brackets): - self.federal_ordinary_income_tax_brackets = brackets - return self - - def get_federal_ordinary_income_tax_brackets(self): - return self.federal_ordinary_income_tax_brackets - - def set_federal_dividends_and_long_term_gains_income_tax_brackets(self, - brackets): - self.federal_dividends_and_long_term_gains_brackets = brackets; - return self - - def get_federal_dividends_and_long_term_gains_income_tax_brackets(self): - return self.federal_dividends_and_long_term_gains_brackets - - def dump(self): - print "SIMULATION PARAMETERS" - print " {:<50}: {:>14}".format("Initial year annual expenses", - self.initial_annual_expenses) - print " {:<50}: {:>14}".format("Annual inflation rate", - utils.format_rate(self.inflation_multiplier)) - print " {:<50}: {:>14}".format("Average annual investment return rate", - utils.format_rate(self.investment_multiplier)) - print " {:<50}: {:>14}".format("Annual social security benefit increase rate", - utils.format_rate(self.social_security_multiplier)) - print " {:<50}: {:>14}".format("Age at which Lynn takes social security", - self.social_security_age[constants.LYNN]) - print " {:<50}: {:>14}".format("Lynn's first year social security benefit", - self.initial_social_security_dollars[constants.LYNN]) - print " {:<50}: {:>14}".format("Age at which Scott takes social security", - self.social_security_age[constants.SCOTT]) - print " {:<50}: {:>14}".format("Scott's first year social security benefit", - self.initial_social_security_dollars[constants.SCOTT]) - print " Federal tax brackets [" - self.federal_ordinary_income_tax_brackets.dump() - print " ]" - - print " Federal dividend and long term gain brackets [" - self.federal_dividends_and_long_term_gains_brackets.dump() - print " ]" - print " We assume Roth money continues to be available tax-free." - -class mutable_dynamic_historical_parameters(mutable_default_parameters): - def __init__(self): - self.selection_index = None - self.selection_duration = 0 - self.historical_tuples = [ - # year stock infl bond - (2020, 3.14, 1.90, 1.54), - (2019, 31.49, 1.70, 2.15), - (2018, -4.38, 2.40, 2.33), - (2017, 21.83, 2.10, 1.19), - (2016, 11.96, 1.30, 0.61), - (2015, 1.38, 0.10, 0.32), - (2014, 13.69, 1.60, 0.12), - (2013, 32.39, 1.50, 0.13), - (2012, 16.00, 2.10, 0.17), - (2011, 2.11, 3.20, 0.18), - (2010, 15.06, 1.60, 0.32), - (2009, 26.46, -0.40, 0.47), - (2008,-37.00, 3.80, 1.83), - (2007, 5.49, 2.80, 4.53), - (2006, 15.79, 3.20, 4.94), - (2005, 4.91, 3.40, 3.62), - (2004, 10.88, 2.70, 1.89), - (2003, 28.68, 2.30, 1.24), - (2002,-22.10, 1.60, 2.00), - (2001,-11.89, 2.80, 3.49), - (2000, -9.10, 3.40, 6.11), - (1999, 21.04, 2.20, 5.08), - (1998, 28.58, 1.50, 5.05), - (1997, 33.36, 2.30, 5.63), - (1996, 22.96, 3.00, 5.52), - (1995, 37.58, 2.80, 5.94), - (1994, 1.32, 2.60, 5.32), - (1993, 10.08, 3.00, 3.43), - (1992, 7.62, 3.00, 3.89), - (1991, 30.47, 4.20, 5.86), - (1990, -3.10, 5.40, 7.89), - (1989, 31.69, 4.82, 8.54), - (1988, 16.61, 4.14, 7.65), - (1987, 15.25, 3.65, 6.77), - (1986, 18.67, 0.86, 6.45), - (1985, 31.73, 3.56, 8.42), - (1984, 6.27, 4.32, 10.91), - (1983, 22.56, 3.21, 9.58), - (1982, 21.55, 6.16, 12.27), - (1981, -4.91, 10.32, 14.80), - (1980, 32.42, 13.50, 12.00), - (1979, 18.44, 11.35, 10.65), - (1978, 6.65, 7.59, 7.00), - (1977, -7.18, 6.50, 6.08), - (1976, 23.84, 5.76, 5.88), - (1975, 37.20, 9.13, 6.78), - (1974,-26.47, 11.04, 8.20), - (1973,-14.66, 6.22, 7.32), - (1972, 18.90, 3.21, 4.95), - (1971, 14.31, 4.38, 4.89), - (1970, 14.01, 5.72, 6.90), - (1969, -8.50, 5.46, 7.12), - (1968, 11.06, 4.19, 5.69), - (1967, 23.98, 3.09, 4.88), - (1966,-10.06, 2.86, 5.20), - (1965, 12.45, 1.61, 4.15), - (1964, 16.48, 1.31, 3.85), - (1963, 22.80, 1.32, 3.36), - (1962, -8.73, 1.00, 2.90), - (1961, 26.89, 1.01, 2.60), - (1960, 0.47, 1.72, 3.24), - (1959, 11.96, 0.69, 3.83), - (1958, 43.36, 2.85, 3.5), - (1957,-10.78, 3.31, 3.6), - (1956, 6.56, 1.49, 2.9), - (1955, 31.56, -0.37, 2.5), - (1954, 52.62, 0.75, 2.37), - (1953, -0.99, 0.75, 2.71), - (1952, 18.37, 1.92, 2.19), - (1951, 24.02, 7.88, 2.00), - (1950, 31.71, 1.26, 1.98), - (1949, 18.79, -1.24, 2.21), - (1948, 5.50, 8.07, 2.40), - (1947, 5.71, 14.36, 2.01), - (1946, -8.07, 8.33, 1.64), - (1945, 36.44, 2.27, 1.67), - (1944, 19.75, 1.73, 1.86), - (1943, 25.90, 6.13, 2.05), - (1942, 20.34, 10.88, 2.36), - (1941,-11.59, 5.00, 2.10), - (1940, -9.78, 0.72, 2.76), - (1939, -0.41, -1.42, 2.76), - (1938, 31.12, -2.08, 2.94), - (1937,-35.03, 3.60, 2.76), - (1936, 33.92, 1.46, 3.39), - (1935, 47.67, 2.24, 2.76), - (1934, -1.44, 3.08, 2.76), - (1933, 53.99, -5.11, 4.71), - (1932, -8.19, -9.87, 4.71), - (1931,-43.34, -8.90, 3.99), - (1930,-24.90, -2.34, 4.71), - (1929, -8.42, 0.00, 4.27) ] - mutable_default_parameters.__init__(self) - - def report_year(self, year): - if self.selection_index is None: - self.selection_index = random.randint(0, - len(self.historical_tuples) - 1) - self.selection_duration = 1 - - t = self.historical_tuples[self.selection_index] - sim_year = t[0] - stock_return = t[1] - inflation = t[2] - bond_return = t[3] - print - print "## REPLAY YEAR %d" % sim_year - inflation_multiplier = utils.convert_rate_to_multiplier(inflation) - self.set_average_inflation_multiplier(inflation_multiplier) - print "## INFLATION is %s (%f)" % ( - utils.format_rate(inflation_multiplier), - inflation_multiplier) - ss_multiplier = inflation_multiplier - if ss_multiplier >= 1.0: - ss_multiplier -= 1.0 - ss_multiplier *= 0.6666 - ss_multiplier += 1.0 - self.set_average_social_security_multiplier(ss_multiplier) - print "## SS is %s (%f)" % ( - utils.format_rate(self.get_average_social_security_multiplier()), - ss_multiplier) - - # Assumes 50/50 Stocks/Bonds portfolio - our_return = (stock_return * 0.5 + - bond_return * 0.5) - self.set_average_investment_return_multiplier(utils.convert_rate_to_multiplier(our_return)) - print "## 50/50 INVESTMENTS RETURN is %s" % utils.format_rate(self.get_average_investment_return_multiplier()) - self.selection_duration += 1 - self.selection_index -= 1 - if self.selection_index < 0 or random.randint(1, 100) < 20: - self.selection_index = None - self.selection_duration = None - diff --git a/person.py b/person.py new file mode 100644 index 0000000..ae86ae1 --- /dev/null +++ b/person.py @@ -0,0 +1,10 @@ +#!/usr/bin/env python3 + +import enum + + +class Person(enum.Enum): + UNKNOWN = 0 + SCOTT = 1 + LYNN = 2 + SHARED = 3 diff --git a/result_summarizer.py b/result_summarizer.py new file mode 100644 index 0000000..ca0fb72 --- /dev/null +++ b/result_summarizer.py @@ -0,0 +1,57 @@ +#!/usr/bin/env python3 + +import statistics as stats +from typing import Iterable + +import histogram +from type.money import Money +from type.rate import Rate + +import simulation +import simulation_results + + +def summarize_results( + results: Iterable[simulation_results.SimulationResults] +) -> None: + num_successes = 0 + num_failures = 0 + num_total = 0 + avg_failure_year = 0 + buckets = histogram.SimpleHistogram.n_evenly_spaced_buckets(10000, 1000*1000*100, 6) + buckets.insert(0, (0, 9999)) + hist = histogram.SimpleHistogram(buckets) + + failure_years = [] + for result in results: + hist.add_item(float(result.final_networth.amount)) + if result.success: + num_successes += 1 + else: + failure_years.append(result.end_year) + avg_failure_year += result.end_year + num_failures += 1 + num_total += 1 + if num_failures > 0: + avg_failure_year /= num_failures + + nw = [result.final_networth for result in results] + + nw.sort() + with simulation.ReportColorizer(): + print('SIMULATION RESULTS:') + print(f' Number of trials: {len(nw)}') + print(f' Successes and Failures: {num_successes} successes, {num_failures} failures ({Rate(num_successes/num_total)})') + if num_failures > 0: + print(f' Average failure year: {avg_failure_year:4.0f}') + print(f' Stdev failure year: {stats.pstdev(failure_years):.1f} years') + print(f' Min ending networth: {nw[0]}') + print(f' p25 ending networth: {nw[len(nw)//4]}') + print(f' Mean ending networth: {Money(stats.mean([x.final_networth.amount for x in results]))}') + print(f' p50 ending networth: {nw[len(nw)//2]}') + print(f' p75 ending networth: {nw[len(nw)//4*3]}') + print(f' Max ending networth: {nw[-1]}') + print + print(f' Stdev ending networth: {Money(stats.pstdev([x.final_networth.amount for x in results]))}') + print('') + print(hist.__repr__(label_formatter='$%-9s')) diff --git a/retire.py b/retire.py index fc68655..4282da7 100755 --- a/retire.py +++ b/retire.py @@ -1,287 +1,74 @@ -#!/usr/local/bin/python - -import sys -import traceback - -from accounts import * -import constants -from parameters import * -from tax_brackets import tax_brackets -from tax_collector import tax_collector -import utils -import secrets -from money import money - -class simulation(object): - def __init__(self, parameters, accounts): - """Initialize simulation parameters and starting account balances""" - self.params = parameters - self.accounts = accounts - self.lynn_age = 0 - self.scott_age = 0 - self.alex_age = 0 - self.year = 0 - self.max_net_worth = 0 - - def do_rmd_withdrawals(self, taxes): - """Determine if any account that has RMDs will require someone to - take money out of it this year and, if so, how much. Then do - the withdrawal.""" - total_withdrawn = money(0) - for x in self.accounts: - if x.has_rmd() and x.get_owner() == constants.SCOTT: - rmd = x.do_rmd_withdrawal(self.scott_age, taxes) - total_withdrawn += rmd - elif x.has_rmd() and x.get_owner() == constants.LYNN: - rmd = x.do_rmd_withdrawal(self.lynn_age, taxes) - total_withdrawn += rmd - return total_withdrawn - - def go_find_money(self, amount_needed, taxes): - """Look through accounts and try to find amount using some heuristics - about where to withdraw money first.""" - - # Try brokerage accounts first - for x in self.accounts: - if not x.is_age_restricted(): - amount_to_withdraw = min(amount_needed, x.get_balance()) - if amount_to_withdraw > 0: - print "## Withdrawing %s from %s" % (amount_to_withdraw, - x.get_name()) - x.withdraw(amount_to_withdraw, taxes) - amount_needed -= amount_to_withdraw - if amount_needed <= 0: return - - # Next try age restircted accounts - for x in self.accounts: - if (x.is_age_restricted() and - x.has_rmd() and - ((x.belongs_to_lynn() and self.lynn_age > 60) or - (x.belongs_to_scott() and self.scott_age > 60))): - - amount_to_withdraw = min(amount_needed, x.get_balance()) - if amount_to_withdraw > 0: - print "## Withdrawing %s from %s" % (amount_to_withdraw, - x.get_name()) - x.withdraw(amount_to_withdraw, taxes) - amount_needed -= amount_to_withdraw - if amount_needed <= 0: return - - # Last try Roth accounts - for x in self.accounts: - if (x.is_age_restricted() and - x.has_roth() and - ((x.belongs_to_lynn() and self.lynn_age > 60) or - (x.belongs_to_scott() and self.scott_age > 60))): - - amount_to_withdraw = min(amount_needed, x.get_balance()) - if amount_to_withdraw > 0: - print "## Withdrawing %s from %s" % (amount_to_withdraw, - x.get_name()) - x.withdraw(amount_to_withdraw, taxes) - amount_needed -= amount_to_withdraw - if amount_needed <= 0: return - raise Exception("Unable to find enough money this year, still need %s more!" % amount_needed) - - def get_social_security(self, - scott_annual_social_security_dollars, - lynn_annual_social_security_dollars, - taxes): - """Figure out if Scott and/or Lynn are taking social security at - their present age in the simulation and, if so, how much their - annual benefit should be.""" - total_benefit = money(0) - if self.scott_age >= self.params.get_initial_social_security_age(constants.SCOTT): - total_benefit += scott_annual_social_security_dollars - taxes.record_ordinary_income(scott_annual_social_security_dollars) - if self.lynn_age >= self.params.get_initial_social_security_age(constants.LYNN): - total_benefit += lynn_annual_social_security_dollars - taxes.record_ordinary_income(lynn_annual_social_security_dollars) - return total_benefit - - def do_opportunistic_roth_conversions(self, taxes): - """Roll over money from pretax 401(k)s or IRAs into Roth.""" - desired_conversion_amount = ( - taxes.how_many_more_dollars_can_we_earn_without_changing_tax_rate( - self.params.get_federal_ordinary_income_tax_brackets())) - if desired_conversion_amount > 0: - money_converted = 0 - for x in self.accounts: - if x.has_roth(): - amount = x.do_roth_conversion(desired_conversion_amount, taxes) - money_converted += amount - desired_conversion_amount -= amount - if money_converted > 0: - return True - return False - - def dump_report_header(self): - self.params.dump() - - def dump_annual_header(self, money_needed): - print "\nYear: %d, estimated annual expenses %s ---------------\n" % ( - self.year, - money_needed) - print "Scott is %d, Lynn is %d and Alex is %d.\n" % ( - self.scott_age, self.lynn_age, self.alex_age) - - # Print out how much money is in each account + overall net worth. - total = money(0) - for x in self.accounts: - total += x.get_balance() - print "{:<50}: {:>14}".format(x.get_name(), x.get_balance()) - print "{:<50}: {:>14}\n".format("TOTAL", total) - if self.max_net_worth < total: - self.max_net_worth = total - - def dump_final_report(self, taxes): - print "\nAGGREGATE STATS FINAL REPORT:" - total = money(0) - for x in self.accounts: - x.dump_final_report() - total += x.get_balance() - taxes.dump_final_report() - print " {:<50}: {:>14}".format("Max net worth achieved", - self.max_net_worth) - print "==> {:<50}: {:>14}".format("Final net worth of simulation", - total) - - def run(self): - """Run the simulation!""" - self.dump_report_header() - - taxes = tax_collector() - adjusted_annual_expenses = self.params.get_initial_annual_expenses() - adjusted_scott_annual_social_security_dollars = ( - self.params.get_initial_social_security_benefit(constants.SCOTT)) - adjusted_lynn_annual_social_security_dollars = ( - self.params.get_initial_social_security_benefit(constants.LYNN)) - - - try: - for self.year in xrange(2020, 2080): - self.scott_age = self.year - 1974 - self.lynn_age = self.year - 1964 - self.alex_age = self.year - 2005 - self.params.report_year(self.year) - - # Computed money needed this year based on inflated budget. - money_needed = money(adjusted_annual_expenses) - - # When Alex is in college, we need $50K more per year. - if self.alex_age > 18 and self.alex_age <= 22: - money_needed += 50000 - - self.dump_annual_header(money_needed) - - # Now, figure out how to find money to pay for this year - # and how much of it is taxable. - total_income = money(0) - - # When we reach a certain age we have to take RMDs from - # some accounts. Handle that here. - rmds = self.do_rmd_withdrawals(taxes) - if rmds > 0: - print "## Satisfied %s of RMDs from age-restricted accounts." % rmds - total_income += rmds - money_needed -= rmds - - # When we reach a certain age we are eligible for SS - # payments. - ss = self.get_social_security( - adjusted_scott_annual_social_security_dollars, - adjusted_lynn_annual_social_security_dollars, - taxes) - if ss > 0: - print "## Social security paid %s" % ss - total_income += ss - money_needed -= ss - - # If we still need money, try to go find it. - if money_needed > 0: - self.go_find_money(money_needed, taxes) - total_income += money_needed - money_needed = 0 - - look_for_conversions = True - tax_limit = money(25000) - while True: - # Maybe do some opportunistic Roth conversions. - taxes_due = taxes.approximate_taxes( - self.params.get_federal_standard_deduction(), - self.params.get_federal_ordinary_income_tax_brackets(), - self.params.get_federal_dividends_and_long_term_gains_income_tax_brackets()) - total_income = taxes.get_total_income() - tax_rate = 0.0 - if total_income > 0: - tax_rate = float(taxes_due) / float(total_income) - - if (look_for_conversions and - tax_rate <= 0.14 and - taxes_due < tax_limit and - self.year <= 2036): - - look_for_conversions = self.do_opportunistic_roth_conversions(taxes) - # because these conversions affect taxes, spin - # once more in the loop and recompute taxes - # due and tax rate. - else: - break - - # Pay taxes_due by going to find more money. This is a - # bit hacky since withdrawing more money to cover taxes - # will, in turn, cause taxable income. But I think taxes - # are low enough and this simulation is rough enough that - # we can ignore this. - if taxes_due > 0: - print "## Estimated federal tax due: %s (this year's tax rate=%s)" % ( - taxes_due, utils.format_rate(tax_rate)) - self.go_find_money(taxes_due, taxes) - else: - print "## No federal taxes due this year!" - taxes.record_taxes_paid_and_reset_for_next_year(taxes_due) - - # Inflation and appreciation: - # * Cost of living increases - # * Social security benefits increase - # * Tax brackets are adjusted for inflation - inflation_multiplier = self.params.get_average_inflation_multiplier() - returns_multiplier = self.params.get_average_investment_return_multiplier() - ss_multiplier = self.params.get_average_social_security_multiplier() - adjusted_annual_expenses *= inflation_multiplier - for x in self.accounts: - x.appreciate(returns_multiplier) - if self.scott_age >= self.params.get_initial_social_security_age(constants.SCOTT): - adjusted_scott_annual_social_security_dollars *= ss_multiplier - if self.lynn_age >= self.params.get_initial_social_security_age(constants.LYNN): - adjusted_lynn_annual_social_security_dollars *= ss_multiplier - self.params.get_federal_ordinary_income_tax_brackets().adjust_with_multiplier(inflation_multiplier) - self.params.get_federal_dividends_and_long_term_gains_income_tax_brackets().adjust_with_multiplier(inflation_multiplier) - succeeded = True - except Exception as e: - print "Exception: %s" % e - print traceback.print_exc(e) - print "Ran out of money!?!" - succeeded = False - - finally: - self.dump_final_report(taxes) - return succeeded - -# main -#params = mutable_default_parameters() - -params = None -accounts = None -s = None -for x in xrange(1, 100): - del params - del accounts - del s - params = mutable_dynamic_historical_parameters() - accounts = secrets.get_starting_account_list() - s = simulation(params, accounts) - print "====================== Simulation %d ======================" % x - if s.run() == False: - print "This simulation failed!" - sys.exit(0) +#!/usr/bin/env python3 + +from typing import List + +import bootstrap +import config + +import account +from person import Person +import result_summarizer +import returns_and_expenses as rai +import simulation +import simulation_params +import trials +from type.money import Money + + +args = config.add_commandline_args( + 'Retire!', + 'Args that drive the retirement simulator', +) +args.add_argument( + '--num_trials', + '-n', + type=int, + default=1, + help='How many simulations to run' +) +args.add_argument( + '--verbosity', + '-v', + type=int, + choices=range(0, 3), + default=1, + help='How verbose should I be?', +) + + +# This defines the set of account and their initial balances. +accounts: List[account.Account] = [ + + # Your accounts here.... + +] + + +@bootstrap.initialize +def main() -> None: + params = simulation_params.DEFAULT_SIMULATION_PARAMS + params.initial_account_states = accounts + params.returns_and_expenses = rai.GaussianRae() #rai.HistoricalRaE() + + if config.config['num_trials'] > 1: + with simulation.ReportColorizer(): + print(params) + results = trials.run_multiple_trials( + params=params, + num_trials=config.config['num_trials'] + ) + print + result_summarizer.summarize_results(results) + else: + sim = simulation.Simulation(params) + results = sim.simulate( + simulation.Verbosity(config.config['verbosity']) + ) + if not results.success: + print("Unsuccessful") + return 1 + return 0 + + +if __name__ == '__main__': + main() diff --git a/returns_and_expenses.py b/returns_and_expenses.py new file mode 100644 index 0000000..3421429 --- /dev/null +++ b/returns_and_expenses.py @@ -0,0 +1,120 @@ +#!/usr/bin/env python3 + +from abc import ABC, abstractmethod +import logging +import random + +from type.rate import Rate + +import data + + +logger = logging.getLogger(__name__) + + +class ReturnsAndExpenses(ABC): + @abstractmethod + def get_annual_inflation_rate(self, year: int) -> Rate: + pass + + @abstractmethod + def get_annual_social_security_increase_rate(self, year: int) -> Rate: + pass + + @abstractmethod + def get_annual_investment_return_rate(self, year: int) -> Rate: + pass + + +class ConstantValueRaE(ReturnsAndExpenses): + def __init__( + self, + *, + inflation_rate = Rate(0.0), + social_security_increase_rate = Rate(0.0), + investment_return_rate = Rate(0.0), + ): + super().__init__() + self.inflation_rate = inflation_rate + self.social_security_increase_rate = social_security_increase_rate + self.investment_return_rate = investment_return_rate + + def get_annual_inflation_rate(self, year: int) -> Rate: + return self.inflation_rate + + def get_annual_social_security_increase_rate(self, year: int) -> Rate: + return self.social_security_increase_rate + + def get_annual_investment_return_rate(self, year: int) -> Rate: + return self.investment_return_rate + + def __repr__(self): + return f'Constant rates: inflation={self.inflation_rate}, ss={self.social_security_increase_rate}, roi={self.investment_return_rate}' + + +class HistoricalRaE(ReturnsAndExpenses): + def __init__(self): + super().__init__() + #self.years = range(1928, 2020) + self.years = [1929, 1930, 1931, 1932, 1933, + 1939, + 1946, 1947, + 1956, 1957, + 1964, 1965, 1966, 1969, + 1973, 1974, 1977, 1978, + 1981, 1984, 1987, 1990, + 2000, 2001, 2002, 2007, 2007] + self.year = None + + def get_annual_inflation_rate(self, year: int) -> Rate: + #self.year = random.randrange(1928, 2020) + self.year = random.choice(self.years) + rois_and_inflation = data.ROIs_AND_INFLATION[self.year] + inflation = rois_and_inflation.inflation + logger.debug(f'HistoricalRaE: inflation is {inflation} (replay={self.year})') + return inflation + + def get_annual_social_security_increase_rate(self, year: int) -> Rate: + rois_and_inflation = data.ROIs_AND_INFLATION[self.year] + ss = rois_and_inflation.inflation + if ss > 0: + ss -= 1.0 + ss /= 2 + ss += 1.0 + logger.debug(f'HistoricalRaE: social security increase rate is {ss} (replay={self.year})') + return ss + + def get_annual_investment_return_rate(self, year: int) -> Rate: + rois_and_inflation = data.ROIs_AND_INFLATION[self.year] + roi = ( + rois_and_inflation.snp_500_return * 0.50 + + rois_and_inflation.us_10y_bond_return * 0.50 + ) + logger.debug(f'HistoricalRaE: investment return 50/50 is {roi} (replay={self.year})') + return Rate(roi) + + def __repr__(self): + return f'historical reply of inflation/returns in {self.years}' + + +class GaussianRae(ReturnsAndExpenses): + def __init__(self): + self.inflation = None + self.mean_inflation = 1.04 # Historical = 3.5% inflation + self.stdev_inflation = 0.028 # Historical = 2.8% inflation stdev + self.mean_roi = 1.060 # Historical = 8.5% 30s/70b; 9.1% 50s/50s; 9.7% 70s/30b + self.stdev_roi = 0.093 # Historical = 6.7% 30s/70b; 9.3% 50s/50b; 12.2% 70s/30b + self.ss_discount = 0.02 + + def get_annual_inflation_rate(self, year: int) -> Rate: + self.inflation = random.gauss(self.mean_inflation, self.stdev_inflation) + return Rate(multiplier=self.inflation) + + def get_annual_social_security_increase_rate(self, year: int) -> Rate: + return Rate(multiplier=self.inflation - self.ss_discount) + + def get_annual_investment_return_rate(self, year: int) -> Rate: + return Rate(multiplier=random.gauss(self.mean_roi, self.stdev_roi)) + + def __repr__(self): + return f'Random Gaussian: (μinflation={Rate(self.mean_inflation).__repr__(relative=True)}, σ={Rate(self.stdev_inflation)}); (μroi={Rate(self.mean_roi).__repr__(relative=True)}, σ={Rate(self.stdev_roi)})' diff --git a/secrets.py b/secrets.py deleted file mode 100644 index cedeec5..0000000 --- a/secrets.py +++ /dev/null @@ -1,4 +0,0 @@ -import accounts - -def get_starting_account_list: - return [ <<< your accounts >>> ] diff --git a/simulation.py b/simulation.py new file mode 100644 index 0000000..6cba37f --- /dev/null +++ b/simulation.py @@ -0,0 +1,381 @@ +#!/usr/bin/env python3 + +import enum +import logging +import re + +import ansi +from type.money import Money + +from person import Person +import simulation_params as sp +import simulation_results as sr +import taxman + + +logger = logging.getLogger(__name__) + + +class Verbosity(enum.IntEnum): + SILENT = 0 + NORMAL = 1 + VERBOSE = 2 + + +class ReportColorizer(ansi.ProgrammableColorizer): + def __init__(self): + super().__init__( + [ + (re.compile('^(.+)\:$', re.MULTILINE), self.header), + (re.compile(' *([A-Z]+[A-Z ]+)\: *'), self.title) + ] + ) + + def header(self, match: re.match): + return f'{ansi.fg("chateau green")}{match.group()}{ansi.reset()}' + + def title(self, match: re.match): + s = match.group() + if len(s) > 14: + return f'{ansi.fg("mint green")}{ansi.bold()}{ansi.underline()}{s}{ansi.reset()}' + return s + + +class Simulation(object): + def __init__( + self, + params: sp.SimulationParameters, + ): + self.year = 0 + self.scott_age = 0 + self.lynn_age = 0 + self.alex_age = 0 + self.accounts = [x for x in params.initial_account_states] + self.taxes = taxman.TaxCollector( + params.federal_ordinary_income_tax_brackets, + params.federal_dividends_and_long_term_gains_brackets + ) + self.params = params + self.returns_and_expenses = params.returns_and_expenses + + def do_rmd_withdrawals(self) -> Money: + """Determine if any account that has RMDs will require someone to + take money out of it this year and, if so, how much. Then do + the withdrawal.""" + total_withdrawn = 0 + for x in self.accounts: + if x.has_rmd() and x.get_owner() == Person.SCOTT: + rmd = x.do_rmd_withdrawal(self.scott_age, self.taxes) + total_withdrawn += rmd + elif x.has_rmd() and (x.get_owner() == Person.LYNN or x.get_owner() == Person.SHARED): + rmd = x.do_rmd_withdrawal(self.lynn_age, self.taxes) + total_withdrawn += rmd + return total_withdrawn + + def go_find_money(self, amount: Money): + """Look through accounts and try to find amount using some heuristics + about where to withdraw money first.""" + logger.debug(f'Simulation: looking for {amount}...') + + # Try brokerage accounts first + for x in self.accounts: + if not x.is_age_restricted(): + if x.get_balance() >= amount: + logger.debug( + f'Simulation: withdrawing {amount} from {x.get_name()}' + ) + x.withdraw(amount, self.taxes) + return + + elif x.get_balance() > 0.01 and x.get_balance() < amount: + money_available = x.get_balance() + logger.debug( + f'Simulation: withdrawing {money_available} from {x.get_name()} ' + + '(and exhausting the account)' + ) + x.withdraw(money_available, self.taxes) + amount -= money_available + + # Next try age restircted accounts + for x in self.accounts: + if ( + x.is_age_restricted() and + x.has_rmd() and + x.belongs_to_lynn() and + self.lynn_age > 60 + ): + if x.get_balance() >= amount: + logging.debug( + f'Simulation: withdrawing {amount} from {x.get_name()}' + ) + x.withdraw(amount, self.taxes) + return + + elif x.get_balance() > 0.01 and x.get_balance() < amount: + money_available = x.get_balance() + logger.debug( + f'Simulation: withdrawing {money_available} from {x.get_name()} ' + + '(and exhausting the account)' + ) + x.withdraw(money_available, self.taxes) + amount -= money_available + + if ( + x.is_age_restricted() and + x.has_rmd() and + x.belongs_to_scott() and + self.scott_age > 60 + ): + if x.get_balance() >= amount: + logger.debug( + f'Simulation: withdrawing {amount} from {x.get_name()}' + ) + x.withdraw(amount, self.taxes) + return + + elif x.get_balance() > 0.01 and x.get_balance() < amount: + money_available = x.get_balance() + logger.debug( + f'Simulation: withdrawing {money_available} from {x.get_name()} ' + + '(and exhausting the account)' + ) + x.withdraw(money_available, self.taxes) + amount -= money_available + + # Last try Roth accounts + for x in self.accounts: + if ( + x.is_age_restricted() and + x.has_roth() and + x.belongs_to_lynn() and + self.lynn_age > 60 + ): + if x.get_balance() >= amount: + logger.debug( + f'Simulation: withdrawing {amount} from {x.get_name()}' + ) + x.withdraw(amount, self.taxes) + return + + elif x.get_balance() > 0.01 and x.get_balance() < amount: + money_available = x.get_balance() + logger.debug( + f'Simulation: withdrawing {money_available} from {x.get_name()} ' + + '(and exhausting the account)' + ) + x.withdraw(money_available, self.taxes) + amount -= money_available + + if ( + x.is_age_restricted() and + x.has_roth() and + x.belongs_to_scott() and + self.scott_age > 60 + ): + if x.get_balance() >= amount: + logger.debug( + f'Simulation: withdrawing {amount} from {x.get_name()}' + ) + x.withdraw(amount, self.taxes) + return + + elif x.get_balance() > 0.01 and x.get_balance() < amount: + money_available = x.get_balance() + logger.debug( + f'Simulation: withdrawing {money_available} from {x.get_name()} ' + + '(and exhausting the account)' + ) + x.withdraw(money_available, self.taxes) + amount -= money_available + raise Exception("Unable to find enough money this year!") + + def get_social_security(self) -> Money: + total_benefit = Money(0) + if self.scott_age >= self.params.scott_social_security_age: + total_benefit += self.params.scott_annual_social_security_dollars + self.taxes.record_ordinary_income( + self.params.scott_annual_social_security_dollars + ) + if self.lynn_age >= self.params.lynn_social_security_age: + total_benefit += self.params.lynn_annual_social_security_dollars + self.taxes.record_ordinary_income( + self.params.lynn_annual_social_security_dollars + ) + return total_benefit + + def do_opportunistic_roth_conversions(self) -> Money: + desired_conversion_amount = ( + self.taxes.how_many_more_dollars_can_we_earn_without_changing_tax_rate() + ) + money_converted = Money(0) + for x in self.accounts: + if x.has_roth(): + amount = x.do_roth_conversion(desired_conversion_amount) + money_converted += amount + desired_conversion_amount -= amount + return money_converted + + def simulate( + self, + silent: Verbosity = Verbosity.NORMAL + ) -> sr.SimulationResults: + if silent is not Verbosity.SILENT: + with ReportColorizer(): + print(self.params) + + results = sr.SimulationResults.create() + try: + for year in range(2022, 2069): + self.year = year + self.scott_age = year - 1974 + self.lynn_age = year - 1964 + self.alex_age = year - 2005 + + # Computed money needed this year based on inflated budget. + money_needed = self.params.annual_expenses + + # When Alex is in college, we need $60K more per year. + if self.alex_age > 18 and self.alex_age <= 22: + money_needed += Money(60000) + + if silent is Verbosity.VERBOSE: + print( + f'\nYear: {year}, estimated annual expenses {money_needed} -----------------\n' + ) + print( + f'Scott is {self.scott_age}, Lynn is {self.lynn_age} and Alex is {self.alex_age}' + ) + + # Print out how much money is in each account + + # overall net worth. + total = 0 + if silent is not Verbosity.VERBOSE: + for x in self.accounts: + total += x.get_balance() + else: + for x in self.accounts: + total += x.get_balance() + print(' %-50s: %18s' % (x.get_name(), x.get_balance())) + print(" %-50s: %18s" % ("TOTAL NET WORTH", total)) + + # Max + if total > results.max_networth: + results.max_networth = total + results.max_networth_year = year + + # Now, figure out how to find money to pay for this year + # and how much of it is taxable. + total_income = 0 + + # When we reach a certain age we have to take RMDs from + # some accounts. Handle that here. + rmds = self.do_rmd_withdrawals() + if rmds > 0: + logger.debug( + f'Simulation: satisfied {rmds} of RMDs from age-restricted accounts.' + ) + total_income += rmds + money_needed -= rmds + if rmds > results.max_rmd: + results.max_rmd = rmds + results.max_rmd_year = year + + # When we reach a certain age we are eligible for SS + # payments. + ss = self.get_social_security() + results.total_social_security += ss + if ss > 0: + logger.debug( + f'Simulation: received {ss} from social security.' + ) + total_income += ss + money_needed -= ss + + # If we still need money, try to go find it in accounts. + if money_needed > 0: + self.go_find_money(money_needed) + total_income += money_needed + money_needed = 0 + + # Maybe do some opportunistic Roth conversions. + taxes_due = self.taxes.approximate_annual_taxes() + old_taxes_due = taxes_due + tax_rate = self.taxes.approximate_annual_tax_rate() + if tax_rate <= 0.16 and year <= 2035: + rollover = self.do_opportunistic_roth_conversions() + if rollover > results.max_rollover: + results.max_rollover = rollover + results.max_rollover_year = year + results.total_rollover += rollover + + # These conversions will affect taxes due. + # Recompute them now. + if rollover > 0: + taxes_due = self.taxes.approximate_annual_taxes() + tax_rate = self.taxes.approximate_annual_tax_rate() + logger.debug( + f'Simulation: rolled {rollover} from pretax into Roth which increased ' + f'taxes by {taxes_due - old_taxes_due}' + ) + + # Pay taxes_due by going to find more money. This is + # a bit hacky since withdrawing more money to cover + # taxes will, in turn, cause taxable income. But I + # think taxes are low enough and this simulation is + # rough enough that we can ignore this. + if taxes_due > results.max_taxes: + results.max_taxes = taxes_due + results.max_taxes_year = year + if taxes_due > 0: + logger.debug( + f'Simulation: estimated {taxes_due} federal tax liability (tax rate={tax_rate})' + ) + self.go_find_money(taxes_due) + else: + logger.debug('Simulation: estimating no tax burden this year') + self.taxes.record_taxes_paid_and_reset_for_next_year(year) + + # Inflation and appreciation. Note also: SS benefits + # currently are increased annually to adjust for + # inflation. Do that here too. + inflation = self.returns_and_expenses.get_annual_inflation_rate(year) + roi = self.returns_and_expenses.get_annual_investment_return_rate(year) + ss = self.returns_and_expenses.get_annual_social_security_increase_rate(year) + self.params.annual_expenses *= inflation + total = 0 + for x in self.accounts: + total += x.appreciate(roi) + if self.scott_age >= self.params.scott_social_security_age: + self.params.scott_annual_social_security_dollars *= ss + if self.lynn_age >= self.params.lynn_social_security_age: + self.params.lynn_annual_social_security_dollars *= ss + msg = ( + f'In {year}, ' + f'inflation={inflation.__repr__(relative=True)}, ' + + f'ROI={roi.__repr__(relative=True)}, ' + + f'net worth={total}' + ) + logger.debug(msg) + if silent is not Verbosity.SILENT: + print(msg) + + except Exception as e: + if silent is not Verbosity.SILENT: + logger.exception(e) + print(f'**** Exception, out of money in {year}? ****') + results.success = False + else: + results.success = True + + # Final report + results.end_year = self.year + 1 + results.final_networth = Money(0) + if results.success: + for x in self.accounts: + results.final_networth += x.get_balance() + results.final_taxes = self.taxes + results.final_account_state = self.accounts + if silent is not Verbosity.SILENT: + with ReportColorizer(): + print(results) + return results diff --git a/simulation_params.py b/simulation_params.py new file mode 100644 index 0000000..973b528 --- /dev/null +++ b/simulation_params.py @@ -0,0 +1,59 @@ +#!/usr/bin/env python3 + +import account +from dataclasses import dataclass +import returns_and_expenses as rai +from typing import List, Tuple + +import string_utils as su +from type.money import Money + +import taxman + + +@dataclass(repr=False) +class SimulationParameters(object): + initial_account_states: List[account.Account] + initial_annual_expenses: Money + annual_expenses: Money + lynn_social_security_age: int + lynn_annual_social_security_dollars: float + scott_social_security_age: int + scott_annual_social_security_dollars: float + federal_dividends_and_long_term_gains_brackets: List[Tuple[Money, float]] + federal_ordinary_income_tax_brackets: List[Tuple[Money, float]] + returns_and_expenses: rai.ReturnsAndExpenses + + def __repr__(self): + with su.SprintfStdout() as buf: + print('SIMULATION PARAMETERS:') + print(f' initial_annual_expenses: {self.initial_annual_expenses}') + print(f' current_annual_expenses: {self.annual_expenses}') + print(f' lynn_social_security_age: {self.lynn_social_security_age}') + print(f' lynn_annual_social_security_dollars: {self.lynn_annual_social_security_dollars}') + print(f' scott_social_security_age: {self.scott_social_security_age}') + print(f' scott_annual_social_security_dollars: {self.scott_annual_social_security_dollars}') + print(f' returns_and_expenses: {self.returns_and_expenses}') + print(' federal_ordinary_income_tax_brackets: [') + for t in self.federal_ordinary_income_tax_brackets: + print(f' {t[0]} => {t[1]}') + print(' ]') + print(' federal_dividends_and_long_term_gains_brackets: [') + for t in self.federal_dividends_and_long_term_gains_brackets: + print(f' {t[0]} => {t[1]}') + print(' ]') + return buf() + + +DEFAULT_SIMULATION_PARAMS = SimulationParameters( + initial_account_states = [], + initial_annual_expenses = Money(150000), + annual_expenses = Money(150000), + lynn_social_security_age = 67, + lynn_annual_social_security_dollars = 40000, + scott_social_security_age = 67, + scott_annual_social_security_dollars = 40000, + federal_ordinary_income_tax_brackets = taxman.PESSIMISTIC_FEDERAL_INCOME_TAX_BRACKETS, + federal_dividends_and_long_term_gains_brackets = taxman.PESSIMISTIC_LONG_TERM_GAIN_FEDERAL_TAX_BRACKETS, + returns_and_expenses = None, +) diff --git a/simulation_results.py b/simulation_results.py new file mode 100644 index 0000000..4f4fff2 --- /dev/null +++ b/simulation_results.py @@ -0,0 +1,75 @@ +#!/usr/bin/env python3 + +from dataclasses import dataclass +from typing import List + +import string_utils as su +from type.money import Money + +import account +import taxman + +@dataclass(repr=False) +class SimulationResults(object): + success: bool + end_year: int + max_networth: Money + max_networth_year: int + max_taxes: Money + max_taxes_year: int + max_rollover: Money + max_rollover_year: int + max_rmd: Money + max_rmd_year: int + total_rollover: Money + total_social_security: Money + final_account_state: List[account.Account] + final_networth: Money + final_taxes: taxman.TaxCollector + + @classmethod + def create(cls) -> "SimulationResults": + return SimulationResults( + False, 0, + Money(0), 0, + Money(0), 0, + Money(0), 0, + Money(0), 0, + Money(0), Money(0), [], Money(0), None + ) + + def __repr__(self): + total = Money(0) + for a in self.final_account_state: + total += a.get_balance() + + with su.SprintfStdout() as ret: + print("SIMULATION RESULTS:") + print('%-54s: %18s' % ('Successful?', self.success)) + for x in self.final_account_state: + x.dump_final_report() + + print(self.final_taxes) + print('Simulation Maximums / Aggregates:') + print(' %-50s: %18s (%s)' % ( + 'Maximum net worth', f'{self.max_networth}', f'in {self.max_networth_year}' + )) + print(' %-50s: %18s (%s)' % ( + 'Final net worth', f'{total}', f'in {self.end_year}' + )) + print(' %-50s: %18s (%s)' % ( + 'Maximum annual RMDs', f'{self.max_rmd}', f'in {self.max_rmd_year}' + )) + print(' %-50s: %18s' % ( + 'Total social security', f'{self.total_social_security}' + )) + print(' %-50s: %18s (%s)' % ( + 'Maximum annual taxes due', f'{self.max_taxes}', f'in {self.max_taxes_year}' + )) + print(' %-50s: %18s' % ( + 'Total Roth conversions', f'{self.total_rollover}' + )) + print(' %-50s: %18s (%s)' % ( + 'Maximum Roth conversion', f'{self.max_rollover}', f'in {self.max_rollover_year}' + )) + return ret() diff --git a/tax_brackets.py b/tax_brackets.py deleted file mode 100644 index b2bd4a7..0000000 --- a/tax_brackets.py +++ /dev/null @@ -1,76 +0,0 @@ -import copy -import utils -from money import money - -class tax_brackets: - """A class to represent tax brackets and some operations on them.""" - - def __init__(self, brackets): - self.brackets = copy.deepcopy(brackets) - - def compute_taxes_for_income(self, income): - """Compute the tax bill for income given our brackets.""" - taxes_due = money(0) - while income > 1: - (threshold, rate) = self.get_bracket_for_income(income) - taxes_due += (income - threshold) * rate - income = threshold - assert taxes_due >= 0, "Somehow computed negative tax bill?!" - return taxes_due - - def get_bracket_for_income(self, income): - """Return the bracket that the last dollar of income was in.""" - assert income > 0, "Income should be >0 to be taxed" - rate = 0.0 - threshold = 0 - for bracket in self.brackets: - # Bracket is a tuple of (monetary_threshold, - # tax_rate). So bracket[0] is a dollar amount and - # bracket[1] is a tax rate. e.g. ( 250000, 0.20 ) - # indicates that every dollar you earn over 250K is - # taxed at 20%. - if (income > bracket[0] and rate < bracket[1]): - threshold = bracket[0] - rate = bracket[1] - return (threshold, rate) - - def get_bracket_above_income(self, income): - """Return the next bracket above the one activated by income.""" - assert income > 0, "Income should be >0 to be taxed" - rate = 1.0 - threshold = None - - # Walk the income tax brackets and look for the one just above - # the one this year's income is activating. - for bracket in self.brackets: - if (bracket[0] > income and bracket[1] < rate): - threshold = bracket[0] - rate = bracket[1] - - # Note: this can return (None, 1.0) iff the income is already - # in the top tax bracket. - return (threshold, rate) - - def get_bracket_below_income(self, income): - """Return the next bracket below the one activated by income.""" - assert income > 0, "Income should be >0 to be taxed" - bracket = self.get_bracket_for_income(income) - income = bracket[0] - return self.get_bracket_for_income(income) - - def get_effective_tax_rate_for_income(self, income): - """Compute and return the effective tax rate for an income.""" - if income <= 0: return 0 - tax_bill = self.compute_taxes_for_income(income) - return float(tax_bill) / income - - def adjust_with_multiplier(self, multiplier): - """Every year the IRS adjusts the income tax brackets for inflation.""" - for bracket in self.brackets: - if bracket[0] != 1: - bracket[0] *= multiplier - - def dump(self): - """Print out the tax brackets we're using in here.""" - for x in self.brackets: - print "{:<20} -> {:<3}".format(x[0], utils.format_rate(x[1])) diff --git a/tax_collector.py b/tax_collector.py deleted file mode 100644 index 7680764..0000000 --- a/tax_collector.py +++ /dev/null @@ -1,114 +0,0 @@ -import utils -from money import money - -class tax_collector(object): - def __init__(self): - # These four accumulate and then clear every year (i.e. every call - # to record_taxes_paid_and_reset_for_next_year) - self.ordinary_income = money(0) - self.short_term_gains = money(0) - self.dividends_and_long_term_gains = money(0) - self.roth_income = money(0) - - # The rest of these aggregate and are used as part of the final stats. - self.total_tax_bill = money(0) - self.total_ordinary_income = money(0) - self.total_short_term_gains = money(0) - self.total_dividends_and_long_term_gains = money(0) - self.total_roth_income = money(0) - self.total_aggregate_income = money(0) - - def record_taxes_paid_and_reset_for_next_year(self, - taxes_paid): - assert taxes_paid >= 0, "You can't pay negative taxes" - self.total_tax_bill += taxes_paid - self.total_aggregate_income += self.get_total_income() - assert self.total_aggregate_income >= 0, "Accumulator should be >= 0" - self.ordinary_income = money(0) - self.short_term_gains = money(0) - self.dividends_and_long_term_gains = money(0) - self.roth_income = money(0) - - def record_ordinary_income(self, amount): - assert amount >= 0, "Income should be non-negative; got %s" % amount - self.ordinary_income += amount - self.total_ordinary_income += amount - - def record_short_term_gain(self, amount): - assert amount >= 0, "Income should be non-negative; got %s" % amount - self.short_term_gains += amount - self.total_short_term_gains += amount - - def record_dividend_or_long_term_gain(self, amount): - assert amount >= 0, "Income should be non-negative; got %s" % amount - self.dividends_and_long_term_gains += amount - self.total_dividends_and_long_term_gains += amount - - def record_roth_income(self, amount): - assert amount >= 0, "Income should be non-negative; got %s" % amount - self.roth_income += amount - self.total_roth_income += amount - - def approximate_taxes(self, - standard_deduction, - ordinary_income_tax_brackets, - dividends_and_long_term_gains_brackets): - assert standard_deduction >= 0, "Standard deduction should be non-negative" - taxes_due = money(0) - - # Handle ordinary income: - ordinary_income = (self.ordinary_income + - self.short_term_gains - - standard_deduction) - if ordinary_income < 0: - ordinary_income = money(0) - taxes_due += ordinary_income_tax_brackets.compute_taxes_for_income( - ordinary_income) - - # Handle dividends and long term gains: - taxes_due += dividends_and_long_term_gains_brackets.compute_taxes_for_income( - self.dividends_and_long_term_gains) - - # Assume Roth money is still available tax free in the future. - assert taxes_due >= 0, "Computed negative taxes?!" - return taxes_due - - def how_many_more_dollars_can_we_earn_without_changing_tax_rate( - self, - federal_ordinary_income_tax_brackets): - """Return number of ordinary income dollars we can make without - changing this year's tax rate. Note: this may return None - which actually indicates something more like 'infinite since - you're already at the top tax bracket.'""" - income = self.ordinary_income - if income <= 1: income = 2 - b = federal_ordinary_income_tax_brackets.get_bracket_above_income( - income) - if b[0] is not None: - delta = b[0] - income - return delta - return 0 - - def get_total_income(self): - return (self.ordinary_income + - self.short_term_gains + - self.dividends_and_long_term_gains + - self.roth_income) - - def dump_final_report(self): - print " Taxes and income:" - print " {:<50}: {:>14}".format("Total aggregate income", - self.total_aggregate_income) - print " ...{:<47}: {:>14}".format("Ordinary income", - self.total_ordinary_income) - print " ...{:<47}: {:>14}".format("Income from short term gains", - self.total_short_term_gains) - print " ...{:<47}: {:>14}".format("Income from dividends and long term gains", - self.total_dividends_and_long_term_gains) - print " ...{:<47}: {:>14}".format("Roth income", - self.total_roth_income) - print " {:<50}: {:>14}".format("Total taxes paid", - self.total_tax_bill) - overall_tax_rate = float(self.total_tax_bill) / float(self.total_aggregate_income) - print " {:<50}: {:>14}".format("Effective tax rate", - utils.format_rate(overall_tax_rate)) diff --git a/taxman.py b/taxman.py new file mode 100644 index 0000000..44ab4ee --- /dev/null +++ b/taxman.py @@ -0,0 +1,219 @@ +#!/usr/bin/env python3 + +from typing import List, Optional, Tuple + +from type.money import Money +from type.rate import Rate +import string_utils as su + + +PESSIMISTIC_FEDERAL_INCOME_TAX_BRACKETS = [ + (Money(612351), Rate(0.70)), + (Money(408201), Rate(0.55)), + (Money(321451), Rate(0.45)), + (Money(168401), Rate(0.35)), + (Money( 78951), Rate(0.26)), + (Money( 19401), Rate(0.18)), + (Money( 1), Rate(0.13)), +] + +CURRENT_FEDERAL_INCOME_TAX_BRACKETS = [ + (Money(612351), Rate(0.37)), + (Money(408201), Rate(0.35)), + (Money(321451), Rate(0.32)), + (Money(168401), Rate(0.24)), + (Money( 78951), Rate(0.22)), + (Money( 19401), Rate(0.12)), + (Money( 1), Rate(0.10)), +] + +CURRENT_LONG_TERM_GAIN_FEDERAL_TAX_BRACKETS = [ + (Money(488851), Rate(0.20)), + (Money( 78751), Rate(0.15)), + (Money( 1), Rate(0.00)), +] + +PESSIMISTIC_LONG_TERM_GAIN_FEDERAL_TAX_BRACKETS = ( + PESSIMISTIC_FEDERAL_INCOME_TAX_BRACKETS) + + +federal_standard_deduction_dollars = Money(24800) # Federal tax standard deduction +federal_ordinary_income_tax_brackets = PESSIMISTIC_FEDERAL_INCOME_TAX_BRACKETS +federal_dividends_and_long_term_gains_brackets = CURRENT_LONG_TERM_GAIN_FEDERAL_TAX_BRACKETS + + +class TaxCollector(object): + def __init__( + self, + ordinary_income_brackets, + dividends_and_long_term_gains_brackets, + ): + self.ordinary_income_brackets = ordinary_income_brackets + self.dividends_and_long_term_gains_brackets = dividends_and_long_term_gains_brackets + + # These four accumulate and then clear every year (i.e. every call + # to record_taxes_paid_and_reset_for_next_year) + self.ordinary_income = Money(0) + self.short_term_gains = Money(0) + self.dividends_and_long_term_gains = Money(0) + self.roth_income = Money(0) + + # The rest of these aggregate and are used as part of the final stats. + self.total_tax_bill = Money(0) + self.total_ordinary_income = Money(0) + self.total_short_term_gains = Money(0) + self.total_dividends_and_long_term_gains = Money(0) + self.total_roth_income = Money(0) + self.total_aggregate_income = Money(0) + self.max_annual_income = None + self.max_annual_income_year = None + + def record_taxes_paid_and_reset_for_next_year(self, current_year: int): + self.total_tax_bill += self.approximate_annual_taxes() + income = self.get_total_annual_income() + if self.max_annual_income is None or income > self.max_annual_income: + self.max_annual_income = income + self.max_annual_income_year = current_year + self.total_aggregate_income += income + self.ordinary_income = Money(0) + self.short_term_gains = Money(0) + self.dividends_and_long_term_gains = Money(0) + self.roth_income = Money(0) + + def record_ordinary_income(self, amount: Money): + self.ordinary_income += amount + self.total_ordinary_income += amount + + def record_short_term_gain(self, amount: Money): + self.short_term_gains += amount + self.total_short_term_gains += amount + + def record_dividend_or_long_term_gain(self, amount: Money): + self.dividends_and_long_term_gains += amount + self.total_dividends_and_long_term_gains += amount + + def record_roth_income(self, amount: Money): + self.roth_income += amount + self.total_roth_income += amount + + def approximate_annual_taxes(self): + taxes_due = Money(0) + + # Handle ordinary income: + ordinary_income = (self.ordinary_income + + self.short_term_gains - + federal_standard_deduction_dollars) + if ordinary_income < 0: + ordinary_income = 0 + taxes_due += self.compute_taxes_on_income_using_brackets( + ordinary_income, + self.ordinary_income_brackets + ) + + # Handle dividends and long term gains: + taxes_due += self.compute_taxes_on_income_using_brackets( + self.dividends_and_long_term_gains, + self.dividends_and_long_term_gains_brackets + ) + + # Assume Roth money is still available tax free in the future. + return taxes_due + + def compute_taxes_on_income_using_brackets( + self, + income: Money, + brackets: List[Tuple[Money, Rate]] + ) -> Money: + taxes_due = Money(0) + while income > Money(1.0): + rate = Rate(0.0) + threshold = 0 + for bracket in brackets: + # Bracket is a tuple of (monetary_threshold, + # tax_rate). So bracket[0] is a dollar amount and + # bracket[1] is a tax rate. e.g. ( 250000, 0.20 ) + # indicates that every dollar you earn over 250K is + # taxed at 20%. + if (income > bracket[0] and rate < bracket[1]): + threshold = bracket[0] + rate = bracket[1] + taxed_amount = income - threshold + taxes_due += taxed_amount * rate + income = threshold + return taxes_due + + def how_many_more_dollars_can_we_earn_without_changing_tax_rate( + self + ) -> Optional[Money]: + """Return number of ordinary income dollars we can make without + changing this year's tax rate. Note: this may return None + which actually indicates something more like 'infinite since + you're already at the top tax bracket.'""" + threshold = None + rate = Rate(999.0) + income = self.ordinary_income + + # Kinda hacky but if there's been no ordinary income this year + # this method was saying "oh, well, you can earn one dollar + # before your tax rate goes from zero to something non-zero." + # This is correct but not useful -- this method is used to + # opportunistically shuffle pretax money into Roth. So let's + # assume we've earned at least one dollar of ordinary income + # this year and work from there. + if income <= Money(0): + income = Money(1.0) + + # Walk the income tax brackets and look for the one just above + # the one this year's income is activating. + for bracket in self.ordinary_income_brackets: + if (bracket[0] > income and bracket[1] < rate): + threshold = bracket[0] + rate = bracket[1] + + # If we found the bracket just above here, use it to compute a + # delta. + if threshold is not None: + assert threshold > income + delta = threshold - income + return delta + return None + + def get_total_annual_income(self) -> Money: + return ( + self.ordinary_income + + self.short_term_gains + + self.dividends_and_long_term_gains + + self.roth_income + ) + + def approximate_annual_tax_rate(self) -> Rate: + total_income = self.get_total_annual_income() + total_taxes = self.approximate_annual_taxes() + return Rate( + multiplier=float(total_taxes) / float(total_income) + ) + + def __repr__(self): + with su.SprintfStdout() as ret: + print("Taxes and Income:") + print(" %-50s: %18s" % ("Total aggregate income", + self.total_aggregate_income)) + print(" ...%-47s: %18s" % ("Ordinary income", + self.total_ordinary_income)) + print(" ...%-47s: %18s" % ("Income from short term gains", + self.total_short_term_gains)) + print(" ...%-47s: %18s" % ("Income from dividends and long term gains", + self.total_dividends_and_long_term_gains)) + print(" ...%-47s: %18s" % ("Roth income", + self.total_roth_income)) + print(" %-50s: %18s (%s)" % ("Maximum annual income", + self.max_annual_income, + f'in {self.max_annual_income_year}')) + print(" %-50s: %18s" % ("Total taxes paid", + self.total_tax_bill)) + overall_tax_rate = Rate( + float(self.total_tax_bill) / float(self.total_aggregate_income) + ) + print(" %-50s: %18s" % ("Effective tax rate", + overall_tax_rate), end='') + return ret() diff --git a/trials.py b/trials.py new file mode 100644 index 0000000..71f9d1e --- /dev/null +++ b/trials.py @@ -0,0 +1,23 @@ +#!/usr/bin/env python3 + +import copy +from typing import Iterable + +import simulation +import simulation_params +import simulation_results + + +def run_multiple_trials( + *, + params: simulation_params.SimulationParameters, + num_trials: int +) -> Iterable[simulation_results.SimulationResults]: + results = [] + for x in range(0, num_trials): + print(f'{x} / {num_trials}', end='\r') + sim = simulation.Simulation(copy.deepcopy(params)) + results.append( + sim.simulate(simulation.Verbosity.SILENT) + ) + return results diff --git a/utils.py b/utils.py deleted file mode 100644 index eddefdb..0000000 --- a/utils.py +++ /dev/null @@ -1,17 +0,0 @@ - -# Global helper functions -def truncate(n, decimals=2): - """Truncate a float to a particular number of decimals.""" - assert decimals > 0 and decimals < 10, "Decimals is weird" - multiplier = 10 ** decimals - return int(n * multiplier) / multiplier - -def format_rate(rate): - """Format a multiplier nee rate to look nice.""" - if rate >= 1.0: - return format_rate(rate - 1.0) - else: - return "{:<}%".format(round(rate * 100, 3)) - -def convert_rate_to_multiplier(rate): - return 1.0 + (rate / 100)