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

owlplanner/config.py

@@ -37,6 +37,7 @@ def saveConfig(myplan, file, mylog):
         "Status": ["unknown", "single", "married"][myplan.N_i],
         "Names": myplan.inames,
         "Birth year": myplan.yobs.tolist(),
+        "Birth month": myplan.mobs.tolist(),
         "Life expectancy": myplan.expectancy.tolist(),
         "Start date": myplan.startDate,
     }
@@ -55,10 +56,10 @@ def saveConfig(myplan, file, mylog):
 
     # Fixed Income.
     diconf["Fixed Income"] = {
-        "Pension amounts": (myplan.pensionAmounts / 1000).tolist(),
+        "Pension monthly amounts": (myplan.pensionAmounts).tolist(),
         "Pension ages": myplan.pensionAges.tolist(),
         "Pension indexed": myplan.pensionIsIndexed,
-        "Social security amounts": (myplan.ssecAmounts / 1000).tolist(),
+        "Social security PIA amounts": (myplan.ssecAmounts).tolist(),
         "Social security ages": myplan.ssecAges.tolist(),
     }
 
@@ -181,11 +182,13 @@ def readConfig(file, *, verbose=True, logstreams=None, readContributions=True):
     inames = diconf["Basic Info"]["Names"]
     # status = diconf['Basic Info']['Status']
     yobs = diconf["Basic Info"]["Birth year"]
-    expectancy = diconf["Basic Info"]["Life expectancy"]
     icount = len(yobs)
+    # Default to January if no month entry found.
+    mobs = diconf["Basic Info"].get("Birth month", [1]*icount)
+    expectancy = diconf["Basic Info"]["Life expectancy"]
     s = ["", "s"][icount - 1]
     mylog.vprint(f"Plan for {icount} individual{s}: {inames}.")
-    p = plan.Plan(inames, yobs, expectancy, name, verbose=True, logstreams=logstreams)
+    p = plan.Plan(inames, yobs, mobs, expectancy, name, verbose=True, logstreams=logstreams)
     p._description = diconf.get("Description", "")
 
     # Assets.
@@ -217,11 +220,11 @@ def readConfig(file, *, verbose=True, logstreams=None, readContributions=True):
             mylog.vprint(f"Ignoring to read contributions file {timeListsFileName}.")
 
     # Fixed Income.
-    ssecAmounts = np.array(diconf["Fixed Income"]["Social security amounts"], dtype=np.float32)
-    ssecAges = np.array(diconf["Fixed Income"]["Social security ages"], dtype=np.int32)
+    ssecAmounts = np.array(diconf["Fixed Income"].get("Social security PIA amounts", [0]*icount), dtype=np.int32)
+    ssecAges = np.array(diconf["Fixed Income"]["Social security ages"])
     p.setSocialSecurity(ssecAmounts, ssecAges)
-    pensionAmounts = np.array(diconf["Fixed Income"]["Pension amounts"], dtype=np.float32)
-    pensionAges = np.array(diconf["Fixed Income"]["Pension ages"], dtype=np.int32)
+    pensionAmounts = np.array(diconf["Fixed Income"].get("Pension monthly amounts", [0]*icount), dtype=np.float32)
+    pensionAges = np.array(diconf["Fixed Income"]["Pension ages"])
     pensionIsIndexed = diconf["Fixed Income"]["Pension indexed"]
     p.setPension(pensionAmounts, pensionAges, pensionIsIndexed)
 

owlplanner/plan.py

@@ -29,6 +29,7 @@ from . import abcapi as abc
 from . import rates
 from . import config
 from . import timelists
+from . import socialsecurity as socsec
 from . import mylogging as log
 from . import progress
 from .plotting.factory import PlotFactory
@@ -212,7 +213,7 @@ class Plan(object):
     This is the main class of the Owl Project.
     """
 
-    def __init__(self, inames, yobs, expectancy, name, *, verbose=False, logstreams=None):
+    def __init__(self, inames, yobs, mobs, expectancy, name, *, verbose=False, logstreams=None):
         """
         Constructor requires three lists: the first
         one contains the name(s) of the individual(s),
