owlplanner 2025.5.15__py3-none-any.whl → 2025.5.28__py3-none-any.whl

owlplanner/config.py

@@ -65,7 +65,7 @@ def saveConfig(myplan, file, mylog):
     diconf["Rates Selection"] = {
         "Heirs rate on tax-deferred estate": float(100 * myplan.nu),
         "Long-term capital gain tax rate": float(100 * myplan.psi),
-        "Dividend tax rate": float(100 * myplan.mu),
+        "Dividend rate": float(100 * myplan.mu),
         "TCJA expiration year": myplan.yTCJA,
         "Method": myplan.rateMethod,
     }
@@ -182,20 +182,19 @@ def readConfig(file, *, verbose=True, logstreams=None, readContributions=True):
     # status = diconf['Basic Info']['Status']
     yobs = diconf["Basic Info"]["Birth year"]
     expectancy = diconf["Basic Info"]["Life expectancy"]
-    startDate = diconf["Basic Info"].get("Start date", "today")
     icount = len(yobs)
     s = ["", "s"][icount - 1]
     mylog.vprint(f"Plan for {icount} individual{s}: {inames}.")
-    p = plan.Plan(inames, yobs, expectancy, name, startDate=startDate, verbose=True, logstreams=logstreams)
+    p = plan.Plan(inames, yobs, expectancy, name, verbose=True, logstreams=logstreams)
     p._description = diconf.get("Description", "")
 
     # Assets.
+    startDate = diconf["Basic Info"].get("Start date", "today")
     balances = {}
     for acc in accountTypes:
         balances[acc] = diconf["Assets"][f"{acc} savings balances"]
-    p.setAccountBalances(
-        taxable=balances["taxable"], taxDeferred=balances["tax-deferred"], taxFree=balances["tax-free"]
-    )
+    p.setAccountBalances(taxable=balances["taxable"], taxDeferred=balances["tax-deferred"],
+                         taxFree=balances["tax-free"], startDate=startDate)
     if icount == 2:
         phi_j = diconf["Assets"]["Beneficiary fractions"]
         p.setBeneficiaryFractions(phi_j)
@@ -227,7 +226,7 @@ def readConfig(file, *, verbose=True, logstreams=None, readContributions=True):
     p.setPension(pensionAmounts, pensionAges, pensionIsIndexed)
 
     # Rates Selection.
-    p.setDividendRate(float(diconf["Rates Selection"]["Dividend tax rate"]))
+    p.setDividendRate(float(diconf["Rates Selection"].get("Dividend rate", 1.8)))    # Fix for mod.
     p.setLongTermCapitalTaxRate(float(diconf["Rates Selection"]["Long-term capital gain tax rate"]))
     p.setHeirsTaxRate(float(diconf["Rates Selection"]["Heirs rate on tax-deferred estate"]))
     p.yTCJA = int(diconf["Rates Selection"]["TCJA expiration year"])

owlplanner/plan.py

@@ -211,7 +211,7 @@ class Plan(object):
     This is the main class of the Owl Project.
     """
 
-    def __init__(self, inames, yobs, expectancy, name, *, startDate=None, verbose=False, logstreams=None):
+    def __init__(self, inames, yobs, expectancy, name, *, verbose=False, logstreams=None):
         """
         Constructor requires three lists: the first
         one contains the name(s) of the individual(s),
@@ -242,7 +242,9 @@ class Plan(object):
         self.defaultPlots = "nominal"
         self.defaultSolver = "HiGHS"
         self._plotterName = None
-        self.setPlotBackend("matplotlib")
+        # Pick a default plotting backend here.
+        # self.setPlotBackend("matplotlib")
+        self.setPlotBackend("plotly")
 
         self.N_i = len(yobs)
         if not (0 <= self.N_i <= 2):
@@ -281,9 +283,9 @@ class Plan(object):
 
         # Default parameters:
         self.psi = 0.15  # Long-term income tax rate on capital gains (decimal)
-        self.chi = 0.6  # Survivor fraction
-        self.mu = 0.02  # Dividend rate (decimal)
-        self.nu = 0.30  # Heirs tax rate (decimal)
+        self.chi = 0.6   # Survivor fraction
+        self.mu = 0.018  # Dividend rate (decimal)
+        self.nu = 0.30   # Heirs tax rate (decimal)
         self.eta = (self.N_i - 1) / 2  # Spousal deposit ratio (0 or .5)
         self.phi_j = np.array([1, 1, 1])  # Fractions left to other spouse at death
         self.smileDip = 15  # Percent to reduce smile profile
@@ -307,6 +309,10 @@ class Plan(object):
         # Previous 3 years for Medicare.
         self.prevMAGI = np.zeros((3))
 
+        # Init previous balance to none.
+        self.beta_ij = None
+        self.startDate = None
+
         # Default slack on profile.
         self.lambdha = 0
 
@@ -320,9 +326,6 @@ class Plan(object):
         # Prepare RMD time series.
         self.rho_in = tx.rho_in(self.yobs, self.N_n)
 
-        # If none was given, default is to begin plan on today's date.
-        self._setStartingDate(startDate)
-
         self._buildOffsetMap()
 
         # Initialize guardrails to ensure proper configuration.
@@ -363,7 +366,7 @@ class Plan(object):
     def _setStartingDate(self, mydate):
         """
         Set the date when the plan starts in the current year.
-        This is for reproducibility purposes.
+        This is mostly for reproducibility purposes and back projecting known balances to Jan 1st.
         String format of mydate is 'month/day'.
         """
         import calendar
