owlplanner 2025.12.5__py3-none-any.whl → 2025.12.20__py3-none-any.whl

owlplanner/plan.py

@@ -30,6 +30,8 @@ from . import rates
 from . import config
 from . import timelists
 from . import socialsecurity as socsec
+from . import debts as debts
+from . import fixedassets as fxasst
 from . import mylogging as log
 from . import progress
 from .plotting.factory import PlotFactory
@@ -208,12 +210,12 @@ def _timer(func):
     return wrapper
 
 
-class Plan(object):
+class Plan:
     """
     This is the main class of the Owl Project.
     """
 
-    def __init__(self, inames, yobs, mobs, expectancy, name, *, verbose=False, logstreams=None):
+    def __init__(self, inames, dobs, expectancy, name, *, verbose=False, logstreams=None):
         """
         Constructor requires three lists: the first
         one contains the name(s) of the individual(s),
@@ -249,13 +251,9 @@ class Plan(object):
         # self.setPlotBackend("matplotlib")
         self.setPlotBackend("plotly")
 
-        self.N_i = len(yobs)
+        self.N_i = len(dobs)
         if not (0 <= self.N_i <= 2):
             raise ValueError(f"Cannot support {self.N_i} individuals.")
-        if len(mobs) != len(yobs):
-            raise ValueError("Months and years arrays should have same length.")
-        if min(mobs) < 1 or max(mobs) > 12:
-            raise ValueError("Months must be between 1 and 12.")
         if self.N_i != len(expectancy):
             raise ValueError(f"Expectancy must have {self.N_i} entries.")
         if self.N_i != len(inames):
@@ -268,8 +266,8 @@ class Plan(object):
         # Default year OBBBA speculated to be expired and replaced by pre-TCJA rates.
         self.yOBBBA = 2032
         self.inames = inames
-        self.yobs = np.array(yobs, dtype=np.int32)
-        self.mobs = np.array(mobs, dtype=np.int32)
+        self.yobs, self.mobs, self.tobs = u.parseDobs(dobs)
+        self.dobs = dobs
         self.expectancy = np.array(expectancy, dtype=np.int32)
 
         # Reference time is starting date in the current year and all passings are assumed at the end.
@@ -316,6 +314,19 @@ class Plan(object):
         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))
 
+        # Debt payments array (length N_n)
+        self.debt_payments_n = np.zeros(self.N_n)
+
+        # Fixed assets arrays (length N_n)
+        self.fixed_assets_tax_free_n = np.zeros(self.N_n)
+        self.fixed_assets_ordinary_income_n = np.zeros(self.N_n)
+        self.fixed_assets_capital_gains_n = np.zeros(self.N_n)
+        # Fixed assets bequest value (assets with yod past plan end)
+        self.fixed_assets_bequest_value = 0.0
+
+        # Remaining debt balance at end of plan
+        self.remaining_debt_balance = 0.0
+
         # Previous 2 years of MAGI needed for Medicare.
         self.prevMAGI = np.zeros((2))
         self.MAGI_n = np.zeros(self.N_n)
@@ -341,6 +352,7 @@ class Plan(object):
         self._adjustedParameters = False
         self.timeListsFileName = "None"
         self.timeLists = {}
+        self.houseLists = {}
         self.zeroContributions()
         self.caseStatus = "unsolved"
         self.rateMethod = None
@@ -593,18 +605,29 @@ class Plan(object):
         thisyear = date.today().year
         self.zeta_in = np.zeros((self.N_i, self.N_n))
         for i in range(self.N_i):
+            # Check if age is in bound.
+            bornOnFirstDays = (self.tobs[i] <= 2)
+            bornOnFirst = (self.tobs[i] == 1)
+
+            eligible = 62 if bornOnFirstDays else 62 + 1/12
+            if ages[i] < eligible:
+                self.mylog.vprint(f"Resetting starting age of {self.inames[i]} to {eligible}.")
+                ages[i] = eligible
+
             # Check if claim age added to birth month falls next year.
-            realage = ages[i] + (self.mobs[i] - 1)/12
-            iage = int(realage)
-            realns = iage - thisyear + self.yobs[i]
+            # janage is age with reference to Jan 1 of yob.
+            janage = ages[i] + (self.mobs[i] - 1)/12
+            iage = int(janage)
+            realns = self.yobs[i] + iage - thisyear
             ns = max(0, realns)
             nd = self.horizons[i]
             self.zeta_in[i, ns:nd] = pias[i]
             # Reduce starting year due to month offset. If realns < 0, this has happened already.
             if realns >= 0:
-                self.zeta_in[i, ns] *= 1 - (realage % 1.)
+                self.zeta_in[i, ns] *= 1 - (janage % 1.)
+
             # Increase/decrease PIA due to claiming age.
-            self.zeta_in[i, :] *= socsec.getSelfFactor(fras[i], ages[i])
+            self.zeta_in[i, :] *= socsec.getSelfFactor(fras[i], ages[i], bornOnFirst)
 
             # Add spousal benefits if applicable.
             if self.N_i == 2 and spousalBenefits[i] > 0:
@@ -612,7 +635,7 @@ class Plan(object):
                 claimYear = max(self.yobs + (self.mobs - 1)/12 + ages)
                 claimAge = claimYear - self.yobs[i] - (self.mobs[i] - 1)/12
                 ns2 = max(0, int(claimYear) - thisyear)
-                spousalFactor = socsec.getSpousalFactor(fras[i], claimAge)
+                spousalFactor = socsec.getSpousalFactor(fras[i], claimAge, bornOnFirst)
                 self.zeta_in[i, ns2:nd] += spousalBenefits[i] * spousalFactor
                 # Reduce first year of benefit by month offset.
                 self.zeta_in[i, ns2] -= spousalBenefits[i] * spousalFactor * (claimYear % 1.)
@@ -906,9 +929,9 @@ class Plan(object):
         Missing rows (years) are populated with zero values.
         """
         try:
-            filename, self.timeLists = timelists.read(filename, self.inames, self.horizons, self.mylog)
+            filename, self.timeLists, self.houseLists = timelists.read(filename, self.inames, self.horizons, self.mylog)
         except Exception as e:
-            raise Exception(f"Unsuccessful read of Wages and Contributions: {e}") from e
+            raise Exception(f"Unsuccessful read of Household Financial Profile: {e}") from e
 
         self.timeListsFileName = filename
         self.setContributions()
@@ -942,9 +965,72 @@ class Plan(object):
 
         return self.timeLists
 
+    def processDebtsAndFixedAssets(self):
+        """
+        Process debts and fixed assets from houseLists and populate arrays.
+        Should be called after setContributions() and before solve().
+        """
+        thisyear = date.today().year
+
+        # Process debts
+        if "Debts" in self.houseLists and not self.houseLists["Debts"].empty:
+            self.debt_payments_n = debts.get_debt_payments_array(
+                self.houseLists["Debts"], self.N_n, thisyear
+            )
+            self.remaining_debt_balance = debts.get_remaining_debt_balance(
+                self.houseLists["Debts"], self.N_n, thisyear
+            )
+        else:
+            self.debt_payments_n = np.zeros(self.N_n)
+            self.remaining_debt_balance = 0.0
+
+        # Process fixed assets
+        if "Fixed Assets" in self.houseLists and not self.houseLists["Fixed Assets"].empty:
+            filing_status = "married" if self.N_i == 2 else "single"
+            (self.fixed_assets_tax_free_n,
+             self.fixed_assets_ordinary_income_n,
+             self.fixed_assets_capital_gains_n) = fxasst.get_fixed_assets_arrays(
+                self.houseLists["Fixed Assets"], self.N_n, thisyear, filing_status
+            )
+            # Calculate bequest value for assets with yod past plan end
+            self.fixed_assets_bequest_value = fxasst.get_fixed_assets_bequest_value(
+                self.houseLists["Fixed Assets"], self.N_n, thisyear
+            )
+        else:
+            self.fixed_assets_tax_free_n = np.zeros(self.N_n)
+            self.fixed_assets_ordinary_income_n = np.zeros(self.N_n)
+            self.fixed_assets_capital_gains_n = np.zeros(self.N_n)
+            self.fixed_assets_bequest_value = 0.0
+
+    def getFixedAssetsBequestValueInTodaysDollars(self):
+        """
+        Return the fixed assets bequest value in today's dollars.
+        This requires rates to be set to calculate gamma_n (inflation factor).
+
+        Returns:
+        --------
+        float
+            Fixed assets bequest value in today's dollars.
+            Returns 0.0 if rates not set, gamma_n not calculated, or no fixed assets.
+        """
+        if self.fixed_assets_bequest_value == 0.0:
+            return 0.0
+
+        # Check if we can calculate gamma_n
+        if self.rateMethod is None or not hasattr(self, 'tau_kn'):
+            # Rates not set yet - return 0
+            return 0.0
+
+        # Calculate gamma_n if not already calculated
+        if not hasattr(self, 'gamma_n') or self.gamma_n is None:
+            self.gamma_n = _genGamma_n(self.tau_kn)
+
+        # Convert: today's dollars = nominal dollars / inflation_factor
+        return self.fixed_assets_bequest_value / self.gamma_n[-1]
+
     def saveContributions(self):
         """
-        Return workbook on wages and contributions.
+        Return workbook on wages and contributions, including Debts and Fixed Assets.
         """
         if self.timeLists is None:
             return None
