owlplanner 2025.2.9__py3-none-any.whl → 2025.2.11__py3-none-any.whl

owlplanner/abcapi.py

@@ -43,7 +43,7 @@ class Row(object):
         """
         Add an element at index ``ind`` of value ``val`` to the row.
         """
-        assert 0 <= ind and ind < self.nvars, "Index %d out of range." % ind
+        assert 0 <= ind and ind < self.nvars, f"Index {ind} out of range."
         self.ind.append(ind)
         self.val.append(val)
 
@@ -154,7 +154,7 @@ class Bounds(object):
         self.integrality = []
 
     def setBinary(self, ii):
-        assert 0 <= ii and ii < self.nvars, "Index %d out of range." % ii
+        assert 0 <= ii and ii < self.nvars, f"Index {ii} out of range."
         self.ind.append(ii)
         self.lb.append(0)
         self.ub.append(1)
@@ -162,21 +162,21 @@ class Bounds(object):
         self.integrality.append(ii)
 
     def set0_Ub(self, ii, ub):
-        assert 0 <= ii and ii < self.nvars, "Index %d out of range." % ii
+        assert 0 <= ii and ii < self.nvars, f"Index {ii} out of range."
         self.ind.append(ii)
         self.lb.append(0)
         self.ub.append(ub)
         self.key.append("ra")
 
     def setLb_Inf(self, ii, lb):
-        assert 0 <= ii and ii < self.nvars, "Index %d out of range." % ii
+        assert 0 <= ii and ii < self.nvars, f"Index {ii} out of range."
         self.ind.append(ii)
         self.lb.append(lb)
         self.ub.append(np.inf)
         self.key.append("lo")
 
     def setRange(self, ii, lb, ub):
-        assert 0 <= ii and ii < self.nvars, "Index %d out of range." % ii
+        assert 0 <= ii and ii < self.nvars, f"Index {ii} out of range."
         self.ind.append(ii)
         self.lb.append(lb)
         self.ub.append(ub)
@@ -223,7 +223,7 @@ class Objective(object):
         self.val = []
 
     def setElem(self, ind, val):
-        assert 0 <= ind and ind < self.nvars, "Index %d out of range." % ind
+        assert 0 <= ind and ind < self.nvars, f"Index {ind} out of range."
         self.ind.append(ind)
         self.val.append(val)
 

owlplanner/config.py

@@ -42,7 +42,7 @@ def saveConfig(plan, file, mylog):
     diconf["Assets"] = {}
     for j in range(plan.N_j):
         amounts = plan.beta_ij[:, j] / 1000
-        diconf["Assets"]["%s savings balances" % accountTypes[j]] = amounts.tolist()
+        diconf["Assets"][f"{accountTypes[j]} savings balances"] = amounts.tolist()
     if plan.N_i == 2:
         diconf["Assets"]["Beneficiary fractions"] = plan.phi_j.tolist()
         diconf["Assets"]["Spousal surplus deposit fraction"] = plan.eta
@@ -113,23 +113,23 @@ def saveConfig(plan, file, mylog):
             filename = filename + ".toml"
         if not filename.startswith("case_"):
             filename = "case_" + filename
-        mylog.vprint("Saving plan case file as '%s'." % filename)
+        mylog.vprint(f"Saving plan case file as '{filename}'.")
 
         try:
             with open(filename, "w") as casefile:
                 toml.dump(diconf, casefile, encoder=toml.TomlNumpyEncoder())
         except Exception as e:
-            raise RuntimeError("Failed to save case file %s: %s" % (filename, e))
+            raise RuntimeError(f"Failed to save case file {filename}: {e}")
     elif isinstance(file, StringIO):
         try:
             string = toml.dumps(diconf, encoder=toml.TomlNumpyEncoder())
             file.write(string)
         except Exception as e:
-            raise RuntimeError("Failed to save case to StringIO: %s", e)
+            raise RuntimeError(f"Failed to save case to StringIO: {e}")
     elif file is None:
         pass
     else:
-        raise ValueError("Argument %s has unknown type" % type(file))
+        raise ValueError(f"Argument {type(file)} has unknown type")
 
     return diconf
 
@@ -151,27 +151,27 @@ def readConfig(file, *, verbose=True, logstreams=None, readContributions=True):
         if not filename.endswith(".toml"):
             filename = filename + ".toml"
 
-        mylog.vprint("Reading plan from case file '%s'." % filename)
+        mylog.vprint(f"Reading plan from case file '{filename}'.")
 
         try:
             with open(filename, "r") as f:
                 diconf = toml.load(f)
         except Exception as e:
-            raise FileNotFoundError("File %s not found: %s" % (filename, e))
+            raise FileNotFoundError(f"File {filename} not found: {e}")
     elif isinstance(file, BytesIO):
         try:
             string = file.getvalue().decode("utf-8")
             diconf = toml.loads(string)
         except Exception as e:
-            raise RuntimeError("Cannot read from BytesIO: %s" % e)
+            raise RuntimeError(f"Cannot read from BytesIO: {e}")
     elif isinstance(file, StringIO):
         try:
             string = file.getvalue()
             diconf = toml.loads(string)
         except Exception as e:
-            raise RuntimeError("Cannot read from StringIO: %s" % e)
+            raise RuntimeError(f"Cannot read from StringIO: {e}")
     else:
-        raise ValueError("%s not a valid type" % type(file))
+        raise ValueError(f"Type {type(file)} not a valid type")
 
     # Basic Info.
     name = diconf["Plan Name"]
@@ -181,14 +181,14 @@ def readConfig(file, *, verbose=True, logstreams=None, readContributions=True):
     expectancy = diconf["Basic Info"]["Life expectancy"]
     startDate = diconf["Basic Info"]["Start date"]
     icount = len(yobs)
-
-    mylog.vprint("Plan for %d individual%s: %s." % (icount, ["", "s"][icount - 1], inames))
+    s = ["", "s"][icount - 1]
+    mylog.vprint(f"Plan for {icount} individual{s}: {inames}.")
     p = plan.Plan(inames, yobs, expectancy, name, startDate=startDate, verbose=True, logstreams=logstreams)
 
     # Assets.
     balances = {}
     for acc in accountTypes:
-        balances[acc] = diconf["Assets"]["%s savings balances" % acc]
+        balances[acc] = diconf["Assets"][f"{acc} savings balances"]
     p.setAccountBalances(
         taxable=balances["taxable"], taxDeferred=balances["tax-deferred"], taxFree=balances["tax-free"]
     )
@@ -207,11 +207,11 @@ def readConfig(file, *, verbose=True, logstreams=None, readContributions=True):
             elif dirname != "" and os.path.exists(dirname + "/" + timeListsFileName):
                 myfile = dirname + "/" + timeListsFileName
             else:
-                raise FileNotFoundError("File '%s' not found." % timeListsFileName)
+                raise FileNotFoundError(f"File '{timeListsFileName}' not found.")
             p.readContributions(myfile)
         else:
             p.timeListsFileName = timeListsFileName
-            mylog.vprint("Ignoring to read contributions file %s." % timeListsFileName)
+            mylog.vprint(f"Ignoring to read contributions file {timeListsFileName}.")
 
     # Fixed Income.
     ssecAmounts = np.array(diconf["Fixed Income"]["Social security amounts"], dtype=np.float32)
@@ -272,7 +272,7 @@ def readConfig(file, *, verbose=True, logstreams=None, readContributions=True):
             generic=boundsAR["generic"],
         )
     else:
-        raise ValueError("Unknown asset allocation type %s." % allocType)
+        raise ValueError(f"Unknown asset allocation type {allocType}.")
 
     # Optimization Parameters.
     p.objective = diconf["Optimization Parameters"]["Objective"]

owlplanner/logging.py