@@ -463,7 +466,7 @@ class Plan(object):
 
     def setDividendRate(self, mu):
         """
-        Set dividend tax rate. Rate is in percent. Default 2%.
+        Set dividend tax rate. Rate is in percent. Default 1.8%.
         """
         if not (0 <= mu <= 100):
             raise ValueError("Rate must be between 0 and 100.")
@@ -549,9 +552,6 @@ class Plan(object):
                 ns = max(0, self.yobs[i] + ages[i] - thisyear)
                 nd = self.horizons[i]
                 self.pi_in[i, ns:nd] = amounts[i]
-                # Only include remaining part of current year.
-                if ns == 0:
-                    self.pi_in[i, 0] *= self.yearFracLeft
 
         self.pensionAmounts = np.array(amounts)
         self.pensionAges = np.array(ages, dtype=np.int32)
@@ -583,9 +583,6 @@ class Plan(object):
             ns = max(0, self.yobs[i] + ages[i] - thisyear)
             nd = self.horizons[i]
             self.zeta_in[i, ns:nd] = amounts[i]
-            # Only include remaining part of current year.
-            if ns == 0:
-                self.zeta_in[i, 0] *= self.yearFracLeft
 
         if self.N_i == 2:
             # Approximate calculation for spousal benefit (only valid at FRA).
@@ -618,8 +615,6 @@ class Plan(object):
             self.mylog.vprint("Securing", u.pc(self.chi, f=0), "of spending amount for surviving spouse.")
 
         self.xi_n = _genXi_n(profile, self.chi, self.n_d, self.N_n, dip, increase, delay)
-        # Account for time elapsed in the current year.
-        self.xi_n[0] *= self.yearFracLeft
 
         self.spendingProfile = profile
         self.smileDip = dip
@@ -654,9 +649,6 @@ class Plan(object):
         self.tau_kn = dr.genSeries(self.N_n).transpose()
         self.mylog.vprint(f"Generating rate series of {len(self.tau_kn[0])} years using {method} method.")
 
-        # Account for how late we are now in the first year and reduce rate accordingly.
-        self.tau_kn[:, 0] *= self.yearFracLeft
-
         # Once rates are selected, (re)build cumulative inflation multipliers.
         self.gamma_n = _genGamma_n(self.tau_kn)
         self._adjustedParameters = False
@@ -706,7 +698,7 @@ class Plan(object):
 
         return amount * self.gamma_n[span]
 