@@ -251,6 +252,10 @@ class Plan(object):
         self.N_i = len(yobs)
         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):
@@ -264,6 +269,7 @@ class Plan(object):
         self.yOBBBA = 2032
         self.inames = inames
         self.yobs = np.array(yobs, dtype=np.int32)
+        self.mobs = np.array(mobs, dtype=np.int32)
         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.
@@ -297,10 +303,10 @@ class Plan(object):
         # Default to zero pension and social security.
         self.pi_in = np.zeros((self.N_i, self.N_n))
         self.zeta_in = np.zeros((self.N_i, self.N_n))
-        self.pensionAmounts = np.zeros(self.N_i)
+        self.pensionAmounts = np.zeros(self.N_i, dtype=np.int32)
         self.pensionAges = 65 * np.ones(self.N_i, dtype=np.int32)
         self.pensionIsIndexed = [False] * self.N_i
-        self.ssecAmounts = np.zeros(self.N_i)
+        self.ssecAmounts = np.zeros(self.N_i, dtype=np.int32)
         self.ssecAges = 67 * np.ones(self.N_i, dtype=np.int32)
 
         # Parameters from timeLists initialized to zero.
@@ -519,10 +525,10 @@ class Plan(object):
         self.nu = nu
         self.caseStatus = "modified"
 
-    def setPension(self, amounts, ages, indexed=None, units="k"):
+    def setPension(self, amounts, ages, indexed=None):
         """
         Set value of pension for each individual and commencement age.
-        Units are in $k, unless specified otherwise: 'k', 'M', or '1'.
+        Units are in $.
         """
         if len(amounts) != self.N_i:
             raise ValueError(f"Amounts must have {self.N_i} entries.")
@@ -531,10 +537,7 @@ class Plan(object):
         if indexed is None:
             indexed = [False] * self.N_i
 
