owlplanner 2025.8.1__py3-none-any.whl → 2025.11.2__py3-none-any.whl

owlplanner/config.py

@@ -296,6 +296,10 @@ def readConfig(file, *, verbose=True, logstreams=None, readContributions=True):
     # Solver Options.
     p.solverOptions = diconf["Solver Options"]
 
+    # Address legacy case files.
+    if diconf["Solver Options"].get("withMedicare", None) is True:
+        p.solverOptions["withMedicare"] = "loop"
+
     # Check consistency of noRothConversions.
     name = p.solverOptions.get("noRothConversions", "None")
     if name != "None" and name not in p.inames:

owlplanner/plan.py

@@ -1021,7 +1021,7 @@ class Plan(object):
         Refer to companion document for explanations.
         All binary variables must be lumped at the end of the vector.
         """
-        medi = options.get("optimizeMedicare", False)
+        medi = options.get("withMedicare", "loop") == "optimize"
 
         # Stack all variables in a single block vector with all binary variables at the end.
         C = {}
@@ -1223,8 +1223,8 @@ class Plan(object):
 
         for i in range(self.N_i):
             for j in range(self.N_j):
-                backTau = 1 - yearSpent * np.sum(self.tau_kn[:, 0] * self.alpha_ijkn[i, j, :, 0])
-                rhs = self.beta_ij[i, j] * backTau
+                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):
@@ -1386,7 +1386,7 @@ class Plan(object):
                 self.B.setRange(_q3(self.C["zx"], i, n, 1, self.N_i, self.N_n, self.N_zx), 0, 0)
 
     def _configure_Medicare_binary_variables(self, options):
-        if not options.get("optimizeMedicare", False):
+        if options.get("withMedicare", "loop") != "optimize":
             return
 
         bigM = options.get("bigM", 5e6)
@@ -1444,7 +1444,7 @@ class Plan(object):
                 self.A.addRow(row2, -np.inf, rhs2)
 
     def _add_Medicare_costs(self, options):
-        if not options.get("optimizeMedicare", False):
+        if options.get("withMedicare", "loop") != "optimize":
             return
 
         for n in range(self.nm):
@@ -1627,7 +1627,7 @@ class Plan(object):
             "netSpending",
             "noRothConversions",
             "oppCostX",
-            "optimizeMedicare",
+            "withMedicare",
             "previousMAGIs",
             "solver",
             "spendingSlack",
@@ -1635,7 +1635,6 @@ class Plan(object):
             "units",
             "xorConstraints",
             "withSCLoop",
-            "withMedicare",    # Ignore keyword.
         ]
         # We might modify options if required.
         options = {} if options is None else options
@@ -1713,7 +1712,7 @@ class Plan(object):
         """
         Self-consistent loop, regardless of solver.
         """
-        optimizeMedicare = options.get("optimizeMedicare", False)
+        includeMedicare = options.get("withMedicare", "loop") == "loop"
         withSCLoop = options.get("withSCLoop", True)
 
         if objective == "maxSpending":
@@ -1724,7 +1723,7 @@ class Plan(object):
         it = 0
         old_x = np.zeros(self.nvars)
         old_objfns = [np.inf]
-        self._computeNLstuff(None, optimizeMedicare)
+        self._computeNLstuff(None, includeMedicare)
         while True:
             objfn, xx, solverSuccess, solverMsg = solverMethod(objective, options)
 
@@ -1735,7 +1734,7 @@ class Plan(object):
             if not withSCLoop:
                 break
 
-            self._computeNLstuff(xx, optimizeMedicare)
+            self._computeNLstuff(xx, includeMedicare)
 
             delta = xx - old_x
             absSolDiff = np.sum(np.abs(delta), axis=0)/100
@@ -1955,7 +1954,7 @@ class Plan(object):
 
         return J_n
 
-    def _computeNLstuff(self, x, optimizeMedicare):
+    def _computeNLstuff(self, x, includeMedicare):
         """
         Compute MAGI, Medicare costs, long-term capital gain tax rate, and
         net investment income tax (NIIT).
@@ -1972,7 +1971,7 @@ class Plan(object):
         self.J_n = self._computeNIIT(self.MAGI_n, self.I_n, self.Q_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 not optimizeMedicare:
+        if includeMedicare:
             self.M_n = tx.mediCosts(self.yobs, self.horizons, self.MAGI_n, self.prevMAGI, self.gamma_n[:-1], self.N_n)
 
         return None

owlplanner/tax2025.py

@@ -70,7 +70,7 @@ taxBrackets_preTCJA = np.array(
     ]
 )
 
-# These are 2025 current (adjusted for inflation).
+# These are 2025 current.
 stdDeduction_OBBBA = np.array([15750, 31500])    # Single, MFJ
 # These are speculated (adjusted for inflation).
 stdDeduction_preTCJA = np.array([8300, 16600])  # Single, MFJ
@@ -78,7 +78,7 @@ stdDeduction_preTCJA = np.array([8300, 16600])  # Single, MFJ
 # These are current (adjusted for inflation) per individual.
 extra65Deduction = np.array([2000, 1600])       # Single, MFJ
 
-# Thresholds for capital gains (adjusted for inflation).
+# Thresholds setting capital gains brackets 0%, 15%, 20% (adjusted for inflation).
 capGainRates = np.array(
     [
         [48350, 533400],

owlplanner/tax2026.py

@@ -0,0 +1,339 @@
+"""
+
+Owl/tax2026
+---
+
+A retirement planner using linear programming optimization.
+
+See companion document for a complete explanation and description
+of all variables and parameters.
+
+Module to handle all tax calculations.
+
+Copyright © 2026 - Martin-D. Lacasse
+
+Disclaimers: This code is for educational purposes only and does not constitute financial advice.
+
+"""
+
+import numpy as np
+from datetime import date
+
+
+##############################################################################
+# Prepare the data.
+
+taxBracketNames = ["10%", "12/15%", "22/25%", "24/28%", "32/33%", "35%", "37/40%"]
+
+rates_OBBBA = np.array([0.10, 0.12, 0.22, 0.24, 0.32, 0.35, 0.370])
+rates_preTCJA = np.array([0.10, 0.15, 0.25, 0.28, 0.33, 0.35, 0.396])
+
+###############################################################################
+# Start of section where rates need to be actualized every year.
+###############################################################################
+# Single [0] and married filing jointly [1].
+
+# These are 2025 current.
+taxBrackets_OBBBA = np.array(
+    [
+        [12400, 50400, 105700, 201775, 256225, 640600, 9999999],
+        [24800, 100800, 211400, 403550, 512450, 768700, 9999999],
+    ]
+)
+
+irmaaBrackets = np.array(
+    [
+        [0, 106000, 133000, 167000, 200000, 500000],
+        [0, 212000, 266000, 334000, 400000, 750000],
+    ]
+)
+
+# Index [0] stores the standard Medicare part B premium.
+# Following values are incremental IRMAA part B monthly fees.
+irmaaFees = 12 * np.array([185.00, 74.00, 111.00, 110.90, 111.00, 37.00])
+
+# Make projection for pre-TCJA using 2017 to current year.
+# taxBrackets_2017 = np.array(
+#    [ [9325, 37950, 91900, 191650, 416700, 418400, 9999999],
+#      [18650, 75900, 153100, 233350, 416700, 470700, 9999999],
+#    ])
+#
+# stdDeduction_2017 = [6350, 12700]
+#
+# For 2025, I used a 30.5% adjustment from 2017, rounded to closest 50.
+#
+# These are speculated.
+taxBrackets_preTCJA = np.array(
+    [
+        [12150, 49550, 119950, 250200, 544000, 546200, 9999999],  # Single
+        [24350, 99100, 199850, 304600, 543950, 614450, 9999999],  # MFJ
+    ]
+)
+
+# These are 2025 current.
+stdDeduction_OBBBA = np.array([16100, 32200])    # Single, MFJ
+# These are speculated (adjusted for inflation to 2026). TODO
+stdDeduction_preTCJA = np.array([8300, 16600])  # Single, MFJ
+
+# These are current (adjusted for inflation) per individual.
+extra65Deduction = np.array([2000, 1600])       # Single, MFJ
+
+# Thresholds setting capital gains brackets 0%, 15%, 20% (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
+
+# Thresholds for 65+ bonus for circumventing tax on social security.
+bonusThreshold = np.array([75000, 150000])
+
+###############################################################################
+# End of section where rates need to be actualized every year.
+###############################################################################
+
+
+def mediVals(yobs, horizons, gamma_n, Nn, Nq):
+    """
+    Return tuple (nm, L, C) of year index when Medicare starts and vectors L, and C
+    defining end points of constant piecewise linear functions representing IRMAA fees.
+    """
+    thisyear = date.today().year
+    assert Nq == len(irmaaFees), f"Inconsistent value of Nq: {Nq}."
+    assert Nq == len(irmaaBrackets[0]), "Inconsistent IRMAA brackets array."
+    Ni = len(yobs)
+    # What index year will Medicare start? 65 - age.
+    nm = 65 - (thisyear - yobs)
+    nm = np.min(nm)
+    # Has it already started?
+    nm = max(0, nm)
+    Nmed = Nn - nm
+
+    L = np.zeros((Nmed, Nq-1))
+    C = np.zeros((Nmed, Nq))
+
+    # Year starts at offset nm in the plan.
+    for nn in range(Nmed):
+        imed = 0
+        n = nm + nn
+        if thisyear + n - yobs[0] >= 65 and n < horizons[0]:
+            imed += 1
+        if Ni == 2 and thisyear + n - yobs[1] >= 65 and n < horizons[1]:
+            imed += 1
+        if imed:
+            status = 0 if Ni == 1 else 1 if n < horizons[0] and n < horizons[1] else 0
+            L[nn] = gamma_n[n] * irmaaBrackets[status][1:]
+            C[nn] = imed * gamma_n[n] * irmaaFees
+        else:
+            raise RuntimeError("mediVals: This should never happen.")
+
+    return nm, L, C
+
+
+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 status and 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.
+    """
+    thisyear = date.today().year
+    Ni = len(yobs)
+    costs = np.zeros(Nn)
+    for n in range(Nn):
+        status = 0 if Ni == 1 else 1 if n < horizons[0] and n < horizons[1] else 0
+        for i in range(Ni):
+            if thisyear + n - yobs[i] >= 65 and n < horizons[i]:
+                # Start with the (inflation-adjusted) basic Medicare part B premium.
+                costs[n] += gamma_n[n] * irmaaFees[0]
+                if n < 2:
+                    mymagi = prevmagi[n]
+                else:
+                    mymagi = magi[n - 2]
+                for q in range(1, 6):
+                    if mymagi > gamma_n[n] * irmaaBrackets[status][q]:
+                        costs[n] += gamma_n[n] * irmaaFees[q]
+
+    return costs
+
+
+def taxParams(yobs, i_d, n_d, N_n, gamma_n, MAGI_n, yOBBBA=2099):
+    """
+    Input is year of birth, index of shortest-lived individual,
+    lifespan of shortest-lived individual, total number of years
+    in the plan, and the year that preTCJA rates might come back.
+
+    It returns 3 time series:
+    1) Standard deductions at year n (sigma_n).
+    2) Tax rate in year n (theta_tn)
+    3) Delta from top to bottom of tax brackets (Delta_tn)
+    This is pure speculation on future values.
+    Returned values are not indexed for inflation.
+    """
+    # Compute the deltas in-place between brackets, starting from the end.
+    deltaBrackets_OBBBA = np.array(taxBrackets_OBBBA)
+    deltaBrackets_preTCJA = np.array(taxBrackets_preTCJA)
+    for t in range(6, 0, -1):
+        for i in range(2):
+            deltaBrackets_OBBBA[i, t] -= deltaBrackets_OBBBA[i, t - 1]
+            deltaBrackets_preTCJA[i, t] -= deltaBrackets_preTCJA[i, t - 1]
+
+    # Prepare the 3 arrays to return - use transpose for easy slicing.
+    sigmaBar = np.zeros((N_n))
+    Delta = np.zeros((N_n, 7))
+    theta = np.zeros((N_n, 7))
+
+    filingStatus = len(yobs) - 1
+    souls = list(range(len(yobs)))
+    thisyear = date.today().year
+
+    for n in range(N_n):
+        # First check if shortest-lived individual is still with us.
+        if n == n_d:
+            souls.remove(i_d)
+            filingStatus -= 1
+
+        if thisyear + n < yOBBBA:
+            sigmaBar[n] = stdDeduction_OBBBA[filingStatus] * gamma_n[n]
+            Delta[n, :] = deltaBrackets_OBBBA[filingStatus, :]
+        else:
+            sigmaBar[n] = stdDeduction_preTCJA[filingStatus] * gamma_n[n]
+            Delta[n, :] = deltaBrackets_preTCJA[filingStatus, :]
+
+        # Add 65+ additional exemption(s) and "bonus" phasing out.
+        for i in souls:
+            if thisyear + n - yobs[i] >= 65:
+                sigmaBar[n] += extra65Deduction[filingStatus] * gamma_n[n]
+                if thisyear + n <= 2028:
+                    sigmaBar[n] += 6000 * max(0, 1 - 0.06*max(0, MAGI_n[n] - bonusThreshold[filingStatus]))
+
+        # Fill in future tax rates for year n.
+        if thisyear + n < yOBBBA:
+            theta[n, :] = rates_OBBBA[:]
+        else:
+            theta[n, :] = rates_preTCJA[:]
+
+    Delta = Delta.transpose()
+    theta = theta.transpose()
+
+    # Return series unadjusted for inflation, except for sigmaBar, in STD order.
+    return sigmaBar, theta, Delta
+
+
+def taxBrackets(N_i, n_d, N_n, yOBBBA=2099):
+    """
+    Return dictionary containing future tax brackets
+    unadjusted for inflation for plotting.
+    """
+    if not (0 < N_i <= 2):
+        raise ValueError(f"Cannot process {N_i} individuals.")
+
+    n_d = min(n_d, N_n)
+    status = N_i - 1
+
+    # Number of years left in OBBBA from this year.
+    thisyear = date.today().year
+    if yOBBBA < thisyear:
+        raise ValueError(f"Expiration year {yOBBBA} cannot be in the past.")
+
+    ytc = yOBBBA - thisyear
+
+    data = {}
+    for t in range(len(taxBracketNames) - 1):
+        array = np.zeros(N_n)
+        for n in range(N_n):
+            stat = status if n < n_d else 0
+            array[n] = taxBrackets_OBBBA[stat][t] if n < ytc else taxBrackets_preTCJA[stat][t]
+
+        data[taxBracketNames[t]] = array
+
+    return data
+
+
+def rho_in(yobs, N_n):
+    """
+    Return Required Minimum Distribution fractions for each individual.
+    This implementation does not support spouses with more than
+    10-year difference.
+    It starts at age 73 until it goes to 75 in 2033.
+    """
+    # Notice that table starts at age 72.
+    rmdTable = [
+        27.4,
+        26.5,
+        25.5,
+        24.6,
+        23.7,
+        22.9,
+        22.0,
+        21.1,
+        20.2,
+        19.4,
+        18.5,
+        17.7,
+        16.8,
+        16.0,
+        15.2,
+        14.4,
+        13.7,
+        12.9,
+        12.2,
+        11.5,
+        10.8,
+        10.1,
+        9.5,
+        8.9,
+        8.4,
+        7.8,
+        7.3,
+        6.8,
+        6.4,
+        6.0,
+        5.6,
+        5.2,
+        4.9,
+        4.6,
+    ]
+
+    N_i = len(yobs)
+    if N_i == 2 and abs(yobs[0] - yobs[1]) > 10:
+        raise RuntimeError("RMD: Unsupported age difference of more than 10 years.")
+
+    rho = np.zeros((N_i, N_n))
+    thisyear = date.today().year
+    for i in range(N_i):
+        agenow = thisyear - yobs[i]
+        # Account for increase of RMD age between 2023 and 2032.
+        yrmd = 70 if yobs[i] < 1949 else 72 if 1949 <= yobs[i] <= 1950 else 73 if 1951 <= yobs[i] <= 1959 else 75
+        for n in range(N_n):
+            yage = agenow + n
+
+            if yage < yrmd:
+                pass  # rho[i][n] = 0
+            else:
+                rho[i][n] = 1.0 / rmdTable[yage - 72]
+
+    return rho

owlplanner/timelists.py

@@ -54,7 +54,7 @@ def read(finput, inames, horizons, mylog):
     else:
         # Read all worksheets in memory but only process those with proper names.
         try:
-            dfDict = pd.read_excel(finput, sheet_name=None)
+            dfDict = pd.read_excel(finput, sheet_name=None, usecols=_timeHorizonItems)
         except Exception as e:
             raise Exception(f"Could not read file {finput}: {e}.") from e
         streamName = f"file '{finput}'"

owlplanner/version.py

@@ -1 +1 @@
-__version__ = "2025.08.01"
+__version__ = "2025.11.02"

{owlplanner-2025.8.1.dist-info → owlplanner-2025.11.2.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: owlplanner
-Version: 2025.8.1
+Version: 2025.11.2
 Summary: Owl: Retirement planner with great wisdom
 Project-URL: HomePage, https://github.com/mdlacasse/owl
 Project-URL: Repository, https://github.com/mdlacasse/owl
@@ -709,7 +709,7 @@ Description-Content-Type: text/markdown
 
 ## A retirement exploration tool based on linear programming
 
-<img align=right src="https://raw.github.com/mdlacasse/Owl/main/docs/images/owl.png" width="250">
+<img align=right src="https://github.com/mdlacasse/Owl/blob/main/docs/images/owl.png?raw=true" width="250">
 
 -------------------------------------------------------------------------------------
 
@@ -739,12 +739,12 @@ Strictly speaking, it is not a planning tool, but more an environment for explor
 It provides different realizations of a financial strategy through the rigorous
 mathematical optimization of relevant decision variables. Two major objective goals can be set: either
 maximize net spending, or after-tax bequest under various constraints.
-Look at *Basic capabilities* below for more detail.
+Look at the *Capabilities* section below for more detail.
 
 One can certainly have a savings plan, but due to the volatility of financial investments,
 it is impossible to have a certain asset earnings plan. This does not mean one cannot make decisions.
 These decisions need to be guided with an understanding of the sensitivity of the parameters.
-This is exactly where this tool fits it. Given your savings capabilities and spending desires,
+This is exactly where this tool fits in. Given your savings capabilities and spending desires,
 it can generate different future realizations of
 your strategy under different market assumptions, helping to better understand your financial situation.
 
@@ -758,7 +758,7 @@ collecting your data, or academic papers that share the results without really s
 the underlying mathematical models.
 The algorithms in Owl rely on the open-source HiGHS linear programming solver. The complete formulation and
 detailed description of the underlying
-mathematical model can be found [here](https://raw.github.com/mdlacasse/Owl/main/docs/owl.pdf).
+mathematical model can be found [here](https://github.com/mdlacasse/Owl/blob/main/docs/owl.pdf).
 
 It is anticipated that most end users will use Owl through the graphical interface
 either at [owlplanner.streamlit.app](https://owlplanner.streamlit.app)
@@ -768,7 +768,7 @@ as described [here](USER_GUIDE.md).
 
 Not every retirement decision strategy can be framed as an easy-to-solve optimization problem.
 In particular, if one is interested in comparing different withdrawal strategies,
-[FI Calc](ficalc.app) is an elegant application that addresses this need.
+[FI Calc](https://ficalc.app) is an elegant application that addresses this need.
 If, however, you also want to optimize spending, bequest, and Roth conversions, with
 an approach also considering Medicare and federal income tax over the next few years,
 then Owl is definitely a tool that can help guide your decisions.
@@ -840,7 +840,9 @@ Tax status covers married filing jointly and single, depending on the number of
 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.
+They can also be optimized explicitly as an option, but this choice can lead to longer calculations
+due to the use of the many additional binary variables required by the formulation.
+Future Medicare and IRMAA values are simple projections of current values with the assumed inflation rates.
 
 ### Limitations
 Owl is work in progress. At the current time:
@@ -851,15 +853,16 @@ These cases are detected and will generate an error message.
 - Social security rule for surviving spouse assumes that benefits were taken at full retirement age.
 - Current version has no optimization of asset allocations between individuals and/or types of savings accounts.
 If there is interest, that could be added in the future.
-- In the current implementation, social securiy is always taxed at 85%.
-- Medicare calculations are done through a self-consistent loop.
-This means that the Medicare premiums are calculated after an initial solution is generated,
+- In the current implementation, social securiy is always taxed at 85%, assuming that your taxable income will be larger than 34 k$ (single) or 44 k$ (married filing jointly).
+- When Medicare calculations are done through a self-consistent loop,
+the Medicare premiums are calculated after an initial solution is generated,
 and then a new solution is re-generated with these premiums as a constraint.
 In some situations, when the income (MAGI) is near an IRMAA bracket, oscillatory solutions can arise.
 While the solutions generated are very close to one another, Owl will pick the smallest solution
-for being conservative.
-- Part D is not included in the IRMAA calculations. Being considerably more significant,
-only Part B is taken into account. 
+for being conservative. While sometimes computationally costly,
+a comparison with a full Medicare optimization should always be performed.
+- Part D is not included in the IRMAA calculations. Only Part B is taken into account, 
+which is considerably more significant.
 - Future tax brackets are pure speculations derived from the little we know now and projected to the next 30 years.
 Your guesses are as good as mine.
 
@@ -886,8 +889,11 @@ assets to support, even with no estate being left.
 - Optimization solver from [HiGHS](https://highs.dev)
 - Streamlit Community Cloud [Streamlit](https://streamlit.io)
 - Contributors: Josh (noimjosh@gmail.com) for Docker image code,
+ kg333 for fixing an error in Docker's instructions,
  Dale Seng (sengsational) for great insights and suggestions,
- Robert E. Anderson (NH-RedAnt) for bug fixes and suggestions, Clark Jefcoat (hubcity) for fruitful interactions.
+ Robert E. Anderson (NH-RedAnt) for bug fixes and suggestions,
+ Clark Jefcoat (hubcity) for fruitful interactions,
+ Benjamin Quinn (blquinn) and Gene Wood (gene1wood) for improvements and bug fixes.
 
 ---------------------------------------------------------------------
 

{owlplanner-2025.8.1.dist-info → owlplanner-2025.11.2.dist-info}/RECORD

@@ -1,14 +1,15 @@
 owlplanner/__init__.py,sha256=hJ2i4m2JpHPAKyQLjYOXpJzeEsgcTcKD-Vhm0AIjjWg,592
 owlplanner/abcapi.py,sha256=rtg7d0UbftinokR9VlB49VUjDjzUq3ONnJbhMXVIrgo,6879
-owlplanner/config.py,sha256=JJOtS6HyqA4qUHUZydSGG_RMWaCfVMRSOAfWbt4evMI,12461
+owlplanner/config.py,sha256=UF2Dy6E9PiX6Ua8B1R0aYCNUoIYmY46up8awf_36B_Q,12615
 owlplanner/mylogging.py,sha256=OVGeDFO7LIZG91R6HMpZBzjno-B8PH8Fo00Jw2Pdgqw,2558
-owlplanner/plan.py,sha256=keKC9-XeQxza9--D7TaQfcZCLkGDy5yVV9D5pN25MHg,115211
+owlplanner/plan.py,sha256=NDdV0Eri76JMpiNPeuMzLYGX-lDDBEbjXd6Qg6k_CIw,115180
 owlplanner/progress.py,sha256=dUUlFmSAKUei36rUj2BINRY10f_YEUo_e23d0es6nrc,530
 owlplanner/rates.py,sha256=9Nmo8AKsyi5PoCUrzhr06phkSlNTv-TXzj5iYFU76AY,14113
-owlplanner/tax2025.py,sha256=2Jb_UbPT6ye-znRjA0nSaF8T8M17QW4MoRPDoW9XJ8s,10833
-owlplanner/timelists.py,sha256=Q4kBt9kKAa5qxsvOe9wfyUtCQVgiwPmJXTwXUPRBBv8,4066
+owlplanner/tax2025.py,sha256=4KYaT6TO6WU7wDjgdRW48lqfwvVCtaXs9tcw1nleKhg,10834
+owlplanner/tax2026.py,sha256=hgCiCJWVzJITk0cA8W-zxl-a0kObijPZ1yXc0F6MAwk,10848
+owlplanner/timelists.py,sha256=UdzH6A_-w4REn4A1po7yndSiy1R8_R-i_C-94re4JYY,4093
 owlplanner/utils.py,sha256=afAjeO6Msf6Rn4jwz_7Ody9rHGWlBR7iQFqe1xzLNQc,2513
-owlplanner/version.py,sha256=Or3KaHd8BXidAsAkScGwQRvtWIF5uufpsnfgNdR-Kpw,28
+owlplanner/version.py,sha256=7KKWNrt_Dn84IwHPr2R5et9VpN8p8GhpeUnuavkZnVA,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 +17,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.8.1.dist-info/METADATA,sha256=9WRoRbNMdk2kxbT4-Coq912VJixT9rlF1Cv48Po4VJw,54044
-owlplanner-2025.8.1.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-owlplanner-2025.8.1.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-owlplanner-2025.8.1.dist-info/RECORD,,
+owlplanner-2025.11.2.dist-info/METADATA,sha256=MIS1cRREb2Fe56Qu8BJ_9tF5YXB3gFL2Ldaufm2k0Ak,54622
+owlplanner-2025.11.2.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+owlplanner-2025.11.2.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+owlplanner-2025.11.2.dist-info/RECORD,,