-    def setAccountBalances(self, *, taxable, taxDeferred, taxFree, units="k"):
+    def setAccountBalances(self, *, taxable, taxDeferred, taxFree, startDate=None, units="k"):
         """
         Three lists containing the balance of all assets in each category for
         each spouse.  For single individuals, these lists will contain only
@@ -725,11 +717,15 @@ class Plan(object):
         taxDeferred = u.rescale(taxDeferred, fac)
         taxFree = u.rescale(taxFree, fac)
 
-        self.b_ji = np.zeros((self.N_j, self.N_i))
-        self.b_ji[0][:] = taxable
-        self.b_ji[1][:] = taxDeferred
-        self.b_ji[2][:] = taxFree
-        self.beta_ij = self.b_ji.transpose()
+        self.bet_ji = np.zeros((self.N_j, self.N_i))
+        self.bet_ji[0][:] = taxable
+        self.bet_ji[1][:] = taxDeferred
+        self.bet_ji[2][:] = taxFree
+        self.beta_ij = self.bet_ji.transpose()
+
+        # If none was given, default is to begin plan on today's date.
+        self._setStartingDate(startDate)
+
         self.caseStatus = "modified"
 
         self.mylog.vprint("Taxable balances:", *[u.d(taxable[i]) for i in range(self.N_i)])
@@ -929,10 +925,6 @@ class Plan(object):
             self.myRothX_in[i, :h] = self.timeLists[iname]["Roth conv"].iloc[:h]
             self.Lambda_in[i, :h] = self.timeLists[iname]["big-ticket items"].iloc[:h]
 
-        #  In 1st year, reduce wages and contributions depending on starting date.
-        self.omega_in[:, 0] *= self.yearFracLeft
-        self.kappa_ijn[:, :, 0] *= self.yearFracLeft
-
         self.caseStatus = "modified"
 
         return self.timeLists
@@ -1215,13 +1207,17 @@ class Plan(object):
             spending = options["netSpending"]
             if not isinstance(spending, (int, float)):
                 raise ValueError(f"Desired spending provided {spending} is not a number.")
-            spending *= self.optionsUnits * self.yearFracLeft
+            spending *= self.optionsUnits
             self.B.setRange(_q1(self.C["g"], 0, self.N_n), spending, spending)
 
     def _add_initial_balances(self):
+        # Back project balances to the beginning of the year.
+        yearSpent = 1 - self.yearFracLeft
+
         for i in range(self.N_i):
             for j in range(self.N_j):
-                rhs = self.beta_ij[i, j]
+                backTau = 1 - yearSpent * np.sum(self.tau_kn[:, 0] * self.alpha_ijkn[i, j, :, 0])
+                rhs = self.beta_ij[i, j] * backTau
                 self.B.setRange(_q3(self.C["b"], i, j, 0, self.N_i, self.N_j, self.N_n + 1), rhs, rhs)
 
     def _add_surplus_deposit_linking(self):
@@ -2063,43 +2059,43 @@ class Plan(object):
         # Results
         dic["Plan name"] = self._name
         dic["Net yearly spending basis"] = u.d(self.g_n[0] / self.xi_n[0])
-        dic[f"Net spending for year {now}"] = u.d(self.g_n[0] / self.yearFracLeft)
-        dic[f"Net spending remaining in year {now}"] = u.d(self.g_n[0])
+        dic[f"Net spending for year {now}"] = u.d(self.g_n[0])
+        dic[f"Net spending remaining in year {now}"] = u.d(self.g_n[0] * self.yearFracLeft)
 
         totSpending = np.sum(self.g_n, axis=0)
         totSpendingNow = np.sum(self.g_n / self.gamma_n[:-1], axis=0)
-        dic["Total net spending"] = f"{u.d(totSpendingNow)}"
+        dic[" Total net spending"] = f"{u.d(totSpendingNow)}"
         dic["[Total net spending]"] = f"{u.d(totSpending)}"
 
         totRoth = np.sum(self.x_in, axis=(0, 1))
         totRothNow = np.sum(np.sum(self.x_in, axis=0) / self.gamma_n[:-1], axis=0)
-        dic["Total Roth conversions"] = f"{u.d(totRothNow)}"
+        dic[" Total Roth conversions"] = f"{u.d(totRothNow)}"
         dic["[Total Roth conversions]"] = f"{u.d(totRoth)}"
 
         taxPaid = np.sum(self.T_n, axis=0)
         taxPaidNow = np.sum(self.T_n / self.gamma_n[:-1], axis=0)
-        dic["Total income tax paid on ordinary income"] = f"{u.d(taxPaidNow)}"
-        dic["[Total income tax paid on ordinary income]"] = f"{u.d(taxPaid)}"
+        dic[" Total tax paid on ordinary income"] = f"{u.d(taxPaidNow)}"
+        dic["[Total tax paid on ordinary income]"] = f"{u.d(taxPaid)}"
         for t in range(self.N_t):
             taxPaid = np.sum(self.T_tn[t], axis=0)
             taxPaidNow = np.sum(self.T_tn[t] / self.gamma_n[:-1], axis=0)
             tname = tx.taxBracketNames[t]
-            dic[f"-- Subtotal in tax bracket {tname}"] = f"{u.d(taxPaidNow)}"
-            dic[f"-- [Subtotal in tax bracket {tname}]"] = f"{u.d(taxPaid)}"
+            dic[f"»  Subtotal in tax bracket {tname}"] = f"{u.d(taxPaidNow)}"
+            dic[f"» [Subtotal in tax bracket {tname}]"] = f"{u.d(taxPaid)}"
 
         penaltyPaid = np.sum(self.P_n, axis=0)
         penaltyPaidNow = np.sum(self.P_n / self.gamma_n[:-1], axis=0)
-        dic["-- Subtotal in early withdrawal penalty"] = f"{u.d(penaltyPaidNow)}"
-        dic["-- [Subtotal in early withdrawal penalty]"] = f"{u.d(penaltyPaid)}"
+        dic["»  Subtotal in early withdrawal penalty"] = f"{u.d(penaltyPaidNow)}"
+        dic["» [Subtotal in early withdrawal penalty]"] = f"{u.d(penaltyPaid)}"
 
         taxPaid = np.sum(self.U_n, axis=0)
         taxPaidNow = np.sum(self.U_n / self.gamma_n[:-1], axis=0)
-        dic["Total tax paid on gains and dividends"] = f"{u.d(taxPaidNow)}"
+        dic[" Total tax paid on gains and dividends"] = f"{u.d(taxPaidNow)}"
         dic["[Total tax paid on gains and dividends]"] = f"{u.d(taxPaid)}"
 
         taxPaid = np.sum(self.M_n, axis=0)
         taxPaidNow = np.sum(self.M_n / self.gamma_n[:-1], axis=0)
-        dic["Total Medicare premiums paid"] = f"{u.d(taxPaidNow)}"
+        dic[" Total Medicare premiums paid"] = f"{u.d(taxPaidNow)}"
         dic["[Total Medicare premiums paid]"] = f"{u.d(taxPaid)}"
 
         if self.N_i == 2 and self.n_d < self.N_n:
@@ -2107,50 +2103,51 @@ class Plan(object):
             p_j[1] *= 1 - self.nu
             nx = self.n_d - 1
             ynx = self.year_n[nx]
+            ynxNow = 1./self.gamma_n[nx + 1]
             totOthers = np.sum(p_j)
-            totOthersNow = totOthers / self.gamma_n[nx + 1]
             q_j = self.partialEstate_j * self.phi_j
             totSpousal = np.sum(q_j)
-            totSpousalNow = totSpousal / self.gamma_n[nx + 1]
             iname_s = self.inames[self.i_s]
             iname_d = self.inames[self.i_d]
-            dic[f"Sum of spousal transfer to {iname_s} in year {ynx}"] = (f"{u.d(totSpousalNow)}")
-            dic[f"[Sum of spousal transfer to {iname_s} in year {ynx}]"] = (
-                f"{u.d(totSpousal)}")
-            dic[f"-- [Spousal transfer to {iname_s} in year {ynx} - taxable]"] = (
-                f"{u.d(q_j[0])}")
-            dic[f"-- [Spousal transfer to {iname_s} in year {ynx} - tax-def]"] = (
-                f"{u.d(q_j[1])}")
-            dic[f"-- [Spousal transfer to {iname_s} in year {ynx} - tax-free]"] = (
-                f"{u.d(q_j[2])}")
-
-            dic[f"Sum of post-tax non-spousal bequests from {iname_d} in year {ynx}"] = (
-                f"{u.d(totOthersNow)}")
-            dic[f"[Sum of post-tax non-spousal bequests from {iname_d} in year {ynx}]"] = (
-                f"{u.d(totOthers)}")
-            dic[f"-- [Post-tax non-spousal bequests from {iname_d} in year {ynx} - taxable]"] = (
-                f"{u.d(p_j[0])}")
-            dic[f"-- [Post-tax non-spousal bequests from {iname_d} in year {ynx} - tax-def]"] = (
-                f"{u.d(p_j[1])}")
-            dic[f"-- [Post-tax non-spousal bequests from {iname_d} in year {ynx} - tax-free]"] = (
-                f"{u.d(p_j[2])}")
+            dic["Year of partial bequest"] = (f"{ynx}")
+            dic[f" Sum of spousal transfer to {iname_s}"] = (f"{u.d(ynxNow*totSpousal)}")
+            dic[f"[Sum of spousal transfer to {iname_s}]"] = (f"{u.d(totSpousal)}")
+            dic[f"»  Spousal transfer to {iname_s} - taxable"] = (f"{u.d(ynxNow*q_j[0])}")
+            dic[f"» [Spousal transfer to {iname_s} - taxable]"] = (f"{u.d(q_j[0])}")
+            dic[f"»  Spousal transfer to {iname_s} - tax-def"] = (f"{u.d(ynxNow*q_j[1])}")
+            dic[f"» [Spousal transfer to {iname_s} - tax-def]"] = (f"{u.d(q_j[1])}")
+            dic[f"»  Spousal transfer to {iname_s} - tax-free"] = (f"{u.d(ynxNow*q_j[2])}")
+            dic[f"» [Spousal transfer to {iname_s} - tax-free]"] = (f"{u.d(q_j[2])}")
+
+            dic[f" Sum of post-tax non-spousal bequest from {iname_d}"] = (f"{u.d(ynxNow*totOthers)}")
+            dic[f"[Sum of post-tax non-spousal bequest from {iname_d}]"] = (f"{u.d(totOthers)}")
+            dic[f"»  Post-tax non-spousal bequest from {iname_d} - taxable"] = (f"{u.d(ynxNow*p_j[0])}")
+            dic[f"» [Post-tax non-spousal bequest from {iname_d} - taxable]"] = (f"{u.d(p_j[0])}")
+            dic[f"»  Post-tax non-spousal bequest from {iname_d} - tax-def"] = (f"{u.d(ynxNow*p_j[1])}")
+            dic[f"» [Post-tax non-spousal bequest from {iname_d} - tax-def]"] = (f"{u.d(p_j[1])}")
+            dic[f"»  Post-tax non-spousal bequest from {iname_d} - tax-free"] = (f"{u.d(ynxNow*p_j[2])}")
+            dic[f"» [Post-tax non-spousal bequest from {iname_d} - tax-free]"] = (f"{u.d(p_j[2])}")
 
         estate = np.sum(self.b_ijn[:, :, self.N_n], axis=0)
         estate[1] *= 1 - self.nu
-        lastyear = self.year_n[-1]
+        endyear = self.year_n[-1]
+        lyNow = 1./self.gamma_n[-1]
         totEstate = np.sum(estate)
-        totEstateNow = totEstate / self.gamma_n[-1]
-        dic[f"Total estate value at the end of {lastyear}"] = (f"{u.d(totEstateNow)}")
-        dic[f"[Total estate value at the end of {lastyear}]"] = (f"{u.d(totEstate)}")
-        dic[f"-- [Post-tax account value at the end of {lastyear} - taxable]"] = (f"{u.d(estate[0])}")
-        dic[f"-- [Post-tax account value at the end of {lastyear} - tax-def]"] = (f"{u.d(estate[1])}")
-        dic[f"-- [Post-tax account value at the end of {lastyear} - tax-free]"] = (f"{u.d(estate[2])}")
+        dic["Year of final bequest"] = (f"{endyear}")
+        dic[" Total value of final bequest"] = (f"{u.d(lyNow*totEstate)}")
+        dic["[Total value of final bequest]"] = (f"{u.d(totEstate)}")
+        dic["»  Post-tax final bequest account value - taxable"] = (f"{u.d(lyNow*estate[0])}")
+        dic["» [Post-tax final bequest account value - taxable]"] = (f"{u.d(estate[0])}")
+        dic["»  Post-tax final bequest account value - tax-def"] = (f"{u.d(lyNow*estate[1])}")
+        dic["» [Post-tax final bequest account value - tax-def]"] = (f"{u.d(estate[1])}")
+        dic["»  Post-tax final bequest account value - tax-free"] = (f"{u.d(lyNow*estate[2])}")
+        dic["» [Post-tax final bequest account value - tax-free]"] = (f"{u.d(estate[2])}")
 
         dic["Plan starting date"] = str(self.startDate)
-        dic[f"Cumulative inflation factor from start date to end of {lastyear}"] = (f"{self.gamma_n[-1]:.2f}")
+        dic["Cumulative inflation factor at end of final year"] = (f"{self.gamma_n[-1]:.2f}")
         for i in range(self.N_i):
-            dic[f"{self.inames[i]:>12}'s {self.horizons[i]:02}-year life horizon"] = (
-                f"{now} -> {now + self.horizons[i] - 1}")
+            dic[f"{self.inames[i]:>14}'s life horizon"] = (f"{now} -> {now + self.horizons[i] - 1}")
+            dic[f"{self.inames[i]:>14}'s years planned"] = (f"{self.horizons[i]}")
 
         dic["Plan name"] = self._name
         dic["Number of decision variables"] = str(self.A.nvars)
@@ -2200,7 +2197,7 @@ class Plan(object):
             self.mylog.vprint("Warning: Rate method must be selected before plotting.")
             return None
 
-        fig = self._plotter.plot_rates(self._name, self.tau_kn, self.year_n, self.yearFracLeft,
+        fig = self._plotter.plot_rates(self._name, self.tau_kn, self.year_n,
                                        self.N_k, self.rateMethod, self.rateFrm, self.rateTo, tag)
 
         if figure:
@@ -2252,9 +2249,9 @@ class Plan(object):
         return None
 
     @_checkCaseStatus
-    def showAssetDistribution(self, tag="", value=None, figure=False):
+    def showAssetComposition(self, tag="", value=None, figure=False):
         """