@@ -966,6 +1052,36 @@ class Plan(object):
             ws = wb.create_sheet(self.inames[1])
             fillsheet(ws, 1)
 
+        # Add Debts sheet if available
+        if "Debts" in self.houseLists and not self.houseLists["Debts"].empty:
+            ws = wb.create_sheet("Debts")
+            df = self.houseLists["Debts"]
+            for row in dataframe_to_rows(df, index=False, header=True):
+                ws.append(row)
+            _formatDebtsSheet(ws)
+        else:
+            # Create empty Debts sheet with proper columns
+            ws = wb.create_sheet("Debts")
+            df = pd.DataFrame(columns=["name", "type", "year", "term", "amount", "rate"])
+            for row in dataframe_to_rows(df, index=False, header=True):
+                ws.append(row)
+            _formatDebtsSheet(ws)
+
+        # Add Fixed Assets sheet if available
+        if "Fixed Assets" in self.houseLists and not self.houseLists["Fixed Assets"].empty:
+            ws = wb.create_sheet("Fixed Assets")
+            df = self.houseLists["Fixed Assets"]
+            for row in dataframe_to_rows(df, index=False, header=True):
+                ws.append(row)
+            _formatFixedAssetsSheet(ws)
+        else:
+            # Create empty Fixed Assets sheet with proper columns
+            ws = wb.create_sheet("Fixed Assets")
+            df = pd.DataFrame(columns=["name", "type", "basis", "value", "rate", "yod", "commission"])
+            for row in dataframe_to_rows(df, index=False, header=True):
+                ws.append(row)
+            _formatFixedAssetsSheet(ws)
+
         return wb
 
     def zeroContributions(self):
@@ -1178,8 +1294,8 @@ class Plan(object):
                         cgains *= oldTau1
                         # Past years are stored at the end of contributions and conversions arrays.
                         # Use negative index to access tail of array.
+                        # Past years are stored at the end of arrays, accessed via negative indexing
                         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)
 
@@ -1249,12 +1365,19 @@ class Plan(object):
             else:
                 bequest = 1
 
+            # Bequest constraint now refers only to savings accounts
+            # User specifies desired bequest from accounts (fixed assets are separate)
+            # Total bequest = accounts - debts + fixed_assets
+            # So: accounts >= desired_bequest_from_accounts + debts
+            # (fixed_assets are added separately in the total bequest calculation)
+            total_bequest_value = bequest + self.remaining_debt_balance
+
             row = self.A.newRow()
             for i in range(self.N_i):
                 row.addElem(_q3(self.C["b"], i, 0, self.N_n, self.N_i, self.N_j, self.N_n + 1), 1)
                 row.addElem(_q3(self.C["b"], i, 1, self.N_n, self.N_i, self.N_j, self.N_n + 1), 1 - self.nu)
                 row.addElem(_q3(self.C["b"], i, 2, self.N_n, self.N_i, self.N_j, self.N_n + 1), 1)
-            self.A.addRow(row, bequest, bequest)
+            self.A.addRow(row, total_bequest_value, total_bequest_value)
         elif objective == "maxBequest":
             spending = options["netSpending"]
             if not isinstance(spending, (int, float)):
@@ -1336,6 +1459,10 @@ class Plan(object):
         tau_0prev[tau_0prev < 0] = 0
         for n in range(self.N_n):
             rhs = -self.M_n[n] - self.J_n[n]
