fundedness 0.1.0__py3-none-any.whl

fundedness/withdrawals/rmd_style.py

@@ -0,0 +1,203 @@
+"""RMD-style withdrawal strategy."""
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from fundedness.withdrawals.base import (
+    BaseWithdrawalPolicy,
+    WithdrawalContext,
+    WithdrawalDecision,
+)
+
+
+# IRS Uniform Lifetime Table (2024)
+# Maps age to distribution period (divisor)
+RMD_TABLE = {
+    72: 27.4, 73: 26.5, 74: 25.5, 75: 24.6, 76: 23.7,
+    77: 22.9, 78: 22.0, 79: 21.1, 80: 20.2, 81: 19.4,
+    82: 18.5, 83: 17.7, 84: 16.8, 85: 16.0, 86: 15.2,
+    87: 14.4, 88: 13.7, 89: 12.9, 90: 12.2, 91: 11.5,
+    92: 10.8, 93: 10.1, 94: 9.5, 95: 8.9, 96: 8.4,
+    97: 7.8, 98: 7.3, 99: 6.8, 100: 6.4, 101: 6.0,
+    102: 5.6, 103: 5.2, 104: 4.9, 105: 4.6, 106: 4.3,
+    107: 4.1, 108: 3.9, 109: 3.7, 110: 3.5, 111: 3.4,
+    112: 3.3, 113: 3.1, 114: 3.0, 115: 2.9, 116: 2.8,
+    117: 2.7, 118: 2.5, 119: 2.3, 120: 2.0,
+}
+
+
+def get_rmd_divisor(age: int) -> float:
+    """Get RMD distribution period for given age.
+
+    Args:
+        age: Current age
+
+    Returns:
+        Distribution period (divisor)
+    """
+    if age < 72:
+        # Extrapolate backwards (not actual RMD, but useful for strategy)
+        return 27.4 + (72 - age) * 1.0  # Approximate slope
+    elif age > 120:
+        return 2.0
+    else:
+        return RMD_TABLE.get(age, 2.0)
+
+
+@dataclass
+class RMDStylePolicy(BaseWithdrawalPolicy):
+    """RMD-style withdrawal strategy.
+
+    Uses IRS Required Minimum Distribution table to determine withdrawals.
+    Withdrawal = Portfolio Value / Distribution Period
+
+    This approach automatically increases withdrawal rate as you age,
+    similar to how RMDs work for tax-deferred accounts.
+    """
+
+    starting_age: int = 65
+    multiplier: float = 1.0  # Scale factor (1.0 = exact RMD, 1.5 = 150% of RMD)
+    start_before_72: bool = True  # Apply RMD-style before actual RMD age
+
+    @property
+    def name(self) -> str:
+        mult_str = f" × {self.multiplier}" if self.multiplier != 1.0 else ""
+        return f"RMD-Style{mult_str}"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Withdraw based on IRS RMD table divisors. "
+            "Withdrawal rate automatically increases with age."
+        )
+
+    def get_initial_withdrawal(self, initial_wealth: float) -> float:
+        """Calculate first year withdrawal."""
+        divisor = get_rmd_divisor(self.starting_age)
+        return (initial_wealth / divisor) * self.multiplier
+
+    def calculate_withdrawal(self, context: WithdrawalContext) -> WithdrawalDecision:
+        """Calculate RMD-style withdrawal.
+
+        Args:
+            context: Current state including age or year
+
+        Returns:
+            WithdrawalDecision based on RMD table
+        """
+        # Determine current age
+        if context.age is not None:
+            current_age = context.age
+        else:
+            current_age = self.starting_age + context.year
+
+        # Get divisor
+        divisor = get_rmd_divisor(current_age)
+
+        # Calculate withdrawal
+        if isinstance(context.current_wealth, np.ndarray):
+            amount = (context.current_wealth / divisor) * self.multiplier
+        else:
+            amount = (context.current_wealth / divisor) * self.multiplier
+
+        # Apply guardrails
+        amount, is_floor_breach, is_ceiling_hit = self.apply_guardrails(
+            amount, context.current_wealth
+        )
+
+        withdrawal_rate = 1 / divisor * self.multiplier
+
+        return WithdrawalDecision(
+            amount=amount,
+            is_floor_breach=is_floor_breach,
+            is_ceiling_hit=is_ceiling_hit,
+            notes=f"Age {current_age}, divisor: {divisor:.1f}, rate: {withdrawal_rate:.2%}",
+        )
+
+
+@dataclass
+class AmortizationPolicy(BaseWithdrawalPolicy):
+    """Amortization-based withdrawal strategy.
+
+    Treats the portfolio like a mortgage in reverse - calculates the level
+    payment that would exhaust the portfolio over the planning horizon
+    given expected returns.
+    """
+
+    starting_age: int = 65
+    planning_age: int = 95  # Age to plan to
+    expected_return: float = 0.04  # Expected real return
+    recalculate_annually: bool = True  # Recalculate each year
+
+    @property
+    def name(self) -> str:
+        return "Amortization"
+
+    @property
+    def description(self) -> str:
+        return (
+            f"Calculate level payment to exhaust portfolio by age {self.planning_age} "
+            f"assuming {self.expected_return:.1%} real return."
+        )
+
+    def _calculate_pmt(self, wealth: float, years_remaining: int) -> float:
+        """Calculate amortization payment.
+
+        PMT = PV * r / (1 - (1+r)^-n)
+        """
+        if years_remaining <= 0:
+            return wealth  # Spend it all
+
+        r = self.expected_return
+        n = years_remaining
+
+        if r == 0:
+            return wealth / n
+
+        # Standard amortization formula
+        pmt = wealth * r / (1 - (1 + r) ** (-n))
+        return pmt
+
+    def get_initial_withdrawal(self, initial_wealth: float) -> float:
+        """Calculate first year withdrawal."""
+        years = self.planning_age - self.starting_age
+        return self._calculate_pmt(initial_wealth, years)
+
+    def calculate_withdrawal(self, context: WithdrawalContext) -> WithdrawalDecision:
+        """Calculate amortization-based withdrawal.
+
+        Args:
+            context: Current state
+
+        Returns:
+            WithdrawalDecision based on amortization formula
+        """
+        # Determine current age and years remaining
+        if context.age is not None:
+            current_age = context.age
+        else:
+            current_age = self.starting_age + context.year
+
+        years_remaining = max(1, self.planning_age - current_age)
+
+        # Calculate payment
+        if isinstance(context.current_wealth, np.ndarray):
+            amount = np.array([
+                self._calculate_pmt(w, years_remaining)
+                for w in context.current_wealth
+            ])
+        else:
+            amount = self._calculate_pmt(context.current_wealth, years_remaining)
+
+        # Apply guardrails
+        amount, is_floor_breach, is_ceiling_hit = self.apply_guardrails(
+            amount, context.current_wealth
+        )
+
+        return WithdrawalDecision(
+            amount=amount,
+            is_floor_breach=is_floor_breach,
+            is_ceiling_hit=is_ceiling_hit,
+            notes=f"Years remaining: {years_remaining}",
+        )

fundedness/withdrawals/vpw.py

@@ -0,0 +1,136 @@
+"""Variable Percentage Withdrawal (VPW) strategy."""
+
+from dataclasses import dataclass
+
+import numpy as np
+
+from fundedness.withdrawals.base import (
+    BaseWithdrawalPolicy,
+    WithdrawalContext,
+    WithdrawalDecision,
+)
+
+
+# VPW percentage table based on age and asset allocation
+# Source: Bogleheads VPW methodology
+# These are the percentages of portfolio to withdraw at each age
+VPW_TABLE = {
+    # Age: {stock_pct: withdrawal_pct}
+    # Simplified table - in practice would interpolate
+    60: {0: 0.037, 25: 0.039, 50: 0.042, 75: 0.046, 100: 0.051},
+    65: {0: 0.041, 25: 0.044, 50: 0.047, 75: 0.052, 100: 0.058},
+    70: {0: 0.047, 25: 0.050, 50: 0.054, 75: 0.060, 100: 0.068},
+    75: {0: 0.054, 25: 0.058, 50: 0.064, 75: 0.071, 100: 0.081},
+    80: {0: 0.064, 25: 0.069, 50: 0.076, 75: 0.086, 100: 0.099},
+    85: {0: 0.078, 25: 0.084, 50: 0.093, 75: 0.106, 100: 0.124},
+    90: {0: 0.097, 25: 0.106, 50: 0.118, 75: 0.135, 100: 0.160},
+    95: {0: 0.127, 25: 0.139, 50: 0.156, 75: 0.180, 100: 0.214},
+}
+
+
+def get_vpw_rate(age: int, stock_allocation: int = 50) -> float:
+    """Get VPW withdrawal rate for given age and allocation.
+
+    Args:
+        age: Current age
+        stock_allocation: Stock allocation as integer percentage (0-100)
+
+    Returns:
+        Withdrawal rate as decimal
+    """
+    # Find bracketing ages
+    ages = sorted(VPW_TABLE.keys())
+
+    if age <= ages[0]:
+        age_key = ages[0]
+    elif age >= ages[-1]:
+        age_key = ages[-1]
+    else:
+        # Find closest age
+        age_key = min(ages, key=lambda x: abs(x - age))
+
+    # Find closest allocation
+    allocations = sorted(VPW_TABLE[age_key].keys())
+    if stock_allocation <= allocations[0]:
+        alloc_key = allocations[0]
+    elif stock_allocation >= allocations[-1]:
+        alloc_key = allocations[-1]
+    else:
+        alloc_key = min(allocations, key=lambda x: abs(x - stock_allocation))
+
+    return VPW_TABLE[age_key][alloc_key]
+
+
+@dataclass
+class VPWPolicy(BaseWithdrawalPolicy):
+    """Variable Percentage Withdrawal (VPW) strategy.
+
+    Withdrawal rate varies based on age and remaining life expectancy.
+    Uses actuarial tables to determine appropriate withdrawal percentage.
+    """
+
+    starting_age: int = 65
+    stock_allocation: int = 50  # As integer percentage
+    smoothing_factor: float = 0.0  # 0 = pure VPW, 1 = fully smoothed
+
+    @property
+    def name(self) -> str:
+        return "VPW"
+
+    @property
+    def description(self) -> str:
+        return (
+            "Variable Percentage Withdrawal based on age and life expectancy. "
+            "Withdrawal rate increases as you age."
+        )
+
+    def get_initial_withdrawal(self, initial_wealth: float) -> float:
+        """Calculate first year withdrawal."""
+        rate = get_vpw_rate(self.starting_age, self.stock_allocation)
+        return initial_wealth * rate
+
+    def calculate_withdrawal(self, context: WithdrawalContext) -> WithdrawalDecision:
+        """Calculate VPW withdrawal.
+
+        Args:
+            context: Current state including age or year
+
+        Returns:
+            WithdrawalDecision based on VPW table
+        """
+        # Determine current age
+        if context.age is not None:
+            current_age = context.age
+        else:
+            current_age = self.starting_age + context.year
+
+        # Get VPW rate for current age
+        vpw_rate = get_vpw_rate(current_age, self.stock_allocation)
+
+        # Calculate base withdrawal
+        if isinstance(context.current_wealth, np.ndarray):
+            base_amount = context.current_wealth * vpw_rate
+        else:
+            base_amount = context.current_wealth * vpw_rate
+
+        # Apply smoothing if requested
+        if self.smoothing_factor > 0 and context.previous_spending is not None:
+            smoothed = (
+                self.smoothing_factor * context.previous_spending
+                + (1 - self.smoothing_factor) * base_amount
+            )
+            amount = smoothed
+        else:
+            amount = base_amount
+
+        # Apply guardrails
+        amount, is_floor_breach, is_ceiling_hit = self.apply_guardrails(
+            amount, context.current_wealth
+        )
+
+        return WithdrawalDecision(
+            amount=amount,
+            is_floor_breach=is_floor_breach,
+            is_ceiling_hit=is_ceiling_hit,
+            notes=f"Age {current_age}, VPW rate: {vpw_rate:.2%}",
+        )

fundedness-0.1.0.dist-info/METADATA

@@ -0,0 +1,233 @@
+Metadata-Version: 2.4
+Name: fundedness
+Version: 0.1.0
+Summary: A Python financial planning toolkit with CEFR calculations, Monte Carlo simulations, and beautiful visualizations
+Project-URL: Homepage, https://github.com/engineerinvestor/financial-health-calculator
+Project-URL: Documentation, https://engineerinvestor.github.io/financial-health-calculator/
+Project-URL: Repository, https://github.com/engineerinvestor/financial-health-calculator
+Author-email: Engineer Investor <egr.investor@gmail.com>
+License-Expression: MIT
+Keywords: CEFR,Monte Carlo,finance,planning,retirement,withdrawal
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: End Users/Desktop
+Classifier: Intended Audience :: Financial and Insurance Industry
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Topic :: Office/Business :: Financial :: Investment
+Requires-Python: >=3.10
+Requires-Dist: numpy>=1.24.0
+Requires-Dist: pandas>=2.0.0
+Requires-Dist: plotly>=5.18.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: scipy>=1.11.0
+Provides-Extra: all
+Requires-Dist: fastapi>=0.108.0; extra == 'all'
+Requires-Dist: hypothesis>=6.92.0; extra == 'all'
+Requires-Dist: mkdocs-material>=9.5.0; extra == 'all'
+Requires-Dist: mkdocs>=1.5.0; extra == 'all'
+Requires-Dist: mkdocstrings[python]>=0.24.0; extra == 'all'
+Requires-Dist: mypy>=1.8.0; extra == 'all'
+Requires-Dist: pytest-cov>=4.1.0; extra == 'all'
+Requires-Dist: pytest>=7.4.0; extra == 'all'
+Requires-Dist: ruff>=0.1.9; extra == 'all'
+Requires-Dist: streamlit>=1.29.0; extra == 'all'
+Requires-Dist: uvicorn[standard]>=0.25.0; extra == 'all'
+Provides-Extra: api
+Requires-Dist: fastapi>=0.108.0; extra == 'api'
+Requires-Dist: uvicorn[standard]>=0.25.0; extra == 'api'
+Provides-Extra: dev
+Requires-Dist: hypothesis>=6.92.0; extra == 'dev'
+Requires-Dist: mypy>=1.8.0; extra == 'dev'
+Requires-Dist: pytest-cov>=4.1.0; extra == 'dev'
+Requires-Dist: pytest>=7.4.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.9; extra == 'dev'
+Provides-Extra: docs
+Requires-Dist: mkdocs-material>=9.5.0; extra == 'docs'
+Requires-Dist: mkdocs>=1.5.0; extra == 'docs'
+Requires-Dist: mkdocstrings[python]>=0.24.0; extra == 'docs'
+Provides-Extra: streamlit
+Requires-Dist: streamlit>=1.29.0; extra == 'streamlit'
+Description-Content-Type: text/markdown
+
+# Financial Health Calculator
+
+A comprehensive Python financial planning toolkit with CEFR calculations, Monte Carlo simulations, and beautiful Plotly visualizations.
+
+[![Open In Colab](https://colab.research.google.com/assets/colab-badge.svg)](https://colab.research.google.com/github/engineerinvestor/financial-health-calculator/blob/main/examples/01_cefr_basics.ipynb)
+
+## Features
+
+- **CEFR (Certainty-Equivalent Funded Ratio)**: A fundedness metric that accounts for taxes, liquidity, and concentration risk
+- **Monte Carlo Simulations**: Project retirement outcomes with configurable market assumptions
+- **Withdrawal Strategy Lab**: Compare strategies including fixed SWR, guardrails, VPW, and RMD-style
+- **Beautiful Visualizations**: Interactive Plotly charts with fan charts, waterfalls, and survival curves
+- **REST API**: FastAPI backend for programmatic access
+- **Streamlit App**: User-friendly web interface
+
+## Quick Start
+
+### Installation
+
+```bash
+pip install git+https://github.com/engineerinvestor/financial-health-calculator.git
+```
+
+For development with all extras:
+```bash
+pip install "git+https://github.com/engineerinvestor/financial-health-calculator.git#egg=fundedness[all]"
+```
+
+### Basic Usage
+
+```python
+from fundedness import Asset, BalanceSheet, Liability, compute_cefr
+from fundedness.models.assets import AccountType, LiquidityClass, ConcentrationLevel
+
+# Define your assets
+assets = [
+    Asset(
+        name="401(k)",
+        value=500_000,
+        account_type=AccountType.TAX_DEFERRED,
+        liquidity_class=LiquidityClass.RETIREMENT,
+        concentration_level=ConcentrationLevel.DIVERSIFIED,
+    ),
+    Asset(
+        name="Roth IRA",
+        value=200_000,
+        account_type=AccountType.TAX_EXEMPT,
+        liquidity_class=LiquidityClass.RETIREMENT,
+        concentration_level=ConcentrationLevel.DIVERSIFIED,
+    ),
+]
+
+# Define your spending
+liabilities = [
+    Liability(name="Living Expenses", annual_amount=50_000, is_essential=True),
+    Liability(name="Travel", annual_amount=20_000, is_essential=False),
+]
+
+# Calculate CEFR
+result = compute_cefr(
+    balance_sheet=BalanceSheet(assets=assets),
+    liabilities=liabilities,
+    planning_horizon=30,
+)
+
+print(f"CEFR: {result.cefr:.2f}")
+print(f"Funded: {result.is_funded}")
+print(result.get_interpretation())
+```
+
+## Tutorials
+
+- [CEFR Basics](https://colab.research.google.com/github/engineerinvestor/financial-health-calculator/blob/main/examples/01_cefr_basics.ipynb) - Introduction to the CEFR metric
+- [Time Distribution Analysis](https://colab.research.google.com/github/engineerinvestor/financial-health-calculator/blob/main/examples/02_time_distribution.ipynb) - Monte Carlo simulations
+- [Withdrawal Strategy Comparison](https://colab.research.google.com/github/engineerinvestor/financial-health-calculator/blob/main/examples/03_withdrawal_comparison.ipynb) - Compare different approaches
+
+## Running the Apps
+
+### Streamlit Web App
+
+```bash
+streamlit run streamlit_app/app.py
+```
+
+### FastAPI REST API
+
+```bash
+uvicorn api.main:app --reload
+```
+
+API documentation available at `http://localhost:8000/docs`
+
+## Key Concepts
+
+### CEFR (Certainty-Equivalent Funded Ratio)
+
+CEFR measures how well-funded your retirement is after accounting for:
+
+- **Tax Haircuts**: What you'll owe when withdrawing from different account types
+- **Liquidity Haircuts**: How easily you can access your assets
+- **Reliability Haircuts**: Risk from concentrated positions
+
+**Formula:**
+```
+CEFR = Σ(Asset × (1-τ) × λ × ρ) / PV(Liabilities)
+```
+
+Where τ = tax rate, λ = liquidity factor, ρ = reliability factor
+
+**Interpretation:**
+- CEFR ≥ 2.0: Excellent - Very well-funded
+- CEFR 1.5-2.0: Strong - Well-funded with margin
+- CEFR 1.0-1.5: Adequate - Fully funded
+- CEFR < 1.0: Underfunded - Action needed
+
+### Withdrawal Strategies
+
+| Strategy | Description | Best For |
+|----------|-------------|----------|
+| Fixed SWR | 4% of initial portfolio, adjusted for inflation | Predictability |
+| % of Portfolio | Fixed % of current value | Market adaptation |
+| Guardrails | Adjustable with floor/ceiling | Balance |
+| VPW | Age-based variable percentage | Maximizing spending |
+| RMD-Style | IRS distribution table based | Tax efficiency |
+
+## Development
+
+### Setup
+
+```bash
+git clone https://github.com/engineerinvestor/financial-health-calculator.git
+cd financial-health-calculator
+pip install -e ".[dev]"
+```
+
+### Running Tests
+
+```bash
+pytest
+```
+
+### Code Quality
+
+```bash
+ruff check .
+mypy fundedness
+```
+
+## Project Structure
+
+```
+financial-health-calculator/
+├── fundedness/           # Core Python package
+│   ├── models/           # Pydantic data models
+│   ├── viz/              # Plotly visualizations
+│   ├── withdrawals/      # Withdrawal strategies
+│   ├── allocation/       # Asset allocation strategies
+│   ├── cefr.py           # CEFR calculation
+│   ├── simulate.py       # Monte Carlo engine
+│   └── policies.py       # Spending/allocation policies
+├── api/                  # FastAPI REST API
+├── streamlit_app/        # Streamlit web application
+├── examples/             # Jupyter notebooks
+└── tests/                # pytest tests
+```
+
+## Contact
+
+- Twitter: [@egr_investor](https://x.com/egr_investor)
+- GitHub: [engineerinvestor](https://github.com/engineerinvestor)
+- Email: egr.investor@gmail.com
+
+## License
+
+MIT License
+
+## Disclaimer
+
+This tool is for educational purposes only and does not constitute financial advice. Consult a qualified financial advisor for personalized recommendations.

fundedness-0.1.0.dist-info/RECORD

@@ -0,0 +1,38 @@
+fundedness/__init__.py,sha256=P8LNYSUUlk4-8Wa34FlhCyA_echWenZvg1hk7ccdK58,735
+fundedness/cefr.py,sha256=hCImRrjz-DCPJsuF3HShDZK5tw1vslakh-DrNBHsh2k,7728
+fundedness/liabilities.py,sha256=uKvEV6JQnQdrd7b6VsCc2qf9S2DJdK0XhEX9qwca2Ws,6662
+fundedness/liquidity.py,sha256=ncZF70AfgoVoYZnozpA_CHemfaHmI4KKCe3vITp5ljM,1713
+fundedness/policies.py,sha256=pyIYz86Z3sMYAW2rNhPLnXQ3PQCDCa-oxf9NhWyawy8,5854
+fundedness/risk.py,sha256=Lpls6Q2wVq5SX4p9ZQwCtTM73AcqrGCm3hE2QcgKuq0,2750
+fundedness/simulate.py,sha256=JOZeFx6oyOY2nyzejMgwPKnbNvzQZfYdslN-CwnxfwM,13769
+fundedness/allocation/__init__.py,sha256=6cYoAK3xbC6WphbAQ33XtHILCOY59NfXebpDXNeND18,408
+fundedness/allocation/base.py,sha256=kDypu2t86fsn2DyL5an1fPjbPbQWNmqydz3axWUgjLI,763
+fundedness/allocation/constant.py,sha256=6QcUJ0aBQcJcRJtOMhs7uUu13wJtgcPU7ToQzQZhcgw,531
+fundedness/allocation/glidepath.py,sha256=-q6Jb5WpRuZjJ68akT5WgeRIx3QSIDtlNih0_Iz-_cc,3440
+fundedness/models/__init__.py,sha256=EyW6tGUI9T6QMbIfzsG3igqg5--DtZHSTAuMX6foOiA,874
+fundedness/models/assets.py,sha256=ZKgxl4YaqdRVfDErL9weRhh4St_azo8ruN4g15T3IsQ,5013
+fundedness/models/household.py,sha256=t64FjvO0uQJemddLtCPpK3NNYdZCXU6KjA1VZshaqEk,4671
+fundedness/models/liabilities.py,sha256=iqGl5RU841k1clGOwnFParUvxzCJclq2JzNJoNPywuo,3416
+fundedness/models/market.py,sha256=c3jskREsB7m_mjzuBwJ7oo6hlvLmR423t0JT8_a50eg,5551
+fundedness/models/simulation.py,sha256=0jtIJWISDL-TlKVjr6KxcRfAj5Mrbp-VNyA4Bu7IUfU,2224
+fundedness/models/tax.py,sha256=0XhoBNZqfRqF1_acakrkYgMS5L6Pknq-TloQQBrFw1U,3859
+fundedness/models/utility.py,sha256=0AoJdccTb2hKBrTz5LExm8SrSsaWhhBf7y2NNaUzWQ0,4678
+fundedness/viz/__init__.py,sha256=PRP4PtkBr8PlO4Rz3AUPjj6dKL6168_0ogM8qSqoi-Q,687
+fundedness/viz/colors.py,sha256=kbYyCLvLARoIAMztHjnJZDxMGF9-an5z4obORa6JFEU,3204
+fundedness/viz/comparison.py,sha256=DoQW6xr0r2ko55qyli4ue8ndj__opun97brbbHSnKVA,8530
+fundedness/viz/fan_chart.py,sha256=GqdrOKdW12K7Y8sFQJ853QbYG3ASxvEzfY9cC-EKK70,6102
+fundedness/viz/histogram.py,sha256=i56g330-S84WxUU8GGya40yNUQbnAI2D0vzUbFy51DI,6784
+fundedness/viz/survival.py,sha256=xtaAHkJ3jlTUCYnLrTvwWlOlfLao6NC5cRxT5XKWrxM,6515
+fundedness/viz/tornado.py,sha256=1dZzAfKTDCcyyfbDUBE39f44e6k48yviF8kTRee-pwQ,6684
+fundedness/viz/waterfall.py,sha256=6LD0SbZDUzJrA0Zh1Y1qDx0I4BM5ZN_f2eVCXNK5HRc,5586
+fundedness/withdrawals/__init__.py,sha256=v5wKqet3lNMr9UDMZC4d3UPOrRPbzQ6VvdP-ADAiBrg,646
+fundedness/withdrawals/base.py,sha256=WXBuo-tJtp4V2Ottp2PC2YtyK3mGVJ9Cgq21zGUWObg,3472
+fundedness/withdrawals/comparison.py,sha256=eiobGMHmeQpGnr0_HcY_EKrv5_Nu7EaVf5Y9DdDNAyg,7833
+fundedness/withdrawals/fixed_swr.py,sha256=jwbVZHJuVzaSfDCpo-Zp6wdJmI-RzHvg46s1PFxhfA4,3639
+fundedness/withdrawals/guardrails.py,sha256=rZKVojKbl9LLJLi9LlK1I2JXb537MN_AbZfn4hIU8is,5468
+fundedness/withdrawals/rmd_style.py,sha256=E5FfrUYxFJwULKxzxbtZFLoLspLzUUomTQRUWLGLDpg,6373
+fundedness/withdrawals/vpw.py,sha256=aajHLAkHfsxh33uGRgzv0ozVuZREG-EmARJgWOU6mis,4389
+fundedness-0.1.0.dist-info/METADATA,sha256=MLUiTj3UTO7RUaUhgbHk3ObQb173X44gpP6N9iK8tyM,8092
+fundedness-0.1.0.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+fundedness-0.1.0.dist-info/entry_points.txt,sha256=Oh-Hg08i044YHuSHViCdfoD8CenIGcKrVuUVysvN9sY,51
+fundedness-0.1.0.dist-info/RECORD,,

fundedness-0.1.0.dist-info/WHEEL

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

fundedness-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+fundedness = fundedness.cli:main