@@ -27,7 +27,7 @@ class Logger(object):
             self._logstreams = 2 * logstreams
             self.vprint("Using logstream as stream logger.")
         else:
-            raise ValueError("Log streams %r must be a list." % logstreams)
+            raise ValueError(f"Log streams {logstreams} must be a list.")
 
     def setVerbose(self, verbose=True):
         """

owlplanner/plan.py

@@ -82,7 +82,7 @@ def _genXi_n(profile, fraction, n_d, N_n, a, b, c):
             xi[n_d:] *= fraction
         xi *= neutralSum / xi.sum()
     else:
-        raise ValueError("Unknown profile type %s." % profile)
+        raise ValueError(f"Unknown profile type {profile}.")
 
     return xi
 
@@ -161,7 +161,7 @@ def _checkCaseStatus(func):
     @wraps(func)
     def wrapper(self, *args, **kwargs):
         if self.caseStatus != "solved":
-            self.mylog.vprint("Preventing to run method %s() while case is %s." % (func.__name__, self.caseStatus))
+            self.mylog.vprint(f"Preventing to run method {func.__name__}() while case is {self.caseStatus}.")
             return None
         return func(self, *args, **kwargs)
 
@@ -177,11 +177,11 @@ def _checkConfiguration(func):
     @wraps(func)
     def wrapper(self, *args, **kwargs):
         if self.xi_n is None:
-            msg = "You must define a spending profile before calling %s()." % func.__name__
+            msg = f"You must define a spending profile before calling {func.__name__}()."
             self.mylog.vprint(msg)
             raise RuntimeError(msg)
         if self.alpha_ijkn is None:
-            msg = "You must define an allocation profile before calling %s()." % func.__name__
+            msg = f"You must define an allocation profile before calling {func.__name__}()."
             self.mylog.vprint(msg)
             raise RuntimeError(msg)
         return func(self, *args, **kwargs)
@@ -201,9 +201,7 @@ def _timer(func):
         result = func(self, *args, **kwargs)
         pt = time.process_time() - pt0
         rt = time.time() - rt0
-        self.mylog.vprint(
-            "CPU time used: %dm%.1fs, Wall time: %dm%.1fs." % (int(pt / 60), pt % 60, int(rt / 60), rt % 60)
-        )
+        self.mylog.vprint(f"CPU time used: {int(pt / 60)}m{pt % 60:.1f}s, Wall time: {int(rt / 60)}m{rt % 60:.1f}s.")
         return result
 
     return wrapper
@@ -245,9 +243,9 @@ class Plan(object):
         self.defaultSolver = "HiGHS"
 
         self.N_i = len(yobs)
-        assert 0 < self.N_i and self.N_i <= 2, "Cannot support %d individuals." % self.N_i
-        assert self.N_i == len(expectancy), "Expectancy must have %d entries." % self.N_i
-        assert self.N_i == len(inames), "Names for individuals must have %d entries." % self.N_i
+        assert 0 < self.N_i and self.N_i <= 2, f"Cannot support {self.N_i} individuals."
+        assert self.N_i == len(expectancy), f"Expectancy must have {self.N_i} entries."
+        assert self.N_i == len(inames), f"Names for individuals must have {self.N_i} entries."
         assert inames[0] != "" or (self.N_i == 2 and inames[1] == ""), "Name for each individual must be provided."
 
         self.filingStatus = ["single", "married"][self.N_i - 1]
@@ -301,13 +299,11 @@ class Plan(object):
         self.prevMAGI = np.zeros((2))
 
         # Scenario starts at the beginning of this year and ends at the end of the last year.
-        self.mylog.vprint(
-            "Preparing scenario of %d years for %d individual%s." % (self.N_n, self.N_i, ["", "s"][self.N_i - 1])
-        )
+        s = ["", "s"][self.N_i - 1]
+        self.mylog.vprint(f"Preparing scenario of {self.N_n} years for {self.N_i} individual{s}.")
         for i in range(self.N_i):
-            self.mylog.vprint(
-                "%14s: life horizon from %d -> %d." % (self.inames[i], thisyear, thisyear + self.horizons[i] - 1)
-            )
+            endyear = thisyear + self.horizons[i] - 1
+            self.mylog.vprint(f"{self.inames[i]:>14}: life horizon from {thisyear} -> {endyear}.")
 
         # Prepare income tax and RMD time series.
         self.rho_in = tx.rho_in(self.yobs, self.N_n)
@@ -340,7 +336,7 @@ class Plan(object):
 
     def setLogstreams(self, verbose, logstreams):
         self.mylog = logging.Logger(verbose, logstreams)
-        # self.mylog.vprint("Setting logstreams to %r." % logstreams)
+        # self.mylog.vprint(f"Setting logstreams to {logstreams}.")
 
     def logger(self):
         return self.mylog
@@ -382,7 +378,7 @@ class Plan(object):
         # Take midnight as the reference.
         self.yearFracLeft = 1 - (refdate.timetuple().tm_yday - 1) / (365 + lp)
 
-        self.mylog.vprint("Setting 1st-year starting date to %s." % (self.startDate))
+        self.mylog.vprint(f"Setting 1st-year starting date to {self.startDate}.")
 
         return None
 
@@ -397,7 +393,7 @@ class Plan(object):
         if value in opts:
             return value
 
-        raise ValueError("Value type must be one of: %r" % opts)
+        raise ValueError(f"Value type must be one of: {opts}")
 
         return None
 
@@ -407,7 +403,7 @@ class Plan(object):
         to distinguish graph outputs and as base name for
         saving configurations and workbooks.
         """
-        self.mylog.vprint("Renaming plan %s -> %s." % (self._name, newname))
+        self.mylog.vprint(f"Renaming plan {self._name} -> {newname}.")
         self._name = newname
 
     def setSpousalDepositFraction(self, eta):
@@ -425,8 +421,8 @@ class Plan(object):
             self.mylog.vprint("Deposit fraction can only be 0 for single individuals.")
             eta = 0
         else:
-            self.mylog.vprint("Setting spousal surplus deposit fraction to %.1f." % eta)
-            self.mylog.vprint("\t%s: %.1f, %s: %.1f" % (self.inames[0], (1 - eta), self.inames[1], eta))
+            self.mylog.vprint(f"Setting spousal surplus deposit fraction to {eta:.1f}.")
+            self.mylog.vprint(f"\t{self.inames[0]}: {1-eta:.1f}, {self.inames[1]}: {eta:.1f}")
             self.eta = eta
 
     def setDefaultPlots(self, value):
@@ -435,7 +431,7 @@ class Plan(object):
         """
 
         self.defaultPlots = self._checkValue(value)
-        self.mylog.vprint("Setting plots default value to %s." % value)
+        self.mylog.vprint(f"Setting plots default value to {value}.")
 
     def setDividendRate(self, mu):
         """
@@ -443,7 +439,7 @@ class Plan(object):
         """
         assert 0 <= mu and mu <= 100, "Rate must be between 0 and 100."
         mu /= 100
-        self.mylog.vprint("Dividend return rate on equities set to %s." % u.pc(mu, f=1))
+        self.mylog.vprint(f"Dividend return rate on equities set to {u.pc(mu, f=1)}.")
         self.mu = mu
         self.caseStatus = "modified"
 
@@ -453,7 +449,7 @@ class Plan(object):
         """
         assert 0 <= psi and psi <= 100, "Rate must be between 0 and 100."
         psi /= 100
-        self.mylog.vprint("Long-term capital gain income tax set to %s." % u.pc(psi, f=0))
+        self.mylog.vprint(f"Long-term capital gain income tax set to {u.pc(psi, f=0)}.")
         self.psi = psi
         self.caseStatus = "modified"
 