+            # Add fixed assets tax-free money (positive cash flow)
+            rhs += self.fixed_assets_tax_free_n[n]
+            # Subtract debt payments (negative cash flow)
+            rhs -= self.debt_payments_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)
             row.addElem(_q1(self.C["m"], n, self.N_n), 1)
@@ -1373,7 +1500,8 @@ class Plan(object):
 
     def _add_taxable_income(self):
         for n in range(self.N_n):
-            rhs = 0
+            # Add fixed assets ordinary income
+            rhs = self.fixed_assets_ordinary_income_n[n]
             row = self.A.newRow()
             row.addElem(_q1(self.C["e"], n, self.N_n), 1)
             for i in range(self.N_i):
@@ -1467,16 +1595,19 @@ class Plan(object):
                     row1.addElem(_q2(self.C["x"], i, n2, self.N_i, self.N_n), -1)
                     row2.addElem(_q2(self.C["x"], i, n2, self.N_i, self.N_n), +1)
 
+                    # Dividends and interest gains for year n2.
                     afac = (self.mu*self.alpha_ijkn[i, 0, 0, n2]
                             + np.sum(self.alpha_ijkn[i, 0, 1:, n2]*self.tau_kn[1:, n2]))
-                    afac = 0
+
                     row1.addElem(_q3(self.C["b"], i, 0, n2, self.N_i, self.N_j, self.N_n + 1), -afac)
                     row2.addElem(_q3(self.C["b"], i, 0, n2, self.N_i, self.N_j, self.N_n + 1), +afac)
 
                     row1.addElem(_q2(self.C["d"], i, n2, self.N_i, self.N_n), -afac)
                     row2.addElem(_q2(self.C["d"], i, n2, self.N_i, self.N_n), +afac)
 
+                    # Capital gains on stocks sold from taxable account accrued in year n2 - 1.
                     bfac = self.alpha_ijkn[i, 0, 0, n2] * max(0, self.tau_kn[0, max(0, n2-1)])
+
                     row1.addElem(_q3(self.C["w"], i, 0, n2, self.N_i, self.N_j, self.N_n), +afac - bfac)
                     row2.addElem(_q3(self.C["w"], i, 0, n2, self.N_i, self.N_j, self.N_n), -afac + bfac)
 
@@ -1733,6 +1864,9 @@ class Plan(object):
         self._adjustParameters(self.gamma_n, self.MAGI_n)
         self._buildOffsetMap(options)
 
+        # Process debts and fixed assets
+        self.processDebtsAndFixedAssets()
+
         solver = myoptions.get("solver", self.defaultSolver)
         if solver not in knownSolvers:
             raise ValueError(f"Unknown solver {solver}.")
@@ -1881,7 +2015,7 @@ class Plan(object):
             elif vkeys[i] == "fx":
                 x += [pulp.LpVariable(f"x_{i}", cat="Continuous", lowBound=Lb[i], upBound=Ub[i])]
             else:
-                raise RuntimeError(f"Internal error: Variable with wierd bound f{vkeys[i]}.")
+                raise RuntimeError(f"Internal error: Variable with weird bound {vkeys[i]}.")
 
         x.extend([pulp.LpVariable(f"z_{i}", cat="Binary") for i in range(self.nbins)])
 
@@ -1979,26 +2113,6 @@ class Plan(object):
 
         return solution, xx, solverSuccess, solverMsg
 
-    def _computeNIIT(self, MAGI_n, I_n, Q_n):
-        """
-        Compute ACA tax on Dividends (Q) and Interests (I).
-        Pass arguments to better understand dependencies.
-        For accounting for rent and/or 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 MAGI_n[n] > Gmax:
-                J_n[n] = tx.niitRate * min(MAGI_n[n] - Gmax, I_n[n] + Q_n[n])
-
-        return J_n
-
     def _computeNLstuff(self, x, includeMedicare):
         """
         Compute MAGI, Medicare costs, long-term capital gain tax rate, and
@@ -2013,7 +2127,7 @@ class Plan(object):
 
         self._aggregateResults(x, short=True)
 
-        self.J_n = self._computeNIIT(self.MAGI_n, self.I_n, self.Q_n)
+        self.J_n = tx.computeNIIT(self.N_i, self.MAGI_n, self.I_n, self.Q_n, self.n_d, self.N_n)
         self.psi_n = tx.capitalGainTaxRate(self.N_i, self.MAGI_n, self.gamma_n[:-1], self.n_d, self.N_n)
         # Compute Medicare through self-consistent loop.
         if includeMedicare:
@@ -2094,6 +2208,8 @@ class Plan(object):
             * self.alpha_ijkn[:, 0, 0, :Nn],
             axis=0,
         )
+        # Add fixed assets capital gains
+        self.Q_n += self.fixed_assets_capital_gains_n
         self.U_n = self.psi_n * self.Q_n
 
         self.MAGI_n = self.G_n + self.e_n + self.Q_n
@@ -2102,7 +2218,7 @@ class Plan(object):
                 * np.sum(self.alpha_ijkn[:, 0, 1:, :Nn] * self.tau_kn[1:, :], axis=1))
         self.I_n = np.sum(I_in, axis=0)
 
-        # Stop after building minimu required for self-consistent loop.
+        # Stop after building minimum required for self-consistent loop.
         if short:
             return
 
@@ -2165,6 +2281,34 @@ class Plan(object):
         sources["RothX"] = self.x_in
         sources["tax-free wdrwl"] = self.w_ijn[:, 2, :]
         sources["BTI"] = self.Lambda_in
+        # Debts and fixed assets (debts are negative as expenses)
+        # Reshape 1D arrays to match shape of other sources (N_i x N_n)
+        if self.N_i == 1:
+            sources["debt payments"] = -self.debt_payments_n.reshape(1, -1)
+            sources["fixed assets tax-free"] = self.fixed_assets_tax_free_n.reshape(1, -1)
+            sources["fixed assets ordinary"] = self.fixed_assets_ordinary_income_n.reshape(1, -1)
+            sources["fixed assets capital gains"] = self.fixed_assets_capital_gains_n.reshape(1, -1)
+        else:
+            # For married couples, split using eta between individuals.
+            debt_array = np.zeros((self.N_i, self.N_n))
+            debt_array[0, :] = -self.debt_payments_n * (1 - self.eta)
+            debt_array[1, :] = -self.debt_payments_n * self.eta
+            sources["debt payments"] = debt_array
+
+            fa_tax_free = np.zeros((self.N_i, self.N_n))
+            fa_tax_free[0, :] = self.fixed_assets_tax_free_n * (1 - self.eta)
+            fa_tax_free[1, :] = self.fixed_assets_tax_free_n * self.eta
+            sources["fixed assets tax-free"] = fa_tax_free
+
+            fa_ordinary = np.zeros((self.N_i, self.N_n))
+            fa_ordinary[0, :] = self.fixed_assets_ordinary_income_n * (1 - self.eta)
+            fa_ordinary[1, :] = self.fixed_assets_ordinary_income_n * self.eta
+            sources["fixed assets ordinary"] = fa_ordinary
+
+            fa_capital = np.zeros((self.N_i, self.N_n))
+            fa_capital[0, :] = self.fixed_assets_capital_gains_n * (1 - self.eta)
+            fa_capital[1, :] = self.fixed_assets_capital_gains_n * self.eta
+            sources["fixed assets capital gains"] = fa_capital
 
         savings = {}
         savings["taxable"] = self.b_ijn[:, 0, :]
@@ -2176,7 +2320,9 @@ class Plan(object):
 
         estate_j = np.sum(self.b_ijn[:, :, self.N_n], axis=0)
         estate_j[1] *= 1 - self.nu
-        self.bequest = np.sum(estate_j) / self.gamma_n[-1]
+        # Subtract remaining debt balance from estate
+        total_estate = np.sum(estate_j) - self.remaining_debt_balance
+        self.bequest = max(0.0, total_estate) / self.gamma_n[-1]
 
         self.basis = self.g_n[0] / self.xi_n[0]
 
@@ -2263,7 +2409,10 @@ class Plan(object):
         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]
+            if t >= len(tx.taxBracketNames):
+                tname = f"Bracket {t}"
+            else:
+                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)}"
 
@@ -2287,6 +2436,12 @@ class Plan(object):
         dic[" Total Medicare premiums paid"] = f"{u.d(taxPaidNow)}"
         dic["[Total Medicare premiums paid]"] = f"{u.d(taxPaid)}"
 
+        totDebtPayments = np.sum(self.debt_payments_n, axis=0)
+        if totDebtPayments > 0:
+            totDebtPaymentsNow = np.sum(self.debt_payments_n / self.gamma_n[:-1], axis=0)
+            dic[" Total debt payments"] = f"{u.d(totDebtPaymentsNow)}"
+            dic["[Total debt payments]"] = f"{u.d(totDebtPayments)}"
+
         if self.N_i == 2 and self.n_d < self.N_n:
             p_j = self.partialEstate_j * (1 - self.phi_j)
             p_j[1] *= 1 - self.nu
@@ -2321,9 +2476,16 @@ class Plan(object):
         estate[1] *= 1 - self.nu
         endyear = self.year_n[-1]
         lyNow = 1./self.gamma_n[-1]
-        totEstate = np.sum(estate)
+        debts = self.remaining_debt_balance
+        # Add fixed assets bequest value (assets with yod past plan end)
+        totEstate = np.sum(estate) - debts + self.fixed_assets_bequest_value
         dic["Year of final bequest"] = (f"{endyear}")
         dic[" Total value of final bequest"] = (f"{u.d(lyNow*totEstate)}")
+        if debts > 0:
+            dic[" After paying remaining debts of"] = (f"{u.d(lyNow*debts)}")
+        if self.fixed_assets_bequest_value > 0:
+            dic[" Fixed assets liquidated at end of plan"] = (f"{u.d(lyNow*self.fixed_assets_bequest_value)}")
+            dic["[Fixed assets liquidated at end of plan]"] = (f"{u.d(self.fixed_assets_bequest_value)}")
         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])}")
@@ -2331,6 +2493,8 @@ class Plan(object):
         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])}")
+        if debts > 0:
+            dic["» [Remaining debt balance]"] = (f"{u.d(debts)}")
 
         dic["Plan starting date"] = str(self.startDate)
         dic["Cumulative inflation factor at end of final year"] = (f"{self.gamma_n[-1]:.2f}")
@@ -2713,6 +2877,20 @@ class Plan(object):
             ws.append(lastRow)
             _formatSpreadsheet(ws, "currency")
 
+        # Federal income tax brackets.
+        TxDic = {}
+        for t in range(self.N_t):
+            TxDic[tx.taxBracketNames[t]] = self.T_tn[t, :]
+
+        TxDic["total"] = self.T_n
+        TxDic["NIIT"] = self.J_n
+        TxDic["LTCG"] = self.U_n
+        TxDic["10% penalty"] = self.P_n
+
+        sname = "Federal Income Tax"
+        ws = wb.create_sheet(sname)
+        fillsheet(ws, TxDic, "currency")
+
         # Allocations.
         jDic = {"taxable": 0, "tax-deferred": 1, "tax-free": 2}
         kDic = {"stocks": 0, "C bonds": 1, "T notes": 2, "common": 3}
@@ -2894,3 +3072,93 @@ def _formatSpreadsheet(ws, ftype):
                 cell.number_format = fstring
 
     return None
+
+
+def _formatDebtsSheet(ws):
+    """
+    Format Debts sheet with appropriate column formatting.
+    """
+    from openpyxl.utils import get_column_letter
+
+    # Format header row
+    for cell in ws[1]:
+        cell.style = "Pandas"
+
+    # Get column mapping from header
+    header_row = ws[1]
+    col_map = {}
+    for idx, cell in enumerate(header_row, start=1):
+        col_letter = get_column_letter(idx)
+        col_name = str(cell.value).lower() if cell.value else ""
+        col_map[col_letter] = col_name
+        # Set column width
+        width = max(len(str(cell.value)) + 4, 10)
+        ws.column_dimensions[col_letter].width = width
+
+    # Apply formatting based on column name
+    for col_letter, col_name in col_map.items():
+        if col_name in ["year", "term"]:
+            # Integer format
+            fstring = "#,##0"
+        elif col_name in ["rate"]:
+            # Number format (2 decimal places for percentages stored as numbers)
+            fstring = "#,##0.00"
+        elif col_name in ["amount"]:
+            # Currency format
+            fstring = "$#,##0_);[Red]($#,##0)"
+        else:
+            # Text columns (name, type) - no number formatting
+            continue
+
+        # Apply formatting to all data rows (skip header row 1)
+        for row in ws.iter_rows(min_row=2):
+            for cell in row:
+                if cell.column_letter == col_letter:
+                    cell.number_format = fstring
+
+    return None
+
+
+def _formatFixedAssetsSheet(ws):
+    """
+    Format Fixed Assets sheet with appropriate column formatting.
+    """
+    from openpyxl.utils import get_column_letter
+
+    # Format header row
+    for cell in ws[1]:
+        cell.style = "Pandas"
+
+    # Get column mapping from header
+    header_row = ws[1]
+    col_map = {}
+    for idx, cell in enumerate(header_row, start=1):
+        col_letter = get_column_letter(idx)
+        col_name = str(cell.value).lower() if cell.value else ""
+        col_map[col_letter] = col_name
+        # Set column width
+        width = max(len(str(cell.value)) + 4, 10)
+        ws.column_dimensions[col_letter].width = width
+
+    # Apply formatting based on column name
+    for col_letter, col_name in col_map.items():
+        if col_name in ["yod"]:
+            # Integer format
+            fstring = "#,##0"
+        elif col_name in ["rate", "commission"]:
+            # Number format (1 decimal place for percentages stored as numbers)
+            fstring = "#,##0.00"
+        elif col_name in ["basis", "value"]:
+            # Currency format
+            fstring = "$#,##0_);[Red]($#,##0)"
+        else:
+            # Text columns (name, type) - no number formatting
+            continue
+
+        # Apply formatting to all data rows (skip header row 1)
+        for row in ws.iter_rows(min_row=2):
+            for cell in row:
+                if cell.column_letter == col_letter:
+                    cell.number_format = fstring
+
+    return None

owlplanner/plotting/plotly_backend.py

@@ -829,7 +829,7 @@ class PlotlyBackend(PlotBackend):
                     stack_data.append(data)
 
                 # Add stacked area traces
-                for data, name in zip(stack_data, stack_names):
+                for data, name in zip(stack_data, stack_names, strict=True):
                     fig.add_trace(go.Scatter(
                         x=year_n,
                         y=data,

owlplanner/progress.py

@@ -7,18 +7,62 @@ Disclaimers: This code is for educational purposes only and does not constitute
 
 """
 
+from typing import Optional
 from owlplanner import utils as u
 
 
-class Progress(object):
-    def __init__(self, mylog):
+class Progress:
+    """
+    A simple progress indicator for long-running operations.
+
+    Displays progress as a percentage (0-100%) on a single line that updates
+    in place using carriage return.
+
+    Example:
+        prog = Progress(mylog)
+        prog.start()
+        for i in range(100):
+            prog.show(i / 100)
+        prog.finish()
+    """
+
+    def __init__(self, mylog: Optional[object] = None):
+        """
+        Initialize the progress indicator.
+
+        Args:
+            mylog: Logger object with a print() method. If None, progress
+                   updates will be silently ignored (useful for Streamlit UI).
+        """
         self.mylog = mylog
 
     def start(self):
-        self.mylog.print("|--- progress ---|")
+        """
+        Display the progress header.
+        """
+        if self.mylog is not None:
+            self.mylog.print("|--- progress ---|")
+
+    def show(self, x: float):
+        """
+        Display the current progress percentage.
+
+        Args:
+            x: Progress value between 0.0 and 1.0 (will be clamped to this range).
+               Values outside this range will be clamped.
+        """
+        if self.mylog is None:
+            return
+
+        # Clamp x to [0, 1] range
+        x = max(0.0, min(1.0, x))
 
-    def show(self, x):
-        self.mylog.print(f"\r\r{u.pc(x, f=0)}", end="")
+        # Use single \r for carriage return (double \r\r is unnecessary)
+        self.mylog.print(f"\r{u.pc(x, f=0)}", end="")
 
     def finish(self):
-        self.mylog.print()
+        """
+        Finish the progress display by printing a newline.
+        """
+        if self.mylog is not None:
+            self.mylog.print()

owlplanner/rates.py

@@ -238,7 +238,7 @@ class Rates(object):
                 if corrarr.shape == (Nk, Nk):
                     pass
                 # Only off-diagonal elements were provided: build full matrix.
-                elif corrarr.shape == ((Nk * Nk - Nk) / 2,):
+                elif corrarr.shape == ((Nk * (Nk - 1)) // 2,):
                     newcorr = np.identity(Nk)
                     x = 0
                     for i in range(Nk):