owlplanner 2025.6.21__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)
@@ -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.
@@ -1154,20 +1143,18 @@ class Plan(object):
                 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 in the past:
+                    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 only an contribution - without conversion.
+                        # 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]
-                    else:       # Past of future is in the future: use variables and parameters.
-                        ksum2 = np.sum(self.alpha_ijkn[i, 2, :, nn] * self.tau_kn[:, nn], axis=0)
-                        Tau1 = 1 + ksum2
-                        cgains *= Tau1
-                        row.addElem(_q2(self.C["x"], i, nn, self.N_i, self.N_n), -cgains)
-                        # If only a contribution - without conversion.
-                        # rhs += (cgains - 1) * self.kappa_ijn[i, 2, nn]
-                        rhs += cgains * self.kappa_ijn[i, 2, nn]
 
                 self.A.addRow(row, rhs, np.inf)
 
@@ -1323,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]
@@ -1578,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",
@@ -1637,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.")
 
@@ -1710,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))
@@ -1806,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)
@@ -1876,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.
@@ -1950,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
@@ -1976,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, :Nn])
-                + 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.
@@ -2137,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)}"
@@ -2417,8 +2450,8 @@ class Plan(object):
         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:
@@ -2490,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")
@@ -2504,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,
         }

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

@@ -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...")
@@ -93,6 +93,7 @@ def _condition(dfDict, inames, horizons, mylog):
         # 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(-5, horizons[i]):
             year = thisyear + n

owlplanner/version.py

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: owlplanner
-Version: 2025.6.21
+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

{owlplanner-2025.6.21.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=VVHyKJiooLXXVLiRFJcauZ3oOYU62CCBe4DlpA08P38,109765
+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=95rKYknGMi1bonDVIc3xNmiwG0zTSejKyQy_uWCLSiA,4024
+owlplanner/tax2025.py,sha256=3uDJfKiSRFUp5WDcouAnTEQqEY7LnDKxqxDSKiTsOSQ,8927
+owlplanner/timelists.py,sha256=4pRumdoFlEmmh07wpGhDqauHl2doLG5JcRkvi41fvR4,4065
 owlplanner/utils.py,sha256=6Ky8ZKfNE9x--3znsZ8VZaT2PptDinszRxWsOCPanu8,2512
-owlplanner/version.py,sha256=Q6lAE5sS9Y-tuy3jNnv43HcB70y7l1kmDPNzx4CR9tc,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.21.dist-info/METADATA,sha256=bZI1gHxPSbxJvJP2DuSqiB6Y33x4tdiVgHlKK73wGD4,54045
-owlplanner-2025.6.21.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-owlplanner-2025.6.21.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-owlplanner-2025.6.21.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,,