owlplanner 2025.6.3__py3-none-any.whl → 2025.7.1__py3-none-any.whl

owlplanner/config.py

@@ -65,7 +65,6 @@ def saveConfig(myplan, file, mylog):
     # Rates Selection.
     diconf["Rates Selection"] = {
         "Heirs rate on tax-deferred estate": float(100 * myplan.nu),
-        "Long-term capital gain tax rate": float(100 * myplan.psi),
         "Dividend rate": float(100 * myplan.mu),
         "TCJA expiration year": myplan.yTCJA,
         "Method": myplan.rateMethod,
@@ -228,7 +227,6 @@ def readConfig(file, *, verbose=True, logstreams=None, readContributions=True):
 
     # Rates Selection.
     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

@@ -283,7 +283,7 @@ class Plan(object):
             self.i_s = -1
 
         # Default parameters:
-        self.psi = 0.15  # Long-term income tax rate on capital gains (decimal)
+        self.psi_n = np.zeros(self.N_n)  # Long-term income tax rate on capital gains (decimal)
         self.chi = 0.6   # Survivor fraction
         self.mu = 0.018  # Dividend rate (decimal)
         self.nu = 0.30   # Heirs tax rate (decimal)
@@ -304,8 +304,8 @@ class Plan(object):
         # Parameters from timeLists initialized to zero.
         self.omega_in = np.zeros((self.N_i, self.N_n))
         self.Lambda_in = np.zeros((self.N_i, self.N_n))
-        self.myRothX_in = np.zeros((self.N_i, self.N_n))
-        self.kappa_ijn = np.zeros((self.N_i, self.N_j, self.N_n))
+        self.myRothX_in = np.zeros((self.N_i, self.N_n + 5))
+        self.kappa_ijn = np.zeros((self.N_i, self.N_j, self.N_n + 5))
 
         # Previous 3 years for Medicare.
         self.prevMAGI = np.zeros((2))
@@ -485,17 +485,6 @@ class Plan(object):
         self.caseStatus = "modified"
         self._adjustedParameters = False
 
-    def setLongTermCapitalTaxRate(self, psi):
-        """
-        Set long-term income tax rate. Rate is in percent. Default 15%.
-        """
-        if not (0 <= psi <= 100):
-            raise ValueError("Rate must be between 0 and 100.")
-        psi /= 100
-        self.mylog.vprint(f"Long-term capital gain income tax set to {u.pc(psi, f=0)}.")
-        self.psi = psi
-        self.caseStatus = "modified"
-
     def setBeneficiaryFractions(self, phi):
         """
         Set fractions of savings accounts that is left to surviving spouse.
@@ -920,14 +909,17 @@ class Plan(object):
         # Now fill in parameters which are in $.
         for i, iname in enumerate(self.inames):
             h = self.horizons[i]
-            self.omega_in[i, :h] = self.timeLists[iname]["anticipated wages"].iloc[:h]
-            self.kappa_ijn[i, 0, :h] = self.timeLists[iname]["taxable ctrb"].iloc[:h]
-            self.kappa_ijn[i, 1, :h] = self.timeLists[iname]["401k ctrb"].iloc[:h]
-            self.kappa_ijn[i, 2, :h] = self.timeLists[iname]["Roth 401k ctrb"].iloc[:h]
-            self.kappa_ijn[i, 1, :h] += self.timeLists[iname]["IRA ctrb"].iloc[:h]
-            self.kappa_ijn[i, 2, :h] += self.timeLists[iname]["Roth IRA ctrb"].iloc[:h]
-            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]
+            self.omega_in[i, :h] = self.timeLists[iname]["anticipated wages"].iloc[5:5+h]
+            self.Lambda_in[i, :h] = self.timeLists[iname]["big-ticket items"].iloc[5:5+h]
+
+            # Values for last 5 years of Roth conversion and contributions stored at the end
+            # of array and accessed with negative index.
+            self.kappa_ijn[i, 0, :h+5] = np.roll(self.timeLists[iname]["taxable ctrb"], -5)
+            self.kappa_ijn[i, 1, :h+5] = np.roll(self.timeLists[iname]["401k ctrb"], -5)
+            self.kappa_ijn[i, 1, :h+5] += np.roll(self.timeLists[iname]["IRA ctrb"], -5)
+            self.kappa_ijn[i, 2, :h+5] = np.roll(self.timeLists[iname]["Roth 401k ctrb"], -5)
+            self.kappa_ijn[i, 2, :h+5] += np.roll(self.timeLists[iname]["Roth IRA ctrb"], -5)
+            self.myRothX_in[i, :h+5] = np.roll(self.timeLists[iname]["Roth conv"], -5)
 
         self.caseStatus = "modified"
 
@@ -984,8 +976,9 @@ class Plan(object):
         ]
         for i, iname in enumerate(self.inames):
             h = self.horizons[i]
-            df = pd.DataFrame(0, index=np.arange(h), columns=cols)
-            df["year"] = self.year_n[:h]
+            df = pd.DataFrame(0, index=np.arange(0, h+5), columns=cols)
+            # df["year"] = self.year_n[:h]
+            df["year"] = np.arange(self.year_n[0] - 5, self.year_n[h-1]+1)
             self.timeLists[iname] = df
 
         self.caseStatus = "modified"
@@ -1086,6 +1079,7 @@ class Plan(object):
         self._add_standard_exemption_bounds()
         self._add_defunct_constraints()
         self._add_roth_conversion_constraints(options)
+        self._add_roth_maturation_constraints()
         self._add_withdrawal_limits()
         self._add_conversion_limits()
         self._add_objective_constraints(objective, options)
@@ -1127,6 +1121,43 @@ class Plan(object):
                 for j in range(self.N_j):
                     self.B.setRange(_q3(self.C["w"], self.i_d, j, n, self.N_i, self.N_j, self.N_n), 0, 0)
 
+    def _add_roth_maturation_constraints(self):
+        """
+        Withdrawals from Roth accounts are subject to the 5-year rule for conversion.
+        Conversions and gains are subject to the 5-year rule since conversion.
+        Contributions can be withdrawn at any time (without 59.5 penalty) but
+        gains on contributions are subject to the 5-year rule since the opening of the account.
+        A retainer is put on all conversions and associated gains, and gains on all recent contributions.
+        """
+        # Assume 10% per year for contributions and conversions for past 5 years.
+        # Future years will use the assumed returns.
+        oldTau1 = 1.10
+        for i in range(self.N_i):
+            h = self.horizons[i]
+            for n in range(h):
+                rhs = 0
+                # To add compounded gains to original amount.
+                cgains = 1
+                row = self.A.newRow()
+                row.addElem(_q3(self.C["b"], i, 2, n, self.N_i, self.N_j, self.N_n + 1), 1)
+                row.addElem(_q3(self.C["w"], i, 2, n, self.N_i, self.N_j, self.N_n), -1)
+                for dn in range(1, 6):
+                    nn = n - dn
+                    if nn >= 0:       # Past of future is now or in the future: use variables and parameters.
+                        Tau1 = 1 + np.sum(self.alpha_ijkn[i, 2, :, nn] * self.tau_kn[:, nn], axis=0)
+                        cgains *= Tau1
+                        row.addElem(_q2(self.C["x"], i, nn, self.N_i, self.N_n), -cgains)
+                        # If a contribution - it can be withdrawn but not the gains.
+                        rhs += (cgains - 1) * self.kappa_ijn[i, 2, nn]
+                    else:  # Past of future is in the past:
+                        # Parameters are stored at the end of contributions and conversions arrays.
+                        cgains *= oldTau1
+                        # If a contribution, it has no penalty, but assume a conversion.
+                        # rhs += (cgains - 1) * self.kappa_ijn[i, 2, nn] + cgains * self.myRothX_in[i, nn]
+                        rhs += cgains * self.kappa_ijn[i, 2, nn] + cgains * self.myRothX_in[i, nn]
+
+                self.A.addRow(row, rhs, np.inf)
+
     def _add_roth_conversion_constraints(self, options):
         if "maxRothConversion" in options and options["maxRothConversion"] == "file":
             for i in range(self.N_i):
@@ -1279,11 +1310,11 @@ class Plan(object):
         tau_0prev = np.roll(self.tau_kn[0, :], 1)
         tau_0prev[tau_0prev < 0] = 0
         for n in range(self.N_n):
-            rhs = -self.M_n[n]
+            rhs = -self.M_n[n] - self.J_n[n]
             row = self.A.newRow({_q1(self.C["g"], n, self.N_n): 1})
             row.addElem(_q1(self.C["s"], n, self.N_n), 1)
             for i in range(self.N_i):
-                fac = self.psi * self.alpha_ijkn[i, 0, 0, n]
+                fac = self.psi_n[n] * self.alpha_ijkn[i, 0, 0, n]
                 rhs += (
                     self.omega_in[i, n]
                     + self.zetaBar_in[i, n]
@@ -1534,7 +1565,7 @@ class Plan(object):
 
         # Check objective and required options.
         knownObjectives = ["maxBequest", "maxSpending"]
-        knownSolvers = ["HiGHS", "PuLP/CBC", "MOSEK"]
+        knownSolvers = ["HiGHS", "PuLP/CBC", "PuLP/HiGHS", "MOSEK"]
 
         knownOptions = [
             "bequest",
@@ -1593,18 +1624,22 @@ class Plan(object):
             raise ValueError(f"Slack value out of range {lambdha}.")
         self.lambdha = lambdha / 100
 
+        # Ensure parameters are adjusted for inflation.
         self._adjustParameters()
 
+        # Reset long-term capital gain tax rate to zero.
+        self.psi_n[:] = 0
+
         solver = myoptions.get("solver", self.defaultSolver)
         if solver not in knownSolvers:
             raise ValueError(f"Unknown solver {solver}.")
 
         if solver == "HiGHS":
             solverMethod = self._milpSolve
-        elif solver == "PuLP/CBC":
-            solverMethod = self._pulpSolve
         elif solver == "MOSEK":
             solverMethod = self._mosekSolve
+        elif "PuLP" in solver:
+            solverMethod = self._pulpSolve
         else:
             raise RuntimeError("Internal error in defining solverMethod.")
 
@@ -1666,7 +1701,7 @@ class Plan(object):
             old_x = xx
 
         if solverSuccess:
-            self.mylog.vprint(f"Self-consistent Medicare loop returned after {it} iterations.")
+            self.mylog.vprint(f"Self-consistent Medicare loop returned after {it+1} iterations.")
             self.mylog.vprint(solverMsg)
             self.mylog.vprint(f"Objective: {u.d(solution * objFac)}")
             # self.mylog.vprint('Upper bound:', u.d(-solution.mip_dual_bound))
@@ -1762,7 +1797,13 @@ class Plan(object):
         # solver = pulp.getSolver("MOSEK")
         # prob.solve(solver)
 
-        prob.solve(pulp.PULP_CBC_CMD(msg=False))
+        if "HiGHS" in options["solver"]:
+            solver = pulp.getSolver("HiGHS", msg=False)
+        else:
+            solver = pulp.getSolver("PULP_CBC_CMD", msg=False)
+
+        prob.solve(solver)
+
         # Filter out None values and convert to array.
         xx = np.array([0 if x[i].varValue is None else x[i].varValue for i in range(self.nvars)])
         solution = np.dot(c, xx)
@@ -1832,26 +1873,46 @@ class Plan(object):
 
         return solution, xx, solverSuccess, solverMsg
 
+    def _computeNIIT(self):
+        """
+        Compute Wages (W), Dividends (Q), Interests (I), and exemption(e).
+        For accounting for rent and trust income, one can easily add a column
+        to the Wages and Contributions file and add yearly amount to Q_n + I_n below.
+        """
+        J_n = np.zeros(self.N_n)
+        status = len(self.yobs) - 1
+
+        for n in range(self.N_n):
+            if status and n == self.n_d:
+                status -= 1
+
+            Gmax = tx.niitThreshold[status]
+            if self.MAGI_n[n] > Gmax:
+                J_n[n] = tx.niitRate * min(self.MAGI_n[n] - Gmax, self.I_n[n] + self.Q_n[n])
+
+        return J_n
+
     def _estimateMedicare(self, x=None, withMedicare=True):
         """
-        Compute rough MAGI and Medicare costs.
+        Compute MAGI, Medicare costs, long-term capital gain tax rate, and
+        net investment income tax (NIIT).
         """
-        if withMedicare is False:
+        if x is None or withMedicare is False:
+            self.MAGI_n = np.zeros(self.N_n)
+            self.J_n = np.zeros(self.N_n)
             self.M_n = np.zeros(self.N_n)
+            self.psi_n = np.zeros(self.N_n)
             return
 
-        if x is None:
-            MAGI_n = np.zeros(self.N_n)
-        else:
-            self.F_tn = np.array(x[self.C["F"] : self.C["g"]])
-            self.F_tn = self.F_tn.reshape((self.N_t, self.N_n))
-            MAGI_n = np.sum(self.F_tn, axis=0) + np.array(x[self.C["e"] : self.C["F"]])
+        self._aggregateResults(x, short=True)
 
-        self.M_n = tx.mediCosts(self.yobs, self.horizons, MAGI_n, self.prevMAGI, self.gamma_n[:-1], self.N_n)
+        self.J_n = self._computeNIIT()
+        self.M_n = tx.mediCosts(self.yobs, self.horizons, self.MAGI_n, self.prevMAGI, self.gamma_n[:-1], self.N_n)
+        self.psi_n = tx.capitalGainTaxRate(self.N_i, self.MAGI_n, self.gamma_n[:-1], self.n_d, self.N_n)
 
         return None
 
-    def _aggregateResults(self, x):
+    def _aggregateResults(self, x, short=False):
         """
         Utility function to aggregate results from solver.
         Process all results from solution vector.
@@ -1906,7 +1967,42 @@ class Plan(object):
         # self.z_inz = self.z_inz.reshape((Ni, Nn, Nz))
         # print(self.z_inz)
 
-        # Partial distribution at the passing of first spouse.
+        self.G_n = np.sum(self.F_tn, axis=0)
+
+        tau_0 = np.array(self.tau_kn[0, :])
+        tau_0[tau_0 < 0] = 0
+        # Last year's rates.
+        tau_0prev = np.roll(tau_0, 1)
+        self.Q_n = np.sum(
+            (
+                self.mu
+                * (self.b_ijn[:, 0, :-1] - self.w_ijn[:, 0, :] + self.d_in[:, :] + 0.5 * self.kappa_ijn[:, 0, :Nn])
+                + tau_0prev * self.w_ijn[:, 0, :]
+            )
+            * self.alpha_ijkn[:, 0, 0, :-1],
+            axis=0,
+        )
+        self.U_n = self.psi_n * self.Q_n
+
+        self.MAGI_n = self.G_n + self.e_n + self.Q_n
+
+        I_in = ((self.b_ijn[:, 0, :-1] + self.d_in - self.w_ijn[:, 0, :])
+                * np.sum(self.alpha_ijkn[:, 0, 1:, :-1] * self.tau_kn[1:, :], axis=1))
+        self.I_n = np.sum(I_in, axis=0)
+
+        # Stop after building minimu required for self-consistent loop.
+        if short:
+            return
+
+        self.T_tn = self.F_tn * self.theta_tn
+        self.T_n = np.sum(self.T_tn, axis=0)
+        self.P_n = np.zeros(Nn)
+        # Add early withdrawal penalty if any.
+        for i in range(Ni):
+            self.P_n[0:self.n59[i]] += 0.1*(self.w_ijn[i, 1, 0:self.n59[i]] + self.w_ijn[i, 2, 0:self.n59[i]])
+
+        self.T_n += self.P_n
+        # Compute partial distribution at the passing of first spouse.
         if Ni == 2 and n_d < Nn:
             nx = n_d - 1
             i_d = self.i_d
@@ -1932,30 +2028,6 @@ class Plan(object):
         self.rmd_in = self.rho_in * self.b_ijn[:, 1, :-1]
         self.dist_in = self.w_ijn[:, 1, :] - self.rmd_in
         self.dist_in[self.dist_in < 0] = 0
-        self.G_n = np.sum(self.F_tn, axis=0)
-        self.T_tn = self.F_tn * self.theta_tn
-        self.T_n = np.sum(self.T_tn, axis=0)
-        self.P_n = np.zeros(Nn)
-        # Add early withdrawal penalty if any.
-        for i in range(Ni):
-            self.P_n[0:self.n59[i]] += 0.1*(self.w_ijn[i, 1, 0:self.n59[i]] + self.w_ijn[i, 2, 0:self.n59[i]])
-
-        self.T_n += self.P_n
-
-        tau_0 = np.array(self.tau_kn[0, :])
-        tau_0[tau_0 < 0] = 0
-        # Last year's rates.
-        tau_0prev = np.roll(tau_0, 1)
-        self.Q_n = np.sum(
-            (
-                self.mu
-                * (self.b_ijn[:, 0, :-1] - self.w_ijn[:, 0, :] + self.d_in[:, :] + 0.5 * self.kappa_ijn[:, 0, :])
-                + tau_0prev * self.w_ijn[:, 0, :]
-            )
-            * self.alpha_ijkn[:, 0, 0, :-1],
-            axis=0,
-        )
-        self.U_n = self.psi * self.Q_n
 
         # Make derivative variables.
         # Putting it all together in a dictionary.
@@ -2093,6 +2165,11 @@ class Plan(object):
         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.J_n, axis=0)