-        fac = u.getUnits(units)
-        amounts = u.rescale(amounts, fac)
-
-        self.mylog.vprint("Setting pension of", [u.d(amounts[i]) for i in range(self.N_i)],
+        self.mylog.vprint("Setting monthly pension of", [u.d(amounts[i]) for i in range(self.N_i)],
                           "at age(s)", [int(ages[i]) for i in range(self.N_i)])
 
         thisyear = date.today().year
@@ -542,47 +545,88 @@ class Plan(object):
         self.pi_in = np.zeros((self.N_i, self.N_n))
         for i in range(self.N_i):
             if amounts[i] != 0:
-                ns = max(0, ages[i] - thisyear + self.yobs[i])
+                # Check if claim age added to birth month falls next year.
+                realage = ages[i] + (self.mobs[i] - 1)/12
+                iage = int(realage)
+                fraction = 1 - (realage % 1.)
+                realns = iage - thisyear + self.yobs[i]
+                ns = max(0, realns)
                 nd = self.horizons[i]
                 self.pi_in[i, ns:nd] = amounts[i]
+                # Reduce starting year due to birth month. If realns < 0, this has happened already.
+                if realns >= 0:
+                    self.pi_in[i, ns] *= fraction
+
+        # Convert all to annual numbers.
+        self.pi_in *= 12
 
-        self.pensionAmounts = np.array(amounts)
-        self.pensionAges = np.array(ages, dtype=np.int32)
+        self.pensionAmounts = np.array(amounts, dtype=np.int32)
+        self.pensionAges = np.array(ages)
         self.pensionIsIndexed = indexed
         self.caseStatus = "modified"
         self._adjustedParameters = False
 
-    def setSocialSecurity(self, amounts, ages, units="k"):
+    def setSocialSecurity(self, pias, ages):
         """
-        Set value of social security for each individual and commencement age.
-        Units are in $k, unless specified otherwise: 'k', 'M', or '1'.
+        Set value of social security for each individual and claiming age.
         """
-        if len(amounts) != self.N_i:
-            raise ValueError(f"Amounts must have {self.N_i} entries.")
+        if len(pias) != self.N_i:
+            raise ValueError(f"Principal Insurance Amount must have {self.N_i} entries.")
         if len(ages) != self.N_i:
             raise ValueError(f"Ages must have {self.N_i} entries.")
 
-        fac = u.getUnits(units)
-        amounts = u.rescale(amounts, fac)
+        # Just make sure we are dealing with arrays if lists were passed.
+        pias = np.array(pias, dtype=np.int32)
+        ages = np.array(ages)
 
+        fras = socsec.getFRAs(self.yobs)
+        spousalBenefits = socsec.getSpousalBenefits(pias)
+
+        self.mylog.vprint(
+            "Social security monthly benefits set to", [u.d(pias[i]) for i in range(self.N_i)],
+            "at FRAs(s)", [fras[i] for i in range(self.N_i)],
+        )
         self.mylog.vprint(
-            "Setting social security benefits of", [u.d(amounts[i]) for i in range(self.N_i)],
-            "at age(s)", [int(ages[i]) for i in range(self.N_i)],
+            "Benefits requested to start at age(s)", [ages[i] for i in range(self.N_i)],
         )
 
         thisyear = date.today().year
         self.zeta_in = np.zeros((self.N_i, self.N_n))
         for i in range(self.N_i):
-            ns = max(0, ages[i] - thisyear + self.yobs[i])
+            # 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]
+            ns = max(0, realns)
             nd = self.horizons[i]
-            self.zeta_in[i, ns:nd] = amounts[i]
-
-        if self.N_i == 2:
-            # Approximate calculation for spousal benefit (only valid at FRA, and if of similar ages).
-            self.zeta_in[self.i_s, self.n_d :] = max(amounts[self.i_s], 0.5*amounts[self.i_d])
-
-        self.ssecAmounts = np.array(amounts)
-        self.ssecAges = np.array(ages, dtype=np.int32)
+            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.)
+            # Increase/decrease PIA due to claiming age.
+            self.zeta_in[i, :] *= socsec.getSelfFactor(fras[i], ages[i])
+
+            # Add spousal benefits if applicable.
+            if self.N_i == 2 and spousalBenefits[i] > 0:
+                # The latest of the two spouses to claim.
+                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)
+                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.)
+
+        # Switch survivor to spousal survivor benefits.
+        # Assumes both deceased and survivor already have claimed last year before passing (at n_d - 1).
+        if self.N_i == 2 and self.zeta_in[self.i_d, self.n_d - 1] > self.zeta_in[self.i_s, self.n_d - 1]:
+            self.zeta_in[self.i_s, self.n_d : self.horizons[self.i_s]] = self.zeta_in[self.i_d, self.n_d - 1]
+
+        # Convert all to annual numbers.
+        self.zeta_in *= 12
+
+        self.ssecAmounts = pias
+        self.ssecAges = ages
         self.caseStatus = "modified"
         self._adjustedParameters = False
 
@@ -1116,25 +1160,26 @@ class Plan(object):
             h = self.horizons[i]
             for n in range(h):
                 rhs = 0
-                # To add compounded gains to original amount.
+                # To add compounded gains to cumulative amounts. Always keep cgains >= 1.
                 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.
+                    if nn >= 0:   # Past of future is now or in the future: use variables or parameters.
                         Tau1 = 1 + np.sum(self.alpha_ijkn[i, 2, :, nn] * self.tau_kn[:, nn], axis=0)
-                        cgains *= Tau1
+                        # Ignore market downs.
+                        cgains *= max(1, 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.
+                        # If a contribution, it has only penalty on gains, not on deposited amount.
                         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]
+                        # Past years are stored at the end of contributions and conversions arrays.
+                        # Use negative index to access tail of array.
+                        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)
 
@@ -1675,7 +1720,7 @@ class Plan(object):
             self.prevMAGI = self.optionsUnits * np.array(magi)
 
         lambdha = myoptions.get("spendingSlack", 0)
-        if lambdha < 0 or lambdha > 50:
+        if not (0 <= lambdha <= 50):
             raise ValueError(f"Slack value out of range {lambdha}.")
         self.lambdha = lambdha / 100
 

owlplanner/socialsecurity.py