@@ -462,17 +458,18 @@ class Plan(object):
         Set fractions of savings accounts that is left to surviving spouse.
         Default is [1, 1, 1] for taxable, tax-deferred, adn tax-exempt accounts.
         """
-        assert len(phi) == self.N_j, "Fractions must have %d entries." % self.N_j
+        assert len(phi) == self.N_j, f"Fractions must have {self.N_j} entries."
         for j in range(self.N_j):
             assert 0 <= phi[j] <= 1, "Fractions must be between 0 and 1."
 
         self.phi_j = np.array(phi, dtype=np.float32)
-        self.mylog.vprint("Spousal beneficiary fractions set to", phi)
+        self.mylog.vprint("Spousal beneficiary fractions set to",
+                          ["{:.2f}".format(self.phi_j[j]) for j in range(self.N_j)])
         self.caseStatus = "modified"
 
         if np.any(self.phi_j != 1):
             self.mylog.vprint("Consider changing spousal deposit fraction for better convergence.")
-            self.mylog.vprint("\tRecommended: setSpousalDepositFraction(%d)" % self.i_d)
+            self.mylog.vprint(f"\tRecommended: setSpousalDepositFraction({self.i_d}.)")
 
     def setHeirsTaxRate(self, nu):
         """
@@ -481,7 +478,7 @@ class Plan(object):
         """
         assert 0 <= nu and nu <= 100, "Rate must be between 0 and 100."
         nu /= 100
-        self.mylog.vprint("Heirs tax rate on tax-deferred portion of estate set to %s." % u.pc(nu, f=0))
+        self.mylog.vprint(f"Heirs tax rate on tax-deferred portion of estate set to {u.pc(nu, f=0)}.")
         self.nu = nu
         self.caseStatus = "modified"
 
@@ -490,14 +487,15 @@ class Plan(object):
         Set value of pension for each individual and commencement age.
         Units are in $k, unless specified otherwise: 'k', 'M', or '1'.
         """
-        assert len(amounts) == self.N_i, "Amounts must have %d entries." % self.N_i
-        assert len(ages) == self.N_i, "Ages must have %d entries." % self.N_i
-        assert len(indexed) >= self.N_i, "Indexed list must have at least %d entries." % self.N_i
+        assert len(amounts) == self.N_i, f"Amounts must have {self.N_i} entries."
+        assert len(ages) == self.N_i, f"Ages must have {self.N_i} entries."
+        assert len(indexed) >= self.N_i, f"Indexed list must have at least {self.N_i} entries."
 
         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)], "at age(s)", ages)