+        taxPaidNow = np.sum(self.J_n / self.gamma_n[:-1], axis=0)
+        dic[" Total net investment income tax paid"] = f"{u.d(taxPaidNow)}"
+        dic["[Total net investment income tax paid]"] = 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)}"
@@ -2370,11 +2447,11 @@ class Plan(object):
         the default behavior of setDefaultPlots().
         """
         value = self._checkValue(value)
-        title = self._name + "\nIncome Tax"
+        title = self._name + "\nFederal Income Tax"
         if tag:
             title += " - " + tag
-        # All taxes: ordinary income and dividends.
-        allTaxes = self.T_n + self.U_n
+        # All taxes: ordinary income, dividends, and NIIT.
+        allTaxes = self.T_n + self.U_n + self.J_n
         fig = self._plotter.plot_taxes(self.year_n, allTaxes, self.M_n, self.gamma_n,
                                        value, title, self.inames)
         if figure:
@@ -2446,7 +2523,7 @@ class Plan(object):
             "net spending": self.g_n,
             "taxable ord. income": self.G_n,
             "taxable gains/divs": self.Q_n,
-            "Tax bills + Med.": self.T_n + self.U_n + self.M_n,
+            "Tax bills + Med.": self.T_n + self.U_n + self.M_n + self.J_n,
         }
 
         fillsheet(ws, incomeDic, "currency")
@@ -2460,7 +2537,7 @@ class Plan(object):
             "all BTI's": np.sum(self.Lambda_in, axis=0),
             "all wdrwls": np.sum(self.w_ijn, axis=(0, 1)),
             "all deposits": -np.sum(self.d_in, axis=0),
-            "ord taxes": -self.T_n,
+            "ord taxes": -self.T_n - self.J_n,
             "div taxes": -self.U_n,
             "Medicare": -self.M_n,
         }
@@ -2489,16 +2566,16 @@ class Plan(object):
         # Account balances except final year.
         accDic = {
             "taxable bal": self.b_ijn[:, 0, :-1],
-            "taxable ctrb": self.kappa_ijn[:, 0, :],
+            "taxable ctrb": self.kappa_ijn[:, 0, :self.N_n],
             "taxable dep": self.d_in,
             "taxable wdrwl": self.w_ijn[:, 0, :],
             "tax-deferred bal": self.b_ijn[:, 1, :-1],
-            "tax-deferred ctrb": self.kappa_ijn[:, 1, :],
+            "tax-deferred ctrb": self.kappa_ijn[:, 1, :self.N_n],
             "tax-deferred wdrwl": self.w_ijn[:, 1, :],
             "(included RMDs)": self.rmd_in[:, :],
             "Roth conv": self.x_in,
             "tax-free bal": self.b_ijn[:, 2, :-1],
-            "tax-free ctrb": self.kappa_ijn[:, 2, :],
+            "tax-free ctrb": self.kappa_ijn[:, 2, :self.N_n],
             "tax-free wdrwl": self.w_ijn[:, 2, :],
         }
         for i in range(self.N_i):
@@ -2595,12 +2672,12 @@ class Plan(object):
             planData[self.inames[i] + " txbl dep"] = self.d_in[i, :]
             planData[self.inames[i] + " txbl wrdwl"] = self.w_ijn[i, 0, :]
             planData[self.inames[i] + " tx-def bal"] = self.b_ijn[i, 1, :-1]
-            planData[self.inames[i] + " tx-def ctrb"] = self.kappa_ijn[i, 1, :]
+            planData[self.inames[i] + " tx-def ctrb"] = self.kappa_ijn[i, 1, :self.N_n]
             planData[self.inames[i] + " tx-def wdrl"] = self.w_ijn[i, 1, :]
             planData[self.inames[i] + " (RMD)"] = self.rmd_in[i, :]
             planData[self.inames[i] + " Roth conv"] = self.x_in[i, :]
             planData[self.inames[i] + " tx-free bal"] = self.b_ijn[i, 2, :-1]
-            planData[self.inames[i] + " tx-free ctrb"] = self.kappa_ijn[i, 2, :]
+            planData[self.inames[i] + " tx-free ctrb"] = self.kappa_ijn[i, 2, :self.N_n]
             planData[self.inames[i] + " tax-free wdrwl"] = self.w_ijn[i, 2, :]
             planData[self.inames[i] + " big-ticket items"] = self.Lambda_in[i, :]
 

owlplanner/tax2025.py

@@ -33,7 +33,7 @@ rates_nonTCJA = np.array([0.10, 0.15, 0.25, 0.28, 0.33, 0.35, 0.396])
 ###############################################################################
 # Single [0] and married filing jointly [1].
 
-# These are current.
+# These are 2025 current.
 taxBrackets_TCJA = np.array(
     [
         [11925, 48475, 103350, 197300, 250525, 626350, 9999999],
@@ -65,24 +65,57 @@ irmaaFees = 12 * np.array([185.00, 74.00, 111.00, 110.90, 111.00, 37.00])
 # These are speculated.
 taxBrackets_nonTCJA = np.array(
     [
-        [12150, 49550, 119950, 250200, 544000, 546200, 9999999],
-        [24350, 99100, 199850, 304600, 543950, 614450, 9999999],
+        [12150, 49550, 119950, 250200, 544000, 546200, 9999999],  # Single
+        [24350, 99100, 199850, 304600, 543950, 614450, 9999999],  # MFJ
     ]
 )
 
-# These are current.
-stdDeduction_TCJA = np.array([15000, 30000])
-# These are speculated.
-stdDeduction_nonTCJA = np.array([8300, 16600])
+# These are 2025 current (adjusted for inflation).
+stdDeduction_TCJA = np.array([15000, 30000])    # Single, MFJ
+# These are speculated (adjusted for inflation).
+stdDeduction_nonTCJA = np.array([8300, 16600])  # Single, MFJ
 
-# These are current.
-extra65Deduction = np.array([2000, 1600])
+# These are current (adjusted for inflation).
+extra65Deduction = np.array([2000, 1600])       # Single, MFJ
+
+# Thresholds for capital gains (adjusted for inflation).
+capGainRates = np.array(
+    [
+        [48350, 533400],
+        [96700, 600050],
+    ]
+)
+
+# Thresholds for net investment income tax (not adjusted for inflation).
+niitThreshold = np.array([200000, 250000])
+niitRate = 0.038
 
 ###############################################################################
 # End of section where rates need to be actualized every year.
 ###############################################################################
 
 
+def capitalGainTaxRate(Ni, magi_n, gamma_n, nd, Nn):
+    """
+    Return an array of decimal rates for capital gains.
+    Parameter nd is the index year of first passing of a spouse, if applicable,
+    nd == Nn for single individuals.
+    """
+    status = Ni - 1
+    cgRate_n = np.zeros(Nn)
+
+    for n in range(Nn):
+        if n == nd:
+            status -= 1
+
+        if magi_n[n] > gamma_n[n] * capGainRates[status][1]:
+            cgRate_n[n] = 0.20
+        elif magi_n[n] > gamma_n[n] * capGainRates[status][0]:
+            cgRate_n[n] = 0.15
+
+    return cgRate_n
+
+
 def mediCosts(yobs, horizons, magi, prevmagi, gamma_n, Nn):
     """
     Compute Medicare costs directly.