-        Plot the distribution of each savings account in thousands of dollars
+        Plot the composition of each savings account in thousands of dollars
         during the simulation time. This function will generate three
         graphs, one for taxable accounts, one the tax-deferred accounts,
         and one for tax-free accounts.
@@ -2265,8 +2262,8 @@ class Plan(object):
         the default behavior of setDefaultPlots().
         """
         value = self._checkValue(value)
-        figures = self._plotter.plot_asset_distribution(self.year_n, self.inames, self.b_ijkn,
-                                                        self.gamma_n, value, self._name, tag)
+        figures = self._plotter.plot_asset_composition(self.year_n, self.inames, self.b_ijkn,
+                                                       self.gamma_n, value, self._name, tag)
         if figure:
             return figures
 
@@ -2376,7 +2373,9 @@ class Plan(object):
         title = self._name + "\nIncome Tax"
         if tag:
             title += " - " + tag
-        fig = self._plotter.plot_taxes(self.year_n, self.T_n, self.M_n, self.gamma_n,
+        # All taxes: ordinary income and dividends.
+        allTaxes = self.T_n + self.U_n
+        fig = self._plotter.plot_taxes(self.year_n, allTaxes, self.M_n, self.gamma_n,
                                        value, title, self.inames)
         if figure:
             return fig
@@ -2512,6 +2511,7 @@ class Plan(object):
                 self.b_ijn[i][0][-1],
                 0,
                 0,
+                0,
                 self.b_ijn[i][1][-1],
                 0,
                 0,
@@ -2520,7 +2520,6 @@ class Plan(object):
                 self.b_ijn[i][2][-1],
                 0,
                 0,
-                0,
             ]
             ws.append(lastRow)
             _formatSpreadsheet(ws, "currency")

owlplanner/plotting/base.py

@@ -25,7 +25,7 @@ class PlotBackend(ABC):
         pass
 
     @abstractmethod
-    def plot_rates(self, name, tau_kn, year_n, year_frac_left, N_k, rate_method,
+    def plot_rates(self, name, tau_kn, year_n, N_k, rate_method,
                    rate_frm=None, rate_to=None, tag=""):
         """Plot rate values used over the time horizon."""
         pass
@@ -51,8 +51,8 @@ class PlotBackend(ABC):
         pass
 
     @abstractmethod
-    def plot_asset_distribution(self, year_n, inames, b_ijkn, gamma_n, value, name, tag):
-        """Plot asset distribution over time."""
+    def plot_asset_composition(self, year_n, inames, b_ijkn, gamma_n, value, name, tag):
+        """Plot asset composition over time."""
         pass
 
     @abstractmethod

owlplanner/plotting/matplotlib_backend.py

@@ -108,6 +108,9 @@ class MatplotlibBackend(PlotBackend):
             df.drop("partial", axis=1, inplace=True)
             means = df.mean(axis=0, numeric_only=True)
             medians = df.median(axis=0, numeric_only=True)
+            my[0] = my[1]
+
+        nfields = len(means)
 
         df /= 1000
         if len(df) > 0:
@@ -118,7 +121,7 @@ class MatplotlibBackend(PlotBackend):
                 sbn.histplot(df, multiple="dodge", kde=True, ax=axes)
                 legend = []
                 # Don't know why but legend is reversed from df.
-                for q in range(len(means) - 1, -1, -1):
+                for q in range(nfields - 1, -1, -1):
                     dmedian = u.d(medians.iloc[q], latex=True)
                     dmean = u.d(means.iloc[q], latex=True)
                     legend.append(f"{my[q]}: $M$: {dmedian}, $\\bar{{x}}$: {dmean}")
@@ -126,13 +129,14 @@ class MatplotlibBackend(PlotBackend):
                 plt.xlabel(f"{thisyear} $k")
                 plt.title(objective)
                 leads = [f"partial {my[0]}", f"  final {my[1]}"]
-            elif len(means) == 2:
+                leads = leads if nfields == 2 else leads[1:]
+            elif nfields == 2:
                 # Show partial bequest and net spending as two separate histograms.
                 fig, axes = plt.subplots(1, 2, figsize=(10, 5))
                 cols = ["partial", objective]
                 leads = [f"partial {my[0]}", objective]
-                for q in range(2):
-                    sbn.histplot(df[cols[q]], kde=True, ax=axes[q])
+                for q, col in enumerate(cols):
+                    sbn.histplot(df[col], kde=True, ax=axes[q])
                     dmedian = u.d(medians.iloc[q], latex=True)
                     dmean = u.d(means.iloc[q], latex=True)
                     legend = [f"$M$: {dmedian}, $\\bar{{x}}$: {dmean}"]
@@ -154,7 +158,7 @@ class MatplotlibBackend(PlotBackend):
 
             plt.suptitle(title)
 
-            for q in range(len(means)):
+            for q in range(nfields):
                 print(f"{leads[q]:>12}: Median ({thisyear} $): {u.d(medians.iloc[q])}", file=description)
                 print(f"{leads[q]:>12}:   Mean ({thisyear} $): {u.d(means.iloc[q])}", file=description)
                 mmin = 1000 * df.iloc[:, q].min()
@@ -209,7 +213,7 @@ class MatplotlibBackend(PlotBackend):
         g.figure.suptitle(title, y=1.08)
         return g.figure
 
-    def plot_rates(self, name, tau_kn, year_n, year_frac_left, N_k,
+    def plot_rates(self, name, tau_kn, year_n, N_k,
                    rate_method, rate_frm=None, rate_to=None, tag=""):
         """Plot rate values used over the time horizon."""
         fig, ax = plt.subplots()
@@ -230,19 +234,12 @@ class MatplotlibBackend(PlotBackend):
         ltype = ["-", "-.", ":", "--"]
 
         for k in range(N_k):
-            # Don't plot partial rates for current year if mid-year.
-            if year_frac_left == 1:
-                data = 100 * tau_kn[k]
-                years = year_n
-            else:
-                data = 100 * tau_kn[k, 1:]
-                years = year_n[1:]
-
+            data = 100 * tau_kn[k]
             # Use ddof=1 to match pandas' statistical calculations from numpy.
             label = (
                 rate_name[k] + " <" + "{:.1f}".format(np.mean(data)) + " +/- {:.1f}".format(np.std(data, ddof=1)) + "%>"
             )
-            ax.plot(years, data, label=label, ls=ltype[k % N_k])
+            ax.plot(year_n, data, label=label, ls=ltype[k % N_k])
 
         ax.xaxis.set_major_locator(tk.MaxNLocator(integer=True))
         ax.legend(loc="best", reverse=False, fontsize=8, framealpha=0.7)
@@ -330,8 +327,8 @@ class MatplotlibBackend(PlotBackend):
 
         return self._line_income_plot(year_n, series, style, title, yformat)[0]
 
-    def plot_asset_distribution(self, year_n, inames, b_ijkn, gamma_n, value, name, tag):
-        """Plot asset distribution over time."""
+    def plot_asset_composition(self, year_n, inames, b_ijkn, gamma_n, value, name, tag):
+        """Plot asset composition over time."""
         if value == "nominal":
             yformat = r"\$k (nominal)"
             infladjust = 1
@@ -352,7 +349,7 @@ class MatplotlibBackend(PlotBackend):
                 y2stack[namek] = np.zeros((len(inames), len(years_n)))
                 for i in range(len(inames)):
                     y2stack[namek][i][:] = b_ijkn[i][jDic[jkey]][kDic[kkey]][:] / infladjust
-            title = name + "\nAssets Distribution - " + jkey
+            title = name + "\nAsset Composition - " + jkey
             if tag:
                 title += " - " + tag
             fig, ax = self._stack_plot(years_n, inames, title, range(len(inames)),
@@ -420,12 +417,12 @@ class MatplotlibBackend(PlotBackend):
 
     def plot_taxes(self, year_n, T_n, M_n, gamma_n, value, title, inames):
         """Plot taxes over time."""
-        style = {"income taxes": "-", "Medicare": "-."}
+        style = {"income tax": "-", "Medicare": "-."}
         if value == "nominal":
-            series = {"income taxes": T_n, "Medicare": M_n}
+            series = {"income tax": T_n, "Medicare": M_n}
             yformat = r"\$k (nominal)"
         else:
-            series = {"income taxes": T_n / gamma_n[:-1], "Medicare": M_n / gamma_n[:-1]}
+            series = {"income tax": T_n / gamma_n[:-1], "Medicare": M_n / gamma_n[:-1]}
             yformat = r"\$k (" + str(year_n[0]) + r"\$)"
         fig, ax = self._line_income_plot(year_n, series, style, title, yformat)
 

owlplanner/plotting/plotly_backend.py

@@ -88,6 +88,9 @@ class PlotlyBackend(PlotBackend):
             margin=dict(b=150)
         )
 
+        # Format y-axis as number
+        fig.update_yaxes(tickformat=",.1f")
+
         return fig
 
     def plot_gross_income(self, year_n, G_n, gamma_n, value, title, tax_brackets):
@@ -195,6 +198,11 @@ class PlotlyBackend(PlotBackend):
         # Format y-axis as k
         fig.update_yaxes(tickformat=",.0f")
 
+        ymin = np.min(net_data)
+        ymax = np.max(net_data)
+        if np.abs(ymax - ymin) < 1:
+            fig.update_layout(yaxis=dict(range=[np.floor(ymin)-1, np.ceil(ymax)+1]))
+
         return fig
 
     def plot_taxes(self, year_n, T_n, M_n, gamma_n, value, title, inames):
@@ -215,7 +223,7 @@ class PlotlyBackend(PlotBackend):
         fig.add_trace(go.Scatter(
             x=year_n,
             y=income_tax_data,
-            name="income taxes",
+            name="income tax",
             line=dict(width=2)
         ))
 
@@ -250,7 +258,7 @@ class PlotlyBackend(PlotBackend):
 
         return fig
 
-    def plot_rates(self, name, tau_kn, year_n, year_frac_left, N_k, rate_method, rate_frm=None, rate_to=None, tag=""):
+    def plot_rates(self, name, tau_kn, year_n, N_k, rate_method, rate_frm=None, rate_to=None, tag=""):
         """Plot rate values used over the time horizon."""
         fig = go.Figure()
 
@@ -273,13 +281,7 @@ class PlotlyBackend(PlotBackend):
 
         # Plot each rate
         for k in range(N_k):
-            # Don't plot partial rates for current year if mid-year
-            if year_frac_left == 1:
-                data = 100 * tau_kn[k]
-                years = year_n
-            else:
-                data = 100 * tau_kn[k, 1:]
-                years = year_n[1:]
+            data = 100 * tau_kn[k]
 
             # Calculate mean and std
             mean_val = np.mean(data)
@@ -288,7 +290,7 @@ class PlotlyBackend(PlotBackend):
 
             # Add trace
             fig.add_trace(go.Scatter(
-                x=years,
+                x=year_n,
                 y=data,
                 name=label,
                 line=dict(
@@ -569,7 +571,10 @@ class PlotlyBackend(PlotBackend):
             df.drop("partial", axis=1, inplace=True)
             means = df.mean(axis=0, numeric_only=True)
             medians = df.median(axis=0, numeric_only=True)
+            my[0] = my[1]
 
+        colors = ["orange", "green"]
+        nfields = len(means)
         # Convert to thousands
         df /= 1000
 
@@ -591,7 +596,7 @@ class PlotlyBackend(PlotBackend):
                         x=df[col],
                         name=label,
                         opacity=0.7,
-                        marker_color="orange"
+                        marker_color=colors[i]
                     ))
 
                 # Update layout
@@ -612,8 +617,9 @@ class PlotlyBackend(PlotBackend):
                 )
 
                 leads = [f"partial {my[0]}", f"  final {my[1]}"]
+                leads = leads if nfields == 2 else leads[1:]
 
-            elif len(means) == 2:
+            elif nfields == 2:
                 # Two separate histograms
                 fig = make_subplots(
                     rows=1, cols=2,
@@ -634,23 +640,12 @@ class PlotlyBackend(PlotBackend):
                         go.Histogram(
                             x=df[col],
                             name=label,
-                            marker_color="orange",
-                            showlegend=False
+                            marker_color=colors[i],
+                            showlegend=True
                         ),
                         row=1, col=i+1
                     )
 
-                    # Add statistics annotation
-                    fig.add_annotation(
-                        x=0.01, y=0.99,
-                        xref=f"x{i+1}",
-                        yref="paper",
-                        text=label,
-                        showarrow=False,
-                        font=dict(size=10),
-                        bgcolor="rgba(0, 0, 0, 0)"
-                    )
-
                 # Update layout
                 fig.update_layout(
                     title=title,
@@ -661,7 +656,9 @@ class PlotlyBackend(PlotBackend):
 
                 # Update y-axis labels
                 fig.update_yaxes(title_text="Count", row=1, col=1)
-                fig.update_yaxes(title_text="Count", row=1, col=2)
+                # fig.update_yaxes(title_text="Count", row=1, col=2)
+                fig.update_xaxes(title_text=f"{thisyear} $k", row=1, col=1)
+                fig.update_xaxes(title_text=f"{thisyear} $k", row=1, col=2)
 
             else:
                 # Single histogram for net spending
@@ -697,7 +694,7 @@ class PlotlyBackend(PlotBackend):
                 leads = [objective]
 
             # Add statistics to description
-            for q in range(len(means)):
+            for q in range(nfields):
                 print(f"{leads[q]:>12}: Median ({thisyear} $): {u.d(medians.iloc[q])}", file=description)
                 print(f"{leads[q]:>12}:   Mean ({thisyear} $): {u.d(means.iloc[q])}", file=description)
                 mmin = 1000 * df.iloc[:, q].min()
@@ -710,7 +707,7 @@ class PlotlyBackend(PlotBackend):
 
         return None, description
 
-    def plot_asset_distribution(self, year_n, inames, b_ijkn, gamma_n, value, name, tag):
+    def plot_asset_composition(self, year_n, inames, b_ijkn, gamma_n, value, name, tag):
         """Plot asset distribution over time."""
         # Set up value formatting
         if value == "nominal":
@@ -762,7 +759,7 @@ class PlotlyBackend(PlotBackend):
                 ))
 
             # Update layout
-            title = f"{name}<br>Assets Distribution - {jkey}"
+            title = f"{name}<br>Asset Composition - {jkey}"
             if tag:
                 title += f" - {tag}"
 

owlplanner/version.py

@@ -1 +1 @@
-__version__ = "2025.05.15"
+__version__ = "2025.05.28"

{owlplanner-2025.5.15.dist-info → owlplanner-2025.5.28.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: owlplanner
-Version: 2025.5.15
+Version: 2025.5.28
 Summary: Owl: Retirement planner with great wisdom
 Project-URL: HomePage, https://github.com/mdlacasse/owl
 Project-URL: Repository, https://github.com/mdlacasse/owl
@@ -714,7 +714,7 @@ Description-Content-Type: text/markdown
 -------------------------------------------------------------------------------------
 
 ### TL;DR
-Owl is a financial retirement planning tool that uses a linear programming
+Owl is a retirement financial planning tool that uses a linear programming
 optimization algorithm to provide guidance on retirement decisions
 such as contributions, withdrawals, Roth conversions, and more.
 Users can select varying return rates to perform historical back testing,

{owlplanner-2025.5.15.dist-info → owlplanner-2025.5.28.dist-info}/RECORD

@@ -1,22 +1,22 @@
 owlplanner/__init__.py,sha256=hJ2i4m2JpHPAKyQLjYOXpJzeEsgcTcKD-Vhm0AIjjWg,592
 owlplanner/abcapi.py,sha256=m0vtoEzz9HJV7fOK_d7OnK7ha2Qbf7wLLPCJ9YZzR1k,6851
-owlplanner/config.py,sha256=qIWzj3Tbz_jhhFqIkaMzXzgWQBN4Uk2km_VIMZSh910,12559
+owlplanner/config.py,sha256=v6T6A_90rVyl4sfX8KLpI8wkzt9HCjUiGDsPS-4VTec,12588
 owlplanner/mylogging.py,sha256=tYMw04O-XYSzjTj36fmKJGLcE1VkK6k6oJNeqtKXzuc,2530
-owlplanner/plan.py,sha256=_Oq2UomWzteYVlT6zJC_A2zXO3YVlXG9xgUMcQfWBJg,106742
+owlplanner/plan.py,sha256=BnojjOQzzFdcT4dL8EALzc_vzXO2qQJJXjY98nRZIyA,107114
 owlplanner/progress.py,sha256=8jlCvvtgDI89zXVNMBg1-lnEyhpPvKQS2X5oAIpoOVQ,384
 owlplanner/rates.py,sha256=MiaibxJY82JGpAhGyF2BJTm5-rmVAUuG8KLApVQhjvU,14816
 owlplanner/tax2025.py,sha256=wmlZpYeeGNrbyn5g7wOFqhWbggppodtHqc-ex5XRooI,7850
 owlplanner/timelists.py,sha256=wNYnJqxJ6QqE6jHh5lfFqYngfw5wUFrI15LSsM5ae8s,3949
 owlplanner/utils.py,sha256=WpJgn79YZfH8UCkcmhd-AZlxlGuz1i1-UDBRXImsY6I,2485
-owlplanner/version.py,sha256=qgj6Tm2TUGY2hnWl84UnqBg_PfKL41UcaRHV7ghcCOI,28
+owlplanner/version.py,sha256=5-OFo8vhU5vD37pZxgc1DJNjT8dReNh-zTUao6lJAKE,28
 owlplanner/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 owlplanner/data/rates.csv,sha256=6fxg56BVVORrj9wJlUGFdGXKvOX5r7CSca8uhUbbuIU,3734
 owlplanner/plotting/__init__.py,sha256=VnF6ui78YrTrg1dA6hBIdI02ahzEaHVR3ZEdDe_i880,103
-owlplanner/plotting/base.py,sha256=1bU6iM1pGIE-l9p0GuulX4gRK_7ds96784Wb5oVUUR0,2449
+owlplanner/plotting/base.py,sha256=LP1TByl1tO4m087O6VpbZ_TTMnErHJGLTxXZXC9cuKQ,2431
 owlplanner/plotting/factory.py,sha256=i1k8m_ISnJw06f_JWlMvOQ7Q0PgV_BoLm05uLwFPvOQ,883
-owlplanner/plotting/matplotlib_backend.py,sha256=-M4Am7N0D8Nfv_tKNA1TneFYU_DuW_ZsoUBHRQWD_ok,17887
-owlplanner/plotting/plotly_backend.py,sha256=mu6V1pH-jOkKVs2QfQVQ_nlYgrniiHk4nFCx_ygJhiE,33036
-owlplanner-2025.5.15.dist-info/METADATA,sha256=kw_BIk15vSKoVPiBCUMl40dVrVPrtoweNhqvIZZP52o,54024
-owlplanner-2025.5.15.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-owlplanner-2025.5.15.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-owlplanner-2025.5.15.dist-info/RECORD,,
+owlplanner/plotting/matplotlib_backend.py,sha256=iJm3IBeMA5VUYG_zZxKPIzt4Izv2QWtWvlP656zwJVk,17738
+owlplanner/plotting/plotly_backend.py,sha256=5nqEUJXwLPW1vL9hQijxIUK57sWHvya6ZqIIYof-OjE,32944
+owlplanner-2025.5.28.dist-info/METADATA,sha256=MfSczDcOlFEnxDNOr1HD8NU_fqwvilnF4tTwngbQejE,54024
+owlplanner-2025.5.28.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+owlplanner-2025.5.28.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+owlplanner-2025.5.28.dist-info/RECORD,,