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

owlplanner/utils.py

@@ -1,17 +1,28 @@
 """
+Utility functions for data formatting and manipulation.
 
-Owl/utils
+This module provides helper functions for formatting currency, percentages,
+and other data transformations used throughout the retirement planner.
 
-This file contains functions for handling data.
+Copyright (C) 2025-2026 The Owlplanner Authors
 
-Copyright © 2024 - Martin-D. Lacasse
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
 
-Disclaimers: This code is for educational purposes only and does not constitute financial advice.
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
 
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
 """
 
 ######################################################################
 import numpy as np
+import pandas as pd
 
 
 def d(value, f=0, latex=False) -> str:
@@ -70,6 +81,15 @@ def getUnits(units) -> int:
     return fac
 
 
+def get_numeric_option(options, key, default, *, min_value=None) -> float:
+    value = options.get(key, default)
+    if not isinstance(value, (int, float)):
+        raise ValueError(f"{key} {value} is not a number.")
+    if min_value is not None and value < min_value:
+        raise ValueError(f"{key} must be >= {min_value}.")
+    return float(value)
+
+
 # Next two functions could be a one-line lambda functions.
 # e.g., krond = lambda a, b: 1 if a == b else 0
 def krond(a, b) -> int:
@@ -125,3 +145,158 @@ def parseDobs(dobs):
         tobs.append(ls[2])
 
     return np.array(yobs, dtype=np.int32), np.array(mobs, dtype=np.int32), np.array(tobs, dtype=np.int32)
+
+
+def is_row_active(row):
+    """
+    Check if a DataFrame row should be processed based on 'active' column.
+
+    This function handles the common pattern of checking whether a row in a DataFrame
+    should be processed based on its 'active' column value. The logic is:
+    - If 'active' column doesn't exist, the row is considered active (default behavior)
+    - If 'active' value is NaN or None, the row is considered active (default behavior)
+    - If 'active' value is explicitly False (or falsy), the row is considered inactive
+    - Otherwise (True or truthy), the row is considered active
+
+    Parameters
+    ----------
+    row : pd.Series
+        A pandas Series representing a row from a DataFrame. The row should have
+        an 'active' column (or index entry) if the active/inactive status is to be checked.
+
+    Returns
+    -------
+    bool
+        True if the row should be processed (is active), False if it should be skipped (is inactive).
+    """
+    if "active" not in row.index:
+        return True  # Default to active if column doesn't exist
+    active_value = row["active"]
+    if pd.isna(active_value) or active_value is None:
+        return True  # NaN/None means active
+    return bool(active_value)
+
+
+def is_dataframe_empty(df):
+    """
+    Check if a DataFrame is None or empty.
+
+    This function consolidates the common pattern of checking
+    `df is None or df.empty` throughout the codebase.
+
+    Parameters
+    ----------
+    df : pd.DataFrame or None
+        The DataFrame to check. Can be None or an empty DataFrame.
+
+    Returns
+    -------
+    bool
+        True if df is None or empty, False otherwise.
+    """
+    return df is None or df.empty
+
+
+def ensure_dataframe(df, default_empty=None):
+    """
+    Ensure DataFrame is not None or empty, return default if needed.
+
+    This function checks if a DataFrame is None or empty and returns a default
+    value if so. This consolidates the common pattern of checking
+    `df is None or df.empty` throughout the codebase.
+
+    Parameters
+    ----------
+    df : pd.DataFrame or None
+        The DataFrame to check. Can be None or an empty DataFrame.
+    default_empty : any, optional
+        The value to return if df is None or empty. Default is None.
+        Common values are 0.0, np.zeros(N_n), or a default DataFrame.
+
+    Returns
+    -------
+    any
+        Returns default_empty if df is None or empty, otherwise returns df.
+    """
+    if is_dataframe_empty(df):
+        return default_empty
+    return df
+
+
+def get_empty_array_or_value(N_n, default_value=0.0):
+    """
+    Return empty array or single value based on context.
+
+    This helper function returns either a numpy array of zeros with length N_n
+    if N_n is provided, or a single default value if N_n is None.
+
+    Parameters
+    ----------
+    N_n : int or None
+        Length of the array to create. If None, returns default_value instead.
+    default_value : float, optional
+        Default value to return if N_n is None. Default is 0.0.
+
+    Returns
+    -------
+    np.ndarray or float
+        Returns np.zeros(N_n) if N_n is not None, otherwise returns default_value.
+    """
+    if N_n is not None:
+        return np.zeros(N_n)
+    return default_value
+
+
+def convert_to_bool(val):
+    """
+    Convert various input types to boolean.
+
+    Handles conversion from strings, numbers, booleans, and NaN values.
+    Excel may read booleans as strings ("True"/"False") or numbers (1/0),
+    so this function provides robust conversion.
+
+    Parameters
+    ----------
+    val : any
+        Value to convert to boolean. Can be:
+        - bool: returned as-is
+        - str: "True", "False", "1", "0", "yes", "no", etc.
+        - numeric: 1/0 or other numeric values
+        - None/NaN: defaults to True
+
+    Returns
+    -------
+    bool
+        Boolean value. NaN/None and unknown values default to True.
+    """
+    # Check for None first (before pd.isna which can fail on some types)
+    if val is None:
+        return True  # Default to True for None
+
+    # Check for NaN, but handle cases where pd.isna might fail (e.g., empty lists)
+    try:
+        if pd.isna(val):
+            return True  # Default to True for NaN
+    except (ValueError, TypeError):
+        # pd.isna can raise ValueError for empty arrays/lists
+        # or TypeError for unhashable types - treat as non-NaN and continue
+        pass
+    if isinstance(val, bool):
+        return val
+    if isinstance(val, str):
+        # Handle string representations
+        val_lower = val.lower().strip()
+        if val_lower in ("true", "1", "yes", "y"):
+            return True
+        elif val_lower in ("false", "0", "no", "n"):
+            return False
+        else:
+            # Unknown string, default to True
+            return True
+    # Handle numeric values (1/0)
+    try:
+        num_val = float(val)
+        return bool(num_val) if num_val != 0 else False
+    except (ValueError, TypeError):
+        # Can't convert, default to True
+        return True

owlplanner/version.py

@@ -1 +1,20 @@
-__version__ = "2025.12.20"
+"""
+Package version information.
+
+Copyright (C) 2025-2026 The Owlplanner Authors
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU General Public License as published by
+the Free Software Foundation, either version 3 of the License, or
+(at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU General Public License for more details.
+
+You should have received a copy of the GNU General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>.
+"""
+
+__version__ = "2026.01.26"

{owlplanner-2025.12.20.dist-info → owlplanner-2026.1.26.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: owlplanner
-Version: 2025.12.20
+Version: 2026.1.26
 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
@@ -683,6 +683,7 @@ License:                     GNU GENERAL PUBLIC LICENSE
         the library.  If this is what you want to do, use the GNU Lesser General
         Public License instead of this License.  But first, please read
         <https://www.gnu.org/licenses/why-not-lgpl.html>.
+License-File: AUTHORS
 License-File: LICENSE
 Classifier: Development Status :: 5 - Production/Stable
 Classifier: Intended Audience :: End Users/Desktop
@@ -691,8 +692,10 @@ Classifier: Operating System :: OS Independent
 Classifier: Programming Language :: Python :: 3
 Classifier: Topic :: Office/Business :: Financial :: Investment
 Requires-Python: >=3.10
+Requires-Dist: click>=8.3.1
 Requires-Dist: highspy
 Requires-Dist: jupyter>=1.1.1
+Requires-Dist: loguru>=0.7.3
 Requires-Dist: matplotlib
 Requires-Dist: numpy
 Requires-Dist: odfpy
@@ -712,7 +715,7 @@ Description-Content-Type: text/markdown
 
 ## A retirement exploration tool based on linear programming
 
-<img align=right src="https://github.com/mdlacasse/Owl/blob/main/docs/images/owl.png?raw=true" width="250">
+<img align="right" src="papers/images/owl.png" width="250">
 
 -------------------------------------------------------------------------------------
 
@@ -724,6 +727,10 @@ 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.
 
+Owl is designed for US retirees as it considers US federal tax laws,
+Medicare premiums, rules for 401k including required minimum distributions,
+maturation rules for Roth accounts and conversions, social security rules, etc.
+
 There are three ways to run Owl:
 
 - **Streamlit Hub:** Run Owl remotely as hosted on the Streamlit Community Server at
@@ -763,6 +770,7 @@ Follow these [instructions](INSTALL.md) to install from the source code and self
 It can also run on [MOSEK](https://mosek.com) if available on your computer.
 - Owl planner relies on the following [Python](https://python.org) packages:
     - [highspy](https://highs.dev),
+    [loguru](https://github.com/Delgan/loguru),
     [Matplotlib](https://matplotlib.org),
     [Numpy](https://numpy.org),
     [odfpy](https://https://pypi.org/project/odfpy),

owlplanner-2026.1.26.dist-info/RECORD

@@ -0,0 +1,36 @@
+"owlplanner/In Discussion #58, the case of Kim and Sam.md",sha256=ah5BgkP4Bo04SZ2-Ory8PBeoFRVd7YNUBktYtjp42v0,25193
+owlplanner/__init__.py,sha256=X9u8PrfeTyfjuksYhx0eNrIACgX5Tg3Le7pz8qKkJXk,1341
+owlplanner/abcapi.py,sha256=5yWuiu5eBVO46V5vklO_zfCCrFZX9guRZ9XEemeJ878,7229
+owlplanner/config.py,sha256=-q6TYMagUJGv1ige6VvWPFtZ5ZWkT9Yh-HQrnnWDHfU,19834
+owlplanner/debts.py,sha256=c-eLynjOFryYisae51Po6Iuh46_d_AGOUbOz3z96ZJY,9850
+owlplanner/fixedassets.py,sha256=ItFeXjIdhMVNyXY0xBW6P9ODRajVg1kDRaid9-Eu_Ww,11510
+owlplanner/mylogging.py,sha256=amQA0qWPsXMoJkYYF3nMaVtCDZMWxXJ1hbJS0TkMvf8,8269
+owlplanner/plan.py,sha256=VWrKDGl3UgNB6GQzfw7hQzVNJW_BcupH0I2zP9yKtsw,152509
+owlplanner/progress.py,sha256=ayqoRUMn6dtIxHDYaeX1mu7W2rAhkBYAi4Y2Y_NtdYA,2521
+owlplanner/rates.py,sha256=W-cXEbJl7L9cPEhQbtz4bf_JAkChoCfDSFoZHDUZeys,14393
+owlplanner/socialsecurity.py,sha256=4vn76dUZ2P2fMKyy4eu2ramGNvPQymKzsNFZvwbFWOc,7595
+owlplanner/tax2026.py,sha256=-aHOVv5pErXY82PK5dQBjqoAqYc74w4C5zqGODboUBw,15659
+owlplanner/timelists.py,sha256=4dBZVCgNIx0RwUfimp_k-m9KhRFj6BHX8Hon1vb8oo8,15032
+owlplanner/utils.py,sha256=l2-3HmZutFlEfJUp7gFblY3PBNYm7HiPPCGl0wFkVmA,9461
+owlplanner/version.py,sha256=ah-vzrsjzBTIMnscgEdl8z7Y1yu4uXQ5B3og10cS2y4,747
+owlplanner/cli/README.md,sha256=R-jwwiX5ZW6gCKaRPWVCgwKVoN2MKozrLAkKvfUT4vA,2292
+owlplanner/cli/_main.py,sha256=qAy_2oCLaa_EhvfGFnuh_sVXkCcgp70WMSL7_QKH5XI,1497
+owlplanner/cli/cli_logging.py,sha256=CTBaAMpJIG7ge9Gz44YykBiea3hMxdAXHyiLj1UyvDU,1690
+owlplanner/cli/cmd_list.py,sha256=lOpS_5LGR1IpJLOaHQOrwm1EtbGwv0tfIcZZ8QObmMM,2584
+owlplanner/cli/cmd_run.py,sha256=aLy-X6x_3MSO_yBQ1R4MWKzczfQgWuRQUsNTrVUaWj8,3009
+owlplanner/data/__init__.py,sha256=jpbWHd9n4F06pyfQj1kI3HQ3uiWXfZCjb5BYINOr9_M,850
+owlplanner/data/awi.csv,sha256=w9YwPEqhxqo1Czumh3ihLXLPtk8kJQgqWKClMysOq-c,1625
+owlplanner/data/bendpoints.csv,sha256=h0a7_XqTuyHWe5ZlS3mjIcAWqOMG_93GoiETS-1xxUY,746
+owlplanner/data/newawi.csv,sha256=w9YwPEqhxqo1Czumh3ihLXLPtk8kJQgqWKClMysOq-c,1625
+owlplanner/data/rates.csv,sha256=6Pr5cXFunZKRzB32--kWzhuRnTQMNFfZaww0QF1SIag,3898
+owlplanner/plotting/__init__.py,sha256=UrKO_zHTxZ-Wb2sQbyk2vNHe20Owzt6M1KJ2M6Z5GGw,944
+owlplanner/plotting/base.py,sha256=70-J5AWnHtWqrehVhCNojnTdfNT6PnEpxBKzDh3R57o,3298
+owlplanner/plotting/factory.py,sha256=sVZ0uAuGKBVVh1qkF2IS7xNZGUPIQRIfqgUt2s2Ncjk,1694
+owlplanner/plotting/matplotlib_backend.py,sha256=AILNOhXi_gsR__i1hKoHaEHvMUqQMyLeRAGCoCBfQBY,19222
+owlplanner/plotting/plotly_backend.py,sha256=OqMJRxAhpwIbKSV-Od1-q-tzOs66McZPbKD32be2qx0,34523
+owlplanner-2026.1.26.dist-info/METADATA,sha256=ZHGDl0MzxLspxcYtBCoxp8q1oQKnEZ1qH_gjzInxw1Q,46494
+owlplanner-2026.1.26.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+owlplanner-2026.1.26.dist-info/entry_points.txt,sha256=m2Ql-6VQbotl65wiqx35d3TIh-Tm6Wdjrz3hNdqZKKg,52
+owlplanner-2026.1.26.dist-info/licenses/AUTHORS,sha256=KD6uW6iEOHf51J8DEJ6az-gowFv3NWIpW4zRgqxwuAA,464
+owlplanner-2026.1.26.dist-info/licenses/LICENSE,sha256=IwGE9guuL-ryRPEKi6wFPI_zOhg7zDZbTYuHbSt_SAk,35823
+owlplanner-2026.1.26.dist-info/RECORD,,

owlplanner-2026.1.26.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+owlcli = owlplanner.cli._main:cli

owlplanner-2026.1.26.dist-info/licenses/AUTHORS

@@ -0,0 +1,15 @@
+# This is the list of Owlplanner's significant contributors.
+#
+# This does not necessarily list everyone who has contributed code.
+# To see the full list of contributors, see the revision history in
+# source control.
+Martin-D. Lacasse (mdlacasse, original author)
+Robert E. Anderson (NH-RedAnt)
+Clark Jefcoat (hubcity)
+kg333
+John Leonard (jleonard99)
+Benjamin Quinn (blquinn)
+Dale Seng (sengsational)
+Josh Williams (noimjosh)
+Gene Wood (gene1wood)
+

owlplanner/tax2025.py

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