owlplanner/timelists.py

@@ -21,7 +21,7 @@ import pandas as pd
 
 
 # Expected headers in each excel sheet, one per individual.
-timeHorizonItems = [
+_timeHorizonItems = [
     "year",
     "anticipated wages",
     "taxable ctrb",
@@ -42,7 +42,7 @@ def read(finput, inames, horizons, mylog):
     year, anticipated wages, taxable ctrb, 401k ctrb, Roth 401k ctrb,
     IRA ctrb, Roth IRA ctrb, Roth conv, and big-ticket items.
     Supports xls, xlsx, xlsm, xlsb, odf, ods, and odt file extensions.
-    Returs a dictionary of dataframes by individual's names.
+    Return a dictionary of dataframes by individual's names.
     """
 
     mylog.vprint("Reading wages, contributions, conversions, and big-ticket items over time...")
@@ -59,14 +59,14 @@ def read(finput, inames, horizons, mylog):
             raise Exception(f"Could not read file {finput}: {e}.") from e
         streamName = f"file '{finput}'"
 
-    timeLists = condition(dfDict, inames, horizons, mylog)
+    timeLists = _condition(dfDict, inames, horizons, mylog)
 
     mylog.vprint(f"Successfully read time horizons from {streamName}.")
 
     return finput, timeLists
 
 
-def condition(dfDict, inames, horizons, mylog):
+def _condition(dfDict, inames, horizons, mylog):
     """
     Make sure that time horizons contain all years up to life expectancy,
     and that values are positive (except big-ticket items).
@@ -83,24 +83,25 @@ def condition(dfDict, inames, horizons, mylog):
 
         df = df.loc[:, ~df.columns.str.contains("^Unnamed")]
         for col in df.columns:
-            if col == "" or col not in timeHorizonItems:
+            if col == "" or col not in _timeHorizonItems:
                 df.drop(col, axis=1, inplace=True)
 
-        for item in timeHorizonItems:
+        for item in _timeHorizonItems:
             if item not in df.columns:
                 raise ValueError(f"Item {item} not found for {iname}.")
 
-        # Only consider lines in proper year range.
-        df = df[df["year"] >= thisyear]
+        # Only consider lines in proper year range. Go back 5 years for Roth maturation.
+        df = df[df["year"] >= (thisyear - 5)]
         df = df[df["year"] < endyear]
+        df = df.drop_duplicates("year")
         missing = []
-        for n in range(horizons[i]):
+        for n in range(-5, horizons[i]):
             year = thisyear + n
             if not (df[df["year"] == year]).any(axis=None):
                 df.loc[len(df)] = [year, 0, 0, 0, 0, 0, 0, 0, 0]
                 missing.append(year)
             else:
-                for item in timeHorizonItems:
+                for item in _timeHorizonItems:
                     if item != "big-ticket items" and df[item].iloc[n] < 0:
                         raise ValueError(f"Item {item} for {iname} in year {df['year'].iloc[n]} is < 0.")
 

owlplanner/version.py

@@ -1 +1 @@
-__version__ = "2025.06.03"
+__version__ = "2025.07.01"

{owlplanner-2025.6.3.dist-info → owlplanner-2025.7.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: owlplanner
-Version: 2025.6.3
+Version: 2025.7.1
 Summary: Owl: Retirement planner with great wisdom
 Project-URL: HomePage, https://github.com/mdlacasse/owl
 Project-URL: Repository, https://github.com/mdlacasse/owl
@@ -837,6 +837,8 @@ which are all tracked separately for married individuals. Asset transition to th
 is done according to beneficiary fractions for each type of savings account.
 Tax status covers married filing jointly and single, depending on the number of individuals reported.
 
+Maturation rules for Roth contributions and conversions are implemented as constraints
+limiting withdrawal amounts to cover Roth account balances for 5 years after the events.
 Medicare and IRMAA calculations are performed through a self-consistent loop on cash flow constraints.
 Future values are simple projections of current values with the assumed inflation rates.
 
@@ -885,7 +887,7 @@ assets to support, even with no estate being left.
 - Streamlit Community Cloud [Streamlit](https://streamlit.io)
 - Contributors: Josh (noimjosh@gmail.com) for Docker image code,
  Dale Seng (sengsational) for great insights and suggestions,
- Robert E. Anderson (NH-RedAnt) for bug fixes and suggestions.
+ Robert E. Anderson (NH-RedAnt) for bug fixes and suggestions, Clark Jefcoat (hubcity) for fruitful interactions.
 
 ---------------------------------------------------------------------
 
@@ -893,8 +895,8 @@ Copyright © 2024 - Martin-D. Lacasse
 
 Disclaimers: This code is for educatonal purposes only and does not constitute financial advice.
 
-Code output has been verified with analytical solutions and other approaches.
-Nevertheless, accuracy of results are not guaranteed.
+Code output has been verified with analytical solutions when applicable, and comparative approaches otherwise.
+Nevertheless, accuracy of results is not guaranteed.
 
 --------------------------------------------------------
 

{owlplanner-2025.6.3.dist-info → owlplanner-2025.7.1.dist-info}/RECORD

@@ -1,14 +1,14 @@
 owlplanner/__init__.py,sha256=hJ2i4m2JpHPAKyQLjYOXpJzeEsgcTcKD-Vhm0AIjjWg,592
 owlplanner/abcapi.py,sha256=8VCXS7nH_QZYxCUU3lwO0_UPR9Q5fuYQ6DHDLvHVLPg,6878
-owlplanner/config.py,sha256=onGIMqW2WwB9_CUZauDL6LtHGvc8O1cPUKKcK7Oh70M,12617
+owlplanner/config.py,sha256=-sSz37hwlnmI9_oXZn-R1rpmY0Vyk5L4X--NxGpgEMA,12446
 owlplanner/mylogging.py,sha256=RKUr-y-1XvKZzLMcfdtm4IM30LuRpJwb2qUeXmAWqME,2557
-owlplanner/plan.py,sha256=FgQB0kEV5BXsQdFzcVZwukpqJUy1qR2OYP8wS_owtfo,107055
+owlplanner/plan.py,sha256=rivQ9lSFJx6Eahx83VyTOm6n4uxjbr6LiwiyChRhAnc,111133
 owlplanner/progress.py,sha256=2DOjOLo6Mo7m21wY-9iZhoUksAyi4VCbb6UL2RegNCw,529
 owlplanner/rates.py,sha256=7jXcuHbkJ3AVIeBYZdwme18rdYslIzCuT-c0cLzvKUU,14819
-owlplanner/tax2025.py,sha256=HVYJq8po28jL5Z_il39ZY7qvf2riUEfxio15Zp7TGj8,7890
-owlplanner/timelists.py,sha256=HjoUJQU_ZbfdUy79DefQo5EAXpkfcuG_dOIO9qCljyM,3971
+owlplanner/tax2025.py,sha256=3uDJfKiSRFUp5WDcouAnTEQqEY7LnDKxqxDSKiTsOSQ,8927
+owlplanner/timelists.py,sha256=4pRumdoFlEmmh07wpGhDqauHl2doLG5JcRkvi41fvR4,4065
 owlplanner/utils.py,sha256=6Ky8ZKfNE9x--3znsZ8VZaT2PptDinszRxWsOCPanu8,2512
-owlplanner/version.py,sha256=s0nlL6F_JwS9jBAKvGDeVQurTia-o1wmPv43QaJETt4,28
+owlplanner/version.py,sha256=J00-UKwWWUboYr10jyhzSLOwp2iWtGoC1DRPgnuINV0,28
 owlplanner/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 owlplanner/data/rates.csv,sha256=6fxg56BVVORrj9wJlUGFdGXKvOX5r7CSca8uhUbbuIU,3734
 owlplanner/plotting/__init__.py,sha256=uhxqtUi0OI-QWNOO2LkXgQViW_9yM3rYb-204Wit974,250
@@ -16,7 +16,7 @@ owlplanner/plotting/base.py,sha256=UimGKpMTV-dVm3BX5Apr_Ltorc7dlDLCRPRQ3RF_v7c,2
 owlplanner/plotting/factory.py,sha256=EDopIAPQr9zHRgemObko18FlCeRNhNCoLNNFAOq-X6s,1030
 owlplanner/plotting/matplotlib_backend.py,sha256=AOEkapD94U5hGNoS0EdbRoe8mgdMHH4oOvkXADZS914,17957
 owlplanner/plotting/plotly_backend.py,sha256=AO33GxBHGYG5osir_H1iRRtGxdhs4AjfLV2d_xm35nY,33138
-owlplanner-2025.6.3.dist-info/METADATA,sha256=WhszwtjjNOjd2rfx3QHl6_E52ypcg1DpdJ6JJz3G1vY,53785
-owlplanner-2025.6.3.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-owlplanner-2025.6.3.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-owlplanner-2025.6.3.dist-info/RECORD,,
+owlplanner-2025.7.1.dist-info/METADATA,sha256=_T6vNe7aESAIt668fK9IVb0VDEv5P3Z16bYPyTvr9QY,54044
+owlplanner-2025.7.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+owlplanner-2025.7.1.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+owlplanner-2025.7.1.dist-info/RECORD,,