+        self.mylog.vprint("Setting 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
         # Use zero array freshly initialized.
@@ -522,17 +520,15 @@ class Plan(object):
         Set value of social security for each individual and commencement age.
         Units are in $k, unless specified otherwise: 'k', 'M', or '1'.
         """
-        assert len(amounts) == self.N_i, "Amounts must have %d entries." % self.N_i
-        assert len(ages) == self.N_i, "Ages must have %d entries." % self.N_i
+        assert len(amounts) == self.N_i, f"Amounts must have {self.N_i} entries."
+        assert len(ages) == self.N_i, f"Ages must have {self.N_i} entries."
 
         fac = u.getUnits(units)
         amounts = u.rescale(amounts, fac)
 
         self.mylog.vprint(
-            "Setting social security benefits of",
-            [u.d(amounts[i]) for i in range(self.N_i)],
-            "at age(s)",
-            ages,
+            "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)],
         )
 
         thisyear = date.today().year
@@ -560,10 +556,10 @@ class Plan(object):
         as a second argument. Default value is 60%.
         Dip and increase are percent changes in the smile profile.
         """
-        assert 0 <= percent and percent <= 100, "Survivor value %r outside range." % percent
-        assert 0 <= dip and dip <= 100, "Dip value %r outside range." % dip
-        assert -100 <= increase and increase <= 100, "Increase value %r outside range." % dip
-        assert 0 <= delay and delay <= self.N_n - 2, "Delay value %r outside range." % delay
+        assert 0 <= percent and percent <= 100, f"Survivor value {percent} outside range."
+        assert 0 <= dip and dip <= 100, f"Dip value {dip} outside range."
+        assert -100 <= increase and increase <= 100, f"Increase value {increase} outside range."
+        assert 0 <= delay and delay <= self.N_n - 2, f"Delay value {delay} outside year range."
 
         self.chi = percent / 100
 
@@ -606,13 +602,7 @@ class Plan(object):
         self.rateFrm = frm
         self.rateTo = to
         self.tau_kn = dr.genSeries(self.N_n).transpose()
-        self.mylog.vprint(
-            "Generating rate series of",
-            len(self.tau_kn[0]),
-            "years using",
-            method,
-            "method.",
-        )
+        self.mylog.vprint(f"Generating rate series of {len(self.tau_kn[0])} years using {method} method.")
 
         # Account for how late we are now in the first year and reduce rate accordingly.
         self.tau_kn[:, 0] *= self.yearFracLeft
@@ -671,10 +661,10 @@ class Plan(object):
         each spouse.  For single individuals, these lists will contain only
         one entry. Units are in $k, unless specified otherwise: 'k', 'M', or '1'.
         """
-        plurals = ["", "y", "ies"]
-        assert len(taxable) == self.N_i, "taxable must have %d entr%s." % (self.N_i, plurals[self.N_i])
-        assert len(taxDeferred) == self.N_i, "taxDeferred must have %d entr%s." % (self.N_i, plurals[self.N_i])
-        assert len(taxFree) == self.N_i, "taxFree must have %d entr%s." % (self.N_i, plurals[self.N_i])
+        plurals = ["", "y", "ies"][self.N_i]
+        assert len(taxable) == self.N_i, f"taxable must have {self.N_i} entr{plurals}."
+        assert len(taxDeferred) == self.N_i, f"taxDeferred must have {self.N_i} entr{plurals}."
+        assert len(taxFree) == self.N_i, f"taxFree must have {self.N_i} entr{plurals}."
 
         fac = u.getUnits(units)
         taxable = u.rescale(taxable, fac)
@@ -716,12 +706,12 @@ class Plan(object):
             self.interpCenter = center
             self.interpWidth = width
         else:
-            raise ValueError("Method %s not supported." % method)
+            raise ValueError(f"Method {method} not supported.")
 
         self.interpMethod = method
         self.caseStatus = "modified"
 
-        self.mylog.vprint("Asset allocation interpolation method set to %s." % method)
+        self.mylog.vprint(f"Asset allocation interpolation method set to {method}.")
 
     def setAllocationRatios(self, allocType, taxable=None, taxDeferred=None, taxFree=None, generic=None):
         """
@@ -750,31 +740,19 @@ class Plan(object):
         if allocType == "account":
             # Make sure we have proper input.
             for item in [taxable, taxDeferred, taxFree]:
-                assert len(item) == self.N_i, "%s must one entry per individual." % (item)
+                assert len(item) == self.N_i, f"{item} must have one entry per individual."
                 for i in range(self.N_i):
                     # Initial and final.
-                    assert len(item[i]) == 2, "%s[%d] must have 2 lists (initial and final)." % (
-                        item,
-                        i,
-                    )
+                    assert len(item[i]) == 2, f"{item}[{i}] must have 2 lists (initial and final)."
                     for z in range(2):
-                        assert len(item[i][z]) == self.N_k, "%s[%d][%d] must have %d entries." % (
-                            item,
-                            i,
-                            z,
-                            self.N_k,
-                        )
+                        assert len(item[i][z]) == self.N_k, f"{item}[{i}][{z}] must have {self.N_k} entries."
                         assert abs(sum(item[i][z]) - 100) < 0.01, "Sum of percentages must add to 100."
 
             for i in range(self.N_i):
-                self.mylog.vprint(
-                    self.inames[i],
-                    ": Setting gliding allocation ratios (%) to",
-                    allocType,
-                )
-                self.mylog.vprint("      taxable:", taxable[i][0], "->", taxable[i][1])
-                self.mylog.vprint("  taxDeferred:", taxDeferred[i][0], "->", taxDeferred[i][1])
-                self.mylog.vprint("      taxFree:", taxFree[i][0], "->", taxFree[i][1])
+                self.mylog.vprint(f"{self.inames[i]}: Setting gliding allocation ratios (%) to {allocType}.")
+                self.mylog.vprint(f"      taxable: {taxable[i][0]} -> {taxable[i][1]}")
+                self.mylog.vprint(f"  taxDeferred: {taxDeferred[i][0]} -> {taxDeferred[i][1]}")
+                self.mylog.vprint(f"      taxFree: {taxFree[i][0]} -> {taxFree[i][1]}")
 
             # Order in alpha is j, i, 0/1, k.
             alpha = {}
@@ -798,22 +776,14 @@ class Plan(object):
             assert len(generic) == self.N_i, "generic must have one list per individual."
             for i in range(self.N_i):
                 # Initial and final.
-                assert len(generic[i]) == 2, "generic[%d] must have 2 lists (initial and final)." % i
+                assert len(generic[i]) == 2, f"generic[{i}] must have 2 lists (initial and final)."
                 for z in range(2):
-                    assert len(generic[i][z]) == self.N_k, "generic[%d][%d] must have %d entries." % (
-                        i,
-                        z,
-                        self.N_k,
-                    )
+                    assert len(generic[i][z]) == self.N_k, f"generic[{i}][{z}] must have {self.N_k} entries."
                     assert abs(sum(generic[i][z]) - 100) < 0.01, "Sum of percentages must add to 100."
 
             for i in range(self.N_i):
-                self.mylog.vprint(
-                    self.inames[i],
-                    ": Setting gliding allocation ratios (%) to",
-                    allocType,
-                )
-                self.mylog.vprint("\t", generic[i][0], "->", generic[i][1])
+                self.mylog.vprint(f"{self.inames[i]}: Setting gliding allocation ratios (%) to {allocType}.")
+                self.mylog.vprint(f"\t{generic[i][0]} -> {generic[i][1]}")
 
             for i in range(self.N_i):
                 Nin = self.horizons[i] + 1
@@ -829,14 +799,11 @@ class Plan(object):
         elif allocType == "spouses":
             assert len(generic) == 2, "generic must have 2 entries (initial and final)."
             for z in range(2):
-                assert len(generic[z]) == self.N_k, "generic[%d] must have %d entries." % (
-                    z,
-                    self.N_k,
-                )
+                assert len(generic[z]) == self.N_k, f"generic[{z}] must have {self.N_k} entries."
                 assert abs(sum(generic[z]) - 100) < 0.01, "Sum of percentages must add to 100."
 
-            self.mylog.vprint("Setting gliding allocation ratios (%) to", allocType)
-            self.mylog.vprint("\t", generic[0], "->", generic[1])
+            self.mylog.vprint(f"Setting gliding allocation ratios (%) to {allocType}.")
+            self.mylog.vprint(f"\t{generic[0]} -> {generic[1]}")
 
             # Use longest-lived spouse for both time scales.
             Nxn = max(self.horizons) + 1
@@ -854,7 +821,7 @@ class Plan(object):
         self.ARCoord = allocType
         self.caseStatus = "modified"
 
-        self.mylog.vprint("Interpolating assets allocation ratios using", self.interpMethod, "method.")
+        self.mylog.vprint(f"Interpolating assets allocation ratios using {self.interpMethod} method.")
 
     def readContributions(self, filename):
         """
@@ -880,7 +847,7 @@ class Plan(object):
         try:
             filename, self.timeLists = timelists.read(filename, self.inames, self.horizons, self.mylog)
         except Exception as e:
-            raise Exception("Unsuccessful read of contributions: %s" % e)
+            raise Exception(f"Unsuccessful read of contributions: {e}")
             return False
 
         self.timeListsFileName = filename
@@ -1045,13 +1012,7 @@ class Plan(object):
         self.nvars = _qC(C["z"], self.N_i, self.N_n, self.N_z)
 
         self.C = C
-        self.mylog.vprint(
-            "Problem has",
-            len(C),
-            "distinct time series forming",
-            self.nvars,
-            "decision variables.",
-        )
+        self.mylog.vprint(f"Problem has {len(C)} distinct time series forming {self.nvars} decision variables.")
 
         return None
 
@@ -1132,7 +1093,7 @@ class Plan(object):
         # Roth conversions equalities/inequalities.
         if "maxRothConversion" in options:
             if options["maxRothConversion"] == "file":
-                # self.mylog.vprint('Fixing Roth conversions to those from file %s.' % self.timeListsFileName)
+                # self.mylog.vprint(f"Fixing Roth conversions to those from file {self.timeListsFileName}.")
                 for i in range(Ni):
                     for n in range(self.horizons[i]):
                         rhs = self.myRothX_in[i][n]
@@ -1157,7 +1118,7 @@ class Plan(object):
             try:
                 i_x = self.inames.index(rhsopt)
             except ValueError:
-                raise ValueError("Unknown individual %s for noRothConversions:" % rhsopt)
+                raise ValueError(f"Unknown individual {rhsopt} for noRothConversions:")
 
             for n in range(Nn):
                 B.set0_Ub(_q2(Cx, i_x, n, Ni, Nn), zero)
@@ -1397,10 +1358,10 @@ class Plan(object):
         """
         if yend + self.N_n > self.year_n[0]:
             yend = self.year_n[0] - self.N_n - 1
-            self.mylog.vprint("Warning: Upper bound for year range re-adjusted to %d." % yend)
+            self.mylog.vprint(f"Warning: Upper bound for year range re-adjusted to {yend}.")
         N = yend - ystart + 1
 
-        self.mylog.vprint("Running historical range from %d to %d." % (ystart, yend))
+        self.mylog.vprint(f"Running historical range from {ystart} to {yend}.")
 
         self.mylog.setVerbose(verbose)
 
@@ -1409,7 +1370,7 @@ class Plan(object):
         elif objective == "maxBequest":
             columns = ["partial", "final"]
         else:
-            self.mylog.print("Invalid objective %s." % objective)
+            self.mylog.print(f"Invalid objective {objective}.")
             return None
 
         df = pd.DataFrame(columns=columns)
@@ -1450,7 +1411,7 @@ class Plan(object):
             self.mylog.print("It is pointless to run Monte Carlo simulations with fixed rates.")
             return
 
-        self.mylog.vprint("Running %d Monte Carlo simulations." % N)
+        self.mylog.vprint(f"Running {N} Monte Carlo simulations.")
         self.mylog.setVerbose(verbose)
 
         # Turn off Medicare by default, unless specified in options.
@@ -1465,7 +1426,7 @@ class Plan(object):
         elif objective == "maxBequest":
             columns = ["partial", "final"]
         else:
-            self.mylog.print("Invalid objective %s." % objective)
+            self.mylog.print(f"Invalid objective {objective}.")
             return None
 
         df = pd.DataFrame(columns=columns)
@@ -1505,8 +1466,9 @@ class Plan(object):
 
         description = io.StringIO()
 
-        print("Success rate: %s on %d samples." % (u.pc(len(df) / N), N), file=description)
-        title = "$N$ = %d, $P$ = %s" % (N, u.pc(len(df) / N))
+        pSuccess = u.pc(len(df) / N)
+        print(f"Success rate: {pSuccess} on {N} samples.", file=description)
+        title = f"$N$ = {N}, $P$ = {pSuccess}"
         means = df.mean(axis=0, numeric_only=True)
         medians = df.median(axis=0, numeric_only=True)
 
@@ -1518,13 +1480,14 @@ class Plan(object):
         # or if solution led to empty accounts at the end of first spouse's life.
         if np.all(self.phi_j == 1) or medians.iloc[0] < 1:
             if medians.iloc[0] < 1:
-                print("Optimized solutions all have null partial bequest in year %d." % my[0], file=description)
+                print(f"Optimized solutions all have null partial bequest in year {my[0]}.", file=description)
             df.drop("partial", axis=1, inplace=True)
             means = df.mean(axis=0, numeric_only=True)
             medians = df.median(axis=0, numeric_only=True)
 
         df /= 1000
         if len(df) > 0:
+            thisyear = self.year_n[0]
             if objective == "maxBequest":
                 fig, axes = plt.subplots()
                 # Show both partial and final bequests in the same histogram.
@@ -1532,37 +1495,36 @@ class Plan(object):
                 legend = []
                 # Don't know why but legend is reversed from df.
                 for q in range(len(means) - 1, -1, -1):
-                    legend.append(
-                        "%d: $M$: %s, $\\bar{x}$: %s"
-                        % (my[q], u.d(medians.iloc[q], latex=True), u.d(means.iloc[q], latex=True))
-                    )
+                    dmedian = u.d(medians.iloc[q], latex=True)
+                    dmean = u.d(means.iloc[q], latex=True)
+                    legend.append(f"{my[q]}: $M$: {dmedian}, $\\bar{{x}}$: {dmean}")
                 plt.legend(legend, shadow=True)
-                plt.xlabel("%d $k" % self.year_n[0])
+                plt.xlabel(f"{thisyear} $k")
                 plt.title(objective)
-                leads = ["partial %d" % my[0], "  final %d" % my[1]]
+                leads = [f"partial {my[0]}", f"  final {my[1]}"]
             elif len(means) == 2:
                 # Show partial bequest and net spending as two separate histograms.
                 fig, axes = plt.subplots(1, 2, figsize=(10, 5))
                 cols = ["partial", objective]
-                leads = ["partial %d" % my[0], objective]
+                leads = [f"partial {my[0]}", objective]
                 for q in range(2):
                     sbn.histplot(df[cols[q]], kde=True, ax=axes[q])
-                    legend = [
-                        ("$M$: %s, $\\bar{x}$: %s" % (u.d(medians.iloc[q], latex=True), u.d(means.iloc[q], latex=True)))
-                    ]
+                    dmedian = u.d(medians.iloc[q], latex=True)
+                    dmean = u.d(means.iloc[q], latex=True)
+                    legend = [f"$M$: {dmedian}, $\\bar{{x}}$: {dmean}"]
                     axes[q].set_label(legend)
                     axes[q].legend(labels=legend)
                     axes[q].set_title(leads[q])
-                    axes[q].set_xlabel("%d $k" % self.year_n[0])
+                    axes[q].set_xlabel(f"{thisyear} $k")
             else:
                 # Show net spending as single histogram.
                 fig, axes = plt.subplots()
                 sbn.histplot(df[objective], kde=True, ax=axes)
-                legend = [
-                    ("$M$: %s, $\\bar{x}$: %s" % (u.d(medians.iloc[0], latex=True), u.d(means.iloc[0], latex=True)))
-                ]
+                dmedian = u.d(medians.iloc[0], latex=True)
+                dmean = u.d(means.iloc[0], latex=True)
+                legend = [f"$M$: {dmedian}, $\\bar{{x}}$: {dmean}"]
                 plt.legend(legend, shadow=True)
-                plt.xlabel("%d $k" % self.year_n[0])
+                plt.xlabel(f"{thisyear} $k")
                 plt.title(objective)
                 leads = [objective]
 
@@ -1570,15 +1532,13 @@ class Plan(object):
             # plt.show()
 
         for q in range(len(means)):
-            print("%12s: Median (%d $): %s" % (leads[q], self.year_n[0], u.d(medians.iloc[q])), file=description)
-            print("%12s:   Mean (%d $): %s" % (leads[q], self.year_n[0], u.d(means.iloc[q])), file=description)
-            print(
-                "%12s:           Range: %s - %s"
-                % (leads[q], u.d(1000 * df.iloc[:, q].min()), u.d(1000 * df.iloc[:, q].max())),
-                file=description,
-            )
+            print(f"{leads[q]:>12}: Median ({thisyear} $): {u.d(medians.iloc[q])}", file=description)
+            print(f"{leads[q]:>12}:   Mean ({thisyear} $): {u.d(means.iloc[q])}", file=description)
+            mmin = 1000 * df.iloc[:, q].min()
+            mmax = 1000 * df.iloc[:, q].max()
+            print(f"{leads[q]:>12}:           Range: {u.d(mmin)} - {u.d(mmax)}", file=description)
             nzeros = len(df.iloc[:, q][df.iloc[:, q] < 0.001])
-            print("%12s:  N zero solns: %d" % (leads[q], nzeros), file=description)
+            print(f"{leads[q]:>12}:    N zero solns: {nzeros}", file=description)
 
         return fig, description
 
@@ -1637,13 +1597,13 @@ class Plan(object):
 
         for opt in myoptions:
             if opt not in knownOptions:
-                raise ValueError("Option %s is not one of %r." % (opt, knownOptions))
+                raise ValueError(f"Option {opt} is not one of {knownOptions}.")
 
         if objective not in knownObjectives:
-            raise ValueError("Objective %s is not one of %r." % (objective, knownObjectives))
+            raise ValueError(f"Objective {objective} is not one of {knownObjectives}.")
 
         if objective == "maxBequest" and "netSpending" not in myoptions:
-            raise RuntimeError("Objective %s needs netSpending option." % objective)
+            raise RuntimeError(f"Objective {objective} needs netSpending option.")
 
         if objective == "maxBequest" and "bequest" in myoptions:
             self.mylog.vprint("Ignoring bequest option provided.")
@@ -1672,7 +1632,7 @@ class Plan(object):
         if "solver" in options:
             solver = myoptions["solver"]
             if solver not in knownSolvers:
-                raise ValueError("Unknown solver %s." % solver)
+                raise ValueError(f"Unknown solver {solver}.")
         else:
             solver = self.defaultSolver
 
@@ -1735,7 +1695,7 @@ class Plan(object):
 
             self._estimateMedicare(solution.x)
 
-            self.mylog.vprint("Iteration:", it, "objective:", u.d(solution.fun * objFac, f=2))
+            self.mylog.vprint(f"Iteration: {it} objective: {u.d(solution.fun * objFac, f=2)}")
 
             delta = solution.x - old_x
             absdiff = np.sum(np.abs(delta), axis=0)
@@ -1757,9 +1717,9 @@ class Plan(object):
             old_x = solution.x
 
         if solution.success:
-            self.mylog.vprint("Self-consistent Medicare loop returned after %d iterations." % it)
+            self.mylog.vprint(f"Self-consistent Medicare loop returned after {it} iterations.")
             self.mylog.vprint(solution.message)
-            self.mylog.vprint("Objective:", u.d(solution.fun * objFac))
+            self.mylog.vprint(f"Objective: {u.d(solution.fun * objFac)}")
             # self.mylog.vprint('Upper bound:', u.d(-solution.mip_dual_bound))
             self._aggregateResults(solution.x)
             self._timestamp = datetime.now().strftime("%Y-%m-%d at %H:%M:%S")
@@ -1871,7 +1831,7 @@ class Plan(object):
         task.set_Stream(mosek.streamtype.wrn, _streamPrinter)
         # task.writedata(self._name+'.ptf')
         if solsta == mosek.solsta.integer_optimal:
-            self.mylog.vprint("Self-consistent Medicare loop returned after %d iterations." % it)
+            self.mylog.vprint(f"Self-consistent Medicare loop returned after {it} iterations.")
             task.solutionsummary(mosek.streamtype.msg)
             self.mylog.vprint("Objective:", u.d(solution * objFac))
             self.caseStatus = "solved"
@@ -2052,7 +2012,7 @@ class Plan(object):
         """
         _estate = np.sum(self.b_ijn[:, :, :, self.N_n], axis=(0, 2))
         _estate[1] *= 1 - self.nu
-        self.mylog.vprint("Estate value of %s at the end of year %s." % (u.d(sum(_estate)), self.year_n[-1]))
+        self.mylog.vprint(f"Estate value of {u.d(sum(_estate))} at the end of year {self.year_n[-1]}.")
 
         return None
 
@@ -2104,67 +2064,63 @@ class Plan(object):
 
         totIncome = np.sum(self.g_n, axis=0)
         totIncomeNow = np.sum(self.g_n / self.gamma_n[:-1], axis=0)
-        dic[f"Total net spending in {now}$"] = "%s (%s nominal)" % (u.d(totIncomeNow), u.d(totIncome))
+        dic[f"Total net spending in {now}$"] = f"{u.d(totIncomeNow)} ({u.d(totIncome)} nominal)"
 
         totRoth = np.sum(self.x_in, axis=(0, 1))
         totRothNow = np.sum(np.sum(self.x_in, axis=0) / self.gamma_n[:-1], axis=0)
-        dic[f"Total Roth conversions in {now}$"] = "%s (%s nominal)" % (u.d(totRothNow), u.d(totRoth))
+        dic[f"Total Roth conversions in {now}$"] = f"{u.d(totRothNow)} ({u.d(totRoth)} nominal)"
 
         taxPaid = np.sum(self.T_n, axis=0)
         taxPaidNow = np.sum(self.T_n / self.gamma_n[:-1], axis=0)
-        dic[f"Total income tax paid on ordinary income in {now}$"] = "%s (%s nominal)" % (u.d(taxPaidNow), u.d(taxPaid))
+        dic[f"Total income tax paid on ordinary income in {now}$"] = f"{u.d(taxPaidNow)} ({u.d(taxPaid)} nominal)"
 
         taxPaid = np.sum(self.U_n, axis=0)
         taxPaidNow = np.sum(self.U_n / self.gamma_n[:-1], axis=0)
-        dic[f"Total tax paid on gains and dividends in {now}$"] = "%s (%s nominal)" % (u.d(taxPaidNow), u.d(taxPaid))
+        dic[f"Total tax paid on gains and dividends in {now}$"] = f"{u.d(taxPaidNow)} ({u.d(taxPaid)} nominal)"
 
         taxPaid = np.sum(self.M_n, axis=0)
         taxPaidNow = np.sum(self.M_n / self.gamma_n[:-1], axis=0)
-        dic[f"Total Medicare premiums paid in {now}$"] = "%s (%s nominal)" % (u.d(taxPaidNow), u.d(taxPaid))
+        dic[f"Total Medicare premiums paid in {now}$"] = f"{u.d(taxPaidNow)} ({u.d(taxPaid)} nominal)"
 
         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
             nx = self.n_d - 1
+            ynx = self.year_n[nx]
             totOthers = np.sum(p_j)
             totOthersNow = totOthers / self.gamma_n[nx + 1]
             q_j = self.partialEstate_j * self.phi_j
             totSpousal = np.sum(q_j)
             totSpousalNow = totSpousal / self.gamma_n[nx + 1]
-            dic[
-                "Spousal wealth transfer from %s to %s in year %d (nominal)"
-                % (self.inames[self.i_d], self.inames[self.i_s], self.year_n[nx])
-            ] = "taxable: %s  tax-def: %s  tax-free: %s" % (u.d(q_j[0]), u.d(q_j[1]), u.d(q_j[2]))
+            iname_s = self.inames[self.i_s]
+            iname_d = self.inames[self.i_d]
+            dic[f"Spousal wealth transfer from {iname_d} to {iname_s} in year {ynx} (nominal)"] = (
+                f"taxable: {u.d(q_j[0])}  tax-def: {u.d(q_j[1])}  tax-free: {u.d(q_j[2])}")
 
-            dic["Sum of spousal bequests to %s in year %d in %d$" % (self.inames[self.i_s], self.year_n[nx], now)] = (
-                "%s (%s nominal)" % (u.d(totSpousalNow), u.d(totSpousal))
-            )
+            dic[f"Sum of spousal bequests to {iname_s} in year {ynx} in {now}$"] = (
+                f"{u.d(totSpousalNow)} ({u.d(totSpousal)} nominal)")
             dic[
-                "Post-tax non-spousal bequests from %s in year %d (nominal)" % (self.inames[self.i_d], self.year_n[nx])
-            ] = "taxable: %s  tax-def: %s  tax-free: %s" % (u.d(p_j[0]), u.d(p_j[1]), u.d(p_j[2]))
+                f"Post-tax non-spousal bequests from {iname_d} in year {ynx} (nominal)"] = (
+                f"taxable: {u.d(p_j[0])}  tax-def: {u.d(p_j[1])}  tax-free: {u.d(p_j[2])}")
             dic[
-                "Sum of post-tax non-spousal bequests from %s in year %d in %d$"
-                % (self.inames[self.i_d], self.year_n[nx], now)
-            ] = "%s (%s nominal)" % (u.d(totOthersNow), u.d(totOthers))
+                f"Sum of post-tax non-spousal bequests from {iname_d} in year {ynx} in {now}$"] = (
+                f"{u.d(totOthersNow)} ({u.d(totOthers)} nominal)")
 
         estate = np.sum(self.b_ijn[:, :, self.N_n], axis=0)
         estate[1] *= 1 - self.nu
-        dic["Post-tax account values at the end of final plan year %d (nominal)" % self.year_n[-1]] = (
-            "taxable: %s  tax-def: %s  tax-free: %s" % (u.d(estate[0]), u.d(estate[1]), u.d(estate[2]))
-        )
+        lastyear = self.year_n[-1]
+        dic[f"Post-tax account values at the end of final plan year {lastyear} (nominal)"] = (
+            f"taxable: {u.d(estate[0])}  tax-def: {u.d(estate[1])}  tax-free: {u.d(estate[2])}")
 
         totEstate = np.sum(estate)
         totEstateNow = totEstate / self.gamma_n[-1]
-        dic["Total estate value at the end of final plan year %d in %d$" % (self.year_n[-1], now)] = (
-            "%s (%s nominal)" % (u.d(totEstateNow), u.d(totEstate))
-        )
+        dic[f"Total estate value at the end of final plan year {lastyear} in {now}$"] = (
+            f"{u.d(totEstateNow)} ({u.d(totEstate)} nominal)")
         dic["Plan starting date"] = str(self.startDate)
-        dic["Cumulative inflation factor from start date to end of plan"] = "%.2f" % (self.gamma_n[-1])
+        dic["Cumulative inflation factor from start date to end of plan"] = f"{self.gamma_n[-1]:.2f}"
         for i in range(self.N_i):
-            dic["%12s's %02d-year life horizon" % (self.inames[i], self.horizons[i])] = "%d -> %d" % (
-                now,
-                now + self.horizons[i] - 1,
-            )
+            dic[f"{self.inames[i]:>12}'s {self.horizons[i]:02}-year life horizon"] = (
+                f"{now} -> {now + self.horizons[i] - 1}")
 
         dic["Plan name"] = self._name
         dic["Number of decision variables"] = str(self.A.nvars)
@@ -2182,7 +2138,7 @@ class Plan(object):
         import seaborn as sbn
 
         if self.rateMethod in [None, "user", "historical average", "conservative"]:
-            self.mylog.vprint("Warning: Cannot plot correlations for %s rate method." % self.rateMethod)
+            self.mylog.vprint(f"Warning: Cannot plot correlations for {self.rateMethod} rate method.")
             return None
 
         rateNames = [
@@ -2218,7 +2174,7 @@ class Plan(object):
         # plt.subplots_adjust(wspace=0.3, hspace=0.3)
 
         title = self._name + "\n"
-        title += "Rates Correlations (N=%d) %s" % (self.N_n, self.rateMethod)
+        title += f"Rates Correlations (N={self.N_n}) {self.rateMethod}"
         if self.rateMethod in ["historical", "histochastic"]:
             title += " (" + str(self.rateFrm) + "-" + str(self.rateTo) + ")"
 
@@ -2418,7 +2374,7 @@ class Plan(object):
         elif self.ARCoord == "account":
             acList = ["taxable", "tax-deferred", "tax-free"]
         else:
-            raise ValueError("Unknown coordination %s" % self.ARCoord)
+            raise ValueError(f"Unknown coordination {self.ARCoord}.")
 
         figures = []
         assetDic = {"stocks": 0, "C bonds": 1, "T notes": 2, "common": 3}
@@ -2876,12 +2832,12 @@ class Plan(object):
                 df.to_csv(fname)
                 break
             except PermissionError:
-                self.mylog.print('Failed to save "%s": %s.' % (fname, "Permission denied"))
+                self.mylog.print(f'Failed to save "{fname}": Permission denied.')
                 key = input("Close file and try again? [Yn] ")
                 if key == "n":
                     break
             except Exception as e:
-                raise Exception("Unanticipated exception %r." % e)
+                raise Exception(f"Unanticipated exception: {e}.")
 
         return None
 
@@ -2945,7 +2901,7 @@ def _stackPlot(x, inames, title, irange, series, snames, location, yformat="\\$k
         ax.set_ylabel("%")
         ax.get_yaxis().set_major_formatter(tk.FuncFormatter(lambda x, p: format(int(100 * x), ",")))
     else:
-        raise RuntimeError("Unknown yformat: %s." % yformat)
+        raise RuntimeError(f"Unknown yformat: {yformat}.")
 
     return fig, ax
 
@@ -2963,7 +2919,7 @@ def _saveWorkbook(wb, basename, overwrite, mylog):
         fname = basename
 
     if overwrite is False and isfile(fname):
-        mylog.print('File "%s" already exists.' % fname)
+        mylog.print(f'File "{fname}" already exists.')
         key = input("Overwrite? [Ny] ")
         if key != "y":
             mylog.vprint("Skipping save and returning.")
@@ -2971,16 +2927,16 @@ def _saveWorkbook(wb, basename, overwrite, mylog):
 
     while True:
         try:
-            mylog.vprint('Saving plan as "%s".' % fname)
+            mylog.vprint(f'Saving plan as "{fname}".')
             wb.save(fname)
             break
         except PermissionError:
-            mylog.print('Failed to save "%s": %s.' % (fname, "Permission denied"))
+            mylog.print(f'Failed to save "{fname}": Permission denied.')
             key = input("Close file and try again? [Yn] ")
             if key == "n":
                 break
         except Exception as e:
-            raise Exception("Unanticipated exception %r." % e)
+            raise Exception(f"Unanticipated exception {e}.")
 
     return None
 
@@ -3004,7 +2960,7 @@ def _formatSpreadsheet(ws, ftype):
             ws.column_dimensions[column].width = width
             return None
     else:
-        raise RuntimeError("Unknown format: %s." % ftype)
+        raise RuntimeError(f"Unknown format: {ftype}.")
 
     for cell in ws[1] + ws["A"]:
         cell.style = "Pandas"

owlplanner/progress.py

@@ -14,7 +14,7 @@ class Progress(object):
         self.mylog.print("|--- progress ---|")
 
     def show(self, x):
-        self.mylog.print("\r\r%s" % u.pc(x, f=0), end="")
+        self.mylog.print(f"\r\r{u.pc(x, f=0)}", end="")
 
     def finish(self):
         self.mylog.print()

owlplanner/rates.py

@@ -121,9 +121,9 @@ def historicalValue(amount, year):
     valued at the beginning of the year specified.
     """
     thisyear = date.today().year
-    assert TO == thisyear - 1, "Rates file needs to be updated to be current to %d." % thisyear
-    assert year >= FROM, "Only data from %d is available." % FROM
-    assert year <= thisyear, "Year must be < %d for historical data." % thisyear
+    assert TO == thisyear - 1, f"Rates file needs to be updated to be current to {thisyear}."
+    assert year >= FROM, f"Only data from {FROM} is available."
+    assert year <= thisyear, f"Year must be < {thisyear} for historical data."
 
     span = thisyear - year
     ub = len(Inflation)
@@ -203,7 +203,7 @@ class Rates(object):
             "stochastic",
             "histochastic",
         ]:
-            raise ValueError("Unknown rate selection method %s." % method)
+            raise ValueError(f"Unknown rate selection method {method}.")
 
         Nk = len(self._defRates)
         # First process fixed methods relying on values.
@@ -221,7 +221,7 @@ class Rates(object):
             self._setFixedRates(self._conservRates)
         elif method == "user":
             assert values is not None, "Fixed values must be provided with the user option."
-            assert len(values) == Nk, "values must have %d items." % Nk
+            assert len(values) == Nk, f"Values must have {Nk} items."
             self.means = np.array(values, dtype=float)
             # Convert percent to decimal for storing.
             self.means /= 100.0
@@ -230,8 +230,8 @@ class Rates(object):
         elif method == "stochastic":
             assert values is not None, "Mean values must be provided with the stochastic option."
             assert stdev is not None, "Standard deviations must be provided with the stochastic option."
-            assert len(values) == Nk, "values must have %d items." % Nk
-            assert len(stdev) == Nk, "stdev must have %d items." % Nk
+            assert len(values) == Nk, f"Values must have {Nk} items."
+            assert len(stdev) == Nk, f"stdev must have {Nk} items."
             self.means = np.array(values, dtype=float)
             self.stdev = np.array(stdev, dtype=float)
             # Convert percent to decimal for storing.
@@ -256,7 +256,7 @@ class Rates(object):
                             x += 1
                     corrarr = newcorr
                 else:
-                    raise RuntimeError("Unable to process correlation shape of %s." % corrarr.shape)
+                    raise RuntimeError(f"Unable to process correlation shape of {corrarr.shape}.")
 
             self.corr = corrarr
             assert np.array_equal(self.corr, self.corr.T), "Correlation matrix must be symmetric."
@@ -271,25 +271,25 @@ class Rates(object):
         else:
             # Then methods relying on historical data range.
             assert frm is not None, "From year must be provided with this option."
-            assert FROM <= frm and frm <= TO, 'Lower range "frm=%d" out of bounds.' % frm
-            assert FROM <= to and to <= TO, 'Upper range "to=%d" out of bounds.' % to
+            assert FROM <= frm and frm <= TO, f"Lower range 'frm={frm}' out of bounds."
+            assert FROM <= to and to <= TO, f"Upper range 'to={to}' out of bounds."
             assert frm < to, "Unacceptable range."
             self.frm = frm
             self.to = to
 
             if method == "historical":
-                self.mylog.vprint("Using historical rates representing data from %d to %d." % (frm, to))
+                self.mylog.vprint(f"Using historical rates representing data from {frm} to {to}.")
                 self._rateMethod = self._histRates
             elif method == "historical average" or method == "means":
-                self.mylog.vprint("Using average of rates from %d to %d." % (frm, to))
+                self.mylog.vprint(f"Using average of rates from {frm} to {to}.")
                 self.means, self.stdev, self.corr, self.covar = getRatesDistributions(frm, to, self.mylog)
                 self._setFixedRates(self.means)
             elif method == "histochastic":
-                self.mylog.vprint("Using histochastic rates derived from years %d to %d." % (frm, to))
+                self.mylog.vprint(f"Using histochastic rates derived from years {frm} to {to}.")
                 self._rateMethod = self._stochRates
                 self.means, self.stdev, self.corr, self.covar = getRatesDistributions(frm, to, self.mylog)
             else:
-                raise ValueError("Method $s not supported." % method)
+                raise ValueError(f"Method {method} not supported.")
 
         self.method = method
 
@@ -297,7 +297,7 @@ class Rates(object):
 
     def _setFixedRates(self, rates):
         Nk = len(self._defRates)
-        assert len(rates) == Nk, "Rate list provided must have %d entries." % Nk
+        assert len(rates) == Nk, f"Rate list provided must have {Nk} entries."
         self._myRates = np.array(rates)
         self._rateMethod = self._fixedRates
 

owlplanner/tax2025.py

@@ -154,7 +154,7 @@ def taxBrackets(N_i, n_d, N_n):
     Return dictionary containing future tax brackets
     unadjusted for inflation for plotting.
     """
-    assert 0 < N_i and N_i <= 2, "Cannot process %d individuals." % N_i
+    assert 0 < N_i and N_i <= 2, f"Cannot process {N_i} individuals."
     # This 1 is the number of years left in TCJA from 2025.
     ytc = 1
     status = N_i - 1

owlplanner/timelists.py

@@ -55,12 +55,12 @@ def read(finput, inames, horizons, mylog):
         try:
             dfDict = pd.read_excel(finput, sheet_name=None)
         except Exception as e:
-            raise Exception("Could not read file %r: %s." % (finput, e))
-        streamName = "file '%s'" % finput
+            raise Exception(f"Could not read file {finput}: {e}.")
+        streamName = f"file '{finput}'"
 
         timeLists = condition(dfDict, inames, horizons, mylog)
 
-    mylog.vprint("Successfully read time horizons from %s." % streamName)
+    mylog.vprint(f"Successfully read time horizons from {streamName}.")
 
     return finput, timeLists
 
@@ -101,10 +101,10 @@ def condition(dfDict, inames, horizons, mylog):
             else:
                 for item in timeHorizonItems:
                     if item != "big-ticket items" and df[item].iloc[n] < 0:
-                        raise ValueError("Item %s for %s in year %d is < 0." % (item, iname, df["year"].iloc[n]))
+                        raise ValueError(f"Item {item} for {iname} in year {df['year'].iloc[n]} is < 0.")
 
         if len(missing) > 0:
-            mylog.vprint("Adding %d missing years for %s: %r." % (len(missing), iname, missing))
+            mylog.vprint(f"Adding {len(missing)} missing years for {iname}: {missing}.")
 
         df.sort_values("year", inplace=True)
         # Replace empty (NaN) cells with 0 value.

owlplanner/utils.py

@@ -65,7 +65,7 @@ def getUnits(units) -> int:
     elif units in {"m", "M"}:
         fac = 1000000
     else:
-        raise ValueError("Unknown units %r." % units)
+        raise ValueError(f"Unknown units {units}.")
 
     return fac
 

owlplanner/version.py

@@ -1 +1 @@
-__version__ = "2025.02.09"
+__version__ = "2025.02.11"

{owlplanner-2025.2.9.dist-info → owlplanner-2025.2.11.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: owlplanner
-Version: 2025.2.9
+Version: 2025.2.11
 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.2.11.dist-info/RECORD

@@ -0,0 +1,17 @@
+owlplanner/__init__.py,sha256=QqrdT0Qks20osBTg7h0vJHAxpP9lL7DA99xb0nYbtw4,254
+owlplanner/abcapi.py,sha256=LbzW_KcNy0IeHp42MUHwGu_H67B2h_e1_vu-c2ACTkQ,6646
+owlplanner/config.py,sha256=XFVcXFVpEuWXzybaijNGSTt72py3cYJ3oq0S1ujivl0,11702
+owlplanner/logging.py,sha256=tYMw04O-XYSzjTj36fmKJGLcE1VkK6k6oJNeqtKXzuc,2530
+owlplanner/plan.py,sha256=f_F7sIka4c_91dV7X5XHJkVvztXbtS_cqi24ncBI9gY,113084
+owlplanner/progress.py,sha256=8jlCvvtgDI89zXVNMBg1-lnEyhpPvKQS2X5oAIpoOVQ,384
+owlplanner/rates.py,sha256=TN407qU4n-bac1oymkQ_n2QKEPwFQxy6JZVGwgIkLQU,15585
+owlplanner/tax2025.py,sha256=PVteko6G9gjAT247GnTzAPUe_RaLnZUArFtdzf1dF3M,7014
+owlplanner/timelists.py,sha256=tYieZU67FT6TCcQQis36JaXGI7dT6NqD7RvdEjgJL4M,4026
+owlplanner/utils.py,sha256=HM70W60qB41zfnbl2LltNwAuLYHyy5XYbwnbNcaa6FE,2351
+owlplanner/version.py,sha256=n8NJ4iSncRuwW7_28_WeKgNkjAmkCzQOs0fAbkRFU5E,28
+owlplanner/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+owlplanner/data/rates.csv,sha256=6fxg56BVVORrj9wJlUGFdGXKvOX5r7CSca8uhUbbuIU,3734
+owlplanner-2025.2.11.dist-info/METADATA,sha256=VkjJTA1BGuWJ1HnFS4tGWYrPvA1s_iV0YyIrnxYN2yk,63947
+owlplanner-2025.2.11.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
+owlplanner-2025.2.11.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+owlplanner-2025.2.11.dist-info/RECORD,,

owlplanner-2025.2.9.dist-info/RECORD

@@ -1,17 +0,0 @@
-owlplanner/__init__.py,sha256=QqrdT0Qks20osBTg7h0vJHAxpP9lL7DA99xb0nYbtw4,254
-owlplanner/abcapi.py,sha256=J2xlj6LXwIblot0g4UeO5BC-vIYXsrI72duH82H6Di8,6658
-owlplanner/config.py,sha256=tKqqDxzygC283UPyZwa47oq0PBH0uEv_1bwiwAdRm4Q,11731
-owlplanner/logging.py,sha256=0y6Mhj56vmilgnDvw0pA8ur15oz5O3IN7qNCaf8yUIk,2532
-owlplanner/plan.py,sha256=5biGxkIfilBHOfoROpDs7m_BmzywJ6qldm_8aGAXbXU,114092
-owlplanner/progress.py,sha256=uyCUmuvZzvg2UPonjmXmUsWnnP55Mm6n19Xg3WcjwHU,386
-owlplanner/rates.py,sha256=CRQBaAXIB7hkxkLyDxxptBGuwnXwoIvK9_j4qTAc23Y,15627
-owlplanner/tax2025.py,sha256=VNRo1CiskHLEY_m5-wPVBVK-eFoFIaDF2lFRW-bHdc4,7016
-owlplanner/timelists.py,sha256=NgyPifalMBLfKi-2mtkAems4DnOJSkPtPPXR7LmbGTU,4052
-owlplanner/utils.py,sha256=Wy3ngYuVmWB2CeJx-v6vdhlSeSszQTjtuPtbc7hTb_A,2353
-owlplanner/version.py,sha256=WQPMjK8ZbcCw8owMuvICW0qcZSL2-1yIsSwBODMumNs,28
-owlplanner/data/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-owlplanner/data/rates.csv,sha256=6fxg56BVVORrj9wJlUGFdGXKvOX5r7CSca8uhUbbuIU,3734
-owlplanner-2025.2.9.dist-info/METADATA,sha256=cxhHp7ve0Rpmdr2pChd-y21DmNOejUweN_x8tR7N9K8,63946
-owlplanner-2025.2.9.dist-info/WHEEL,sha256=qtCwoSJWgHk21S1Kb4ihdzI2rlJ1ZKaIurTj_ngOhyQ,87
-owlplanner-2025.2.9.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
-owlplanner-2025.2.9.dist-info/RECORD,,