@@ -0,0 +1,89 @@
+"""
+
+Owl/socialsecurity
+--------
+
+A retirement planner using linear programming optimization.
+
+This file contains the rules related to social security.
+
+Copyright © 2025 - Martin-D. Lacasse
+
+Disclaimers: This code is for educational purposes only and does not constitute financial advice.
+
+"""
+
+import numpy as np
+
+
+def getFRAs(yobs):
+    """
+    Return full retirement age based on birth year.
+    Returns an array of fractional age.
+    """
+    fras = np.zeros(len(yobs))
+
+    for i in range(len(yobs)):
+        if yobs[i] >= 1960:
+            fras[i] = 67
+        else:
+            mo = max(0, 2*(yobs[i] - 1954))
+            fras[i] = 66 + mo/12
+
+    return fras
+
+
+def getSpousalBenefits(pias):
+    """
+    Compute spousal benefit. Returns an array.
+    """
+    icount = len(pias)
+    benefits = np.zeros(icount)
+    if icount == 1:
+        return benefits
+    elif icount == 2:
+        for i in range(2):
+            j = (i+1) % 2
+            benefits[i] = max(0, 0.5*pias[j] - pias[i])
+    else:
+        raise ValueError(f"PIAs array cannot have {icount} entries.")
+
+    return benefits
+
+
+def getSelfFactor(fra, age):
+    """
+    Return factor to multiply PIA given the age when SS starts.
+    Year of FRA and age can be fractional.
+    """
+    if age < 62 or age > 70:
+        raise ValueError(f"Age {age} out of range.")
+
+    diff = fra - age
+    if diff <= 0:
+        return 1. - .08 * diff
+    elif diff <= 3:
+        # Reduction of 20% over first 36 months.
+        return 1. - 0.06666667 * diff
+    else:
+        # Then 5% per tranche of 12 months.
+        return .8 - 0.05 * (diff - 3)
+
+
+def getSpousalFactor(fra, age):
+    """
+    Return factor to multiply spousal benefit given the age when benefit starts.
+    Year of FRA and age can be fractional.
+    """
+    if age < 62:
+        raise ValueError(f"Age {age} out of range.")
+
+    diff = fra - age
+    if diff <= 0:
+        return 1.
+    elif diff <= 3:
+        # Reduction of 25% over first 36 months.
+        return 1. - 0.08333333 * diff
+    else:
+        # Then 5% per tranche of 12 months.
+        return .75 - 0.05 * (diff - 3)

owlplanner/version.py

@@ -1 +1 @@
-__version__ = "2025.11.09"
+__version__ = "2025.12.05"

{owlplanner-2025.11.9.dist-info → owlplanner-2025.12.5.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: owlplanner
-Version: 2025.11.9
+Version: 2025.12.5
 Summary: Owl - Optimal Wealth Lab: Retirement planner with great wisdom
 Project-URL: HomePage, https://github.com/mdlacasse/owl
 Project-URL: Repository, https://github.com/mdlacasse/owl
@@ -722,16 +722,16 @@ Users can select varying return rates to perform historical back testing,
 stochastic rates for performing Monte Carlo analyses,
 or fixed rates either derived from historical averages, or set by the user.
 
-There are a few ways to run Owl:
+There are three ways to run Owl:
 
-- Run Owl directly on the Streamlit Community Server at
+- **Streamlit Hub:** Run Owl remotely as hosted on the Streamlit Community Server at
 [owlplanner.streamlit.app](https://owlplanner.streamlit.app).
 
-- Run locally on your computer using a Docker image.
-Follow these [instructions](docker/README.md) for this option.
+- **Docker Container:** Run Owl locally on your computer using a Docker image.
+Follow these [instructions](docker/README.md) for using this option.
 
-- Run locally on your computer using Python code and libraries.
-Follow these [instructions](INSTALL.md) to install Owl from the source code and run it on your computer.
+- **Self-hosting:** Run Owl locally on your computer using Python code and libraries.
+Follow these [instructions](INSTALL.md) to install from the source code and self-host on your own computer.
 
 -------------------------------------------------------------------------------------
 ## Overview
@@ -760,7 +760,7 @@ There are and were
 good retirement optimizers in the recent past, but the vast majority of them are either proprietary platforms
 collecting your data, or academic papers that share the results without really sharing the details of
 the underlying mathematical models.
-The algorithms in Owl rely on the open-source HiGHS linear programming solver and but they have also been ported to
+The algorithms in Owl rely on the open-source HiGHS linear programming solver but they have also been ported and tested on
 other platforms such as Mosek and COIN-OR. The complete formulation and
 detailed description of the underlying
 mathematical model can be found [here](https://github.com/mdlacasse/Owl/blob/main/docs/owl.pdf).
@@ -849,13 +849,16 @@ They can also be optimized explicitly as an option, but this choice can lead to
 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.
 
+Owl has a basic social security calculator that determines the actual benefits based on the individual's
+primary insurance amount (PIA), full retirement age (FRA), and claiming age. Both
+spousal's benefits and survivor's benefits are calculated for non-complex cases.
+
 ### Limitations
 Owl is work in progress. At the current time:
 - Only the US federal income tax is considered (and minimized through the optimization algorithm).
 Head of household filing status has not been added but can easily be.
 - Required minimum distributions are calculated, but tables for spouses more than 10 years apart are not included.
 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%, assuming that your taxable income will be larger than 34 k$ (single) or 44 k$ (married filing jointly).

{owlplanner-2025.11.9.dist-info → owlplanner-2025.12.5.dist-info}/RECORD

@@ -1,15 +1,16 @@
 owlplanner/__init__.py,sha256=hJ2i4m2JpHPAKyQLjYOXpJzeEsgcTcKD-Vhm0AIjjWg,592
 owlplanner/abcapi.py,sha256=rtg7d0UbftinokR9VlB49VUjDjzUq3ONnJbhMXVIrgo,6879
-owlplanner/config.py,sha256=UF2Dy6E9PiX6Ua8B1R0aYCNUoIYmY46up8awf_36B_Q,12615
+owlplanner/config.py,sha256=bEO5-QAy_rXjzTIJFEIFSfFSdELbJUDp4mRyU2wRBvA,12790
 owlplanner/mylogging.py,sha256=OVGeDFO7LIZG91R6HMpZBzjno-B8PH8Fo00Jw2Pdgqw,2558
-owlplanner/plan.py,sha256=tqybE4JX4tT_znZnCoAqQXQvcUgLmi5FNsCLghHnNus,115177
+owlplanner/plan.py,sha256=FCtiG60AfdvgcUQgnQ4N2KlFXl6T0xC1pdyj9-GGwgY,117597
 owlplanner/progress.py,sha256=dUUlFmSAKUei36rUj2BINRY10f_YEUo_e23d0es6nrc,530
 owlplanner/rates.py,sha256=9Nmo8AKsyi5PoCUrzhr06phkSlNTv-TXzj5iYFU76AY,14113
+owlplanner/socialsecurity.py,sha256=ODxJ7QqHomzKVVlCPMNa-H8ywOcEk8ktyyDJ2MDrMxo,2195
 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=JtEr8miZ9cqjineEUY23Nf4mp48btI1zykUbQYetUWk,28
+owlplanner/version.py,sha256=tIESH6G3DgWFtRScfgtDIL48ULuRpQ0KcMjAFDHJ1D8,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
@@ -17,7 +18,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.11.9.dist-info/METADATA,sha256=d7A8kkgm07tVhzplea9qbH5mFdZu6ZEok_Uhr3RsVq8,54973
-owlplanner-2025.11.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-owlplanner-2025.11.9.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-owlplanner-2025.11.9.dist-info/RECORD,,
+owlplanner-2025.12.5.dist-info/METADATA,sha256=S8mJrqS-nw6cS91G6jOtK6kkN-xGvDKnMEwpBRv1LPs,55234
+owlplanner-2025.12.5.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+owlplanner-2025.12.5.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+owlplanner-2025.12.5.dist-info/RECORD,,

{owlplanner-2025.11.9.dist-info → owlplanner-2025.12.5.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any