glidepath 0.2.0__py3-none-any.whl

glidepath/regions/uk/wrappers.py

@@ -0,0 +1,283 @@
+"""UK wrapper kinds and rules (roadmap 3.1, 9.2; planning §4.2, §5.1, §6).
+
+Implements the core :class:`~glidepath.core.WrapperRuleset` protocol for
+the UK wrapper kinds — workplace DC, SIPP, ISA, LISA, GIA and cash.
+Every figure — the pension tax-free lump-sum fraction, the ISA and LISA
+allowances, the LISA bonus rate — comes from the tax-year data files
+(§5.3); nothing is hardcoded here (guard-tested). The kind-to-rules
+*structure* (which kinds are pensions, which relief mechanics each may
+operate) is scheme mechanics, not policy figures:
+
+- Workplace DC schemes operate either relief mechanic: relief at source
+  or a net pay arrangement, per the employer's scheme.
+- A SIPP is a personal pension, so contributions get relief at source.
+- ISAs and LISAs attract no contribution relief; growth and withdrawals
+  are tax-free. The LISA's 25% government bonus is a contribution
+  bonus, not tax relief (it never extends tax bands), and its
+  contributions are age-windowed (18 to 50, pro-rated by whole months).
+- GIA and cash accounts are bare taxable accounts: paid from taxed
+  income, growth taxable as it arises (dividends and interest feed the
+  §6 savings/dividend layers), withdrawals themselves tax-free. A cash
+  savings account prices no platform or fund charges, so the cash kind
+  alone is exempt from the shipped default fee assumptions
+  (``bears_default_fees``); the shipped cash return default is
+  therefore the account's whole return.
+- Pension money in is tax-relieved, grows tax-free, and comes out as
+  taxable income after the tax-free lump-sum fraction (EET).
+
+Access follows the §4.1 gate convention: pension kinds are gated by the
+NMPA (via :class:`~glidepath.regions.uk.ages.UkAgeRules`, including the
+2028 step-up); LISAs by the charge-free access age of 60 — the engine
+never models a charged early withdrawal, so the 25% withdrawal charge
+ships as data but no draw ever bears it (planning §5.2 gates are
+errors, never silent draws); ISAs, GIAs and cash have no access age.
+Contribution caps: the ISA annual allowance is a per-person cap shared
+across all ISAs and LISAs through the ``uk.isa`` allowance group, and
+the LISA allowance is a sub-cap inside it (its own group); pension
+kinds have no per-kind cap here — the annual allowance is a
+cross-pension measure of pension input amounts and lands in roadmap
+3.3, the member relief limit with contribution schedules in 3.2.
+"""
+
+from dataclasses import dataclass
+from typing import TYPE_CHECKING, NoReturn
+
+from glidepath.core import (
+    ContributionCap,
+    ContributionTaxTreatment,
+    ContributionTerms,
+    GrowthTaxTreatment,
+    ReliefMechanic,
+    WithdrawalTaxTreatment,
+    WrapperKindId,
+    WrapperTaxTreatment,
+)
+from glidepath.regions.uk.ages import UkAgeRules
+from glidepath.regions.uk.loader import available_tax_years, load_tax_year
+from glidepath.regions.uk.years import TaxYearSeries, UkTaxYearError
+
+if TYPE_CHECKING:
+    from collections.abc import Mapping
+    from datetime import date
+
+    from glidepath.core import Money, Period
+    from glidepath.regions.uk.extension import FutureYearsExtension
+    from glidepath.regions.uk.schema import TaxYearFile
+
+WORKPLACE_DC_KIND = WrapperKindId("uk.workplace_dc")
+"""An employer-sponsored defined-contribution pension scheme."""
+
+SIPP_KIND = WrapperKindId("uk.sipp")
+"""A self-invested personal pension."""
+
+ISA_KIND = WrapperKindId("uk.isa")
+"""A (stocks-and-shares or cash) individual savings account."""
+
+LISA_KIND = WrapperKindId("uk.lisa")
+"""A lifetime ISA: bonus-bearing, age-windowed, gated until 60."""
+
+GIA_KIND = WrapperKindId("uk.gia")
+"""A general investment account: bare, taxable as growth arises."""
+
+CASH_KIND = WrapperKindId("uk.cash")
+"""A cash savings account outside any wrapper: interest is taxable."""
+
+ISA_ALLOWANCE_GROUP = "uk.isa"
+"""Allowance group of the overall ISA annual allowance (ISA + LISA)."""
+
+LISA_ALLOWANCE_GROUP = "uk.lisa"
+"""Allowance group of the LISA sub-allowance inside the overall one."""
+
+_PENSION_KINDS = frozenset({WORKPLACE_DC_KIND, SIPP_KIND})
+_TAX_FREE_SAVINGS_KINDS = frozenset({ISA_KIND, LISA_KIND})
+_TAXABLE_KINDS = frozenset({GIA_KIND, CASH_KIND})
+_ALL_KINDS = _PENSION_KINDS | _TAX_FREE_SAVINGS_KINDS | _TAXABLE_KINDS
+
+_RELIEF_MECHANICS: Mapping[WrapperKindId, frozenset[ReliefMechanic]] = {
+    WORKPLACE_DC_KIND: frozenset(
+        {ReliefMechanic.RELIEF_AT_SOURCE, ReliefMechanic.NET_PAY}
+    ),
+    SIPP_KIND: frozenset({ReliefMechanic.RELIEF_AT_SOURCE}),
+    ISA_KIND: frozenset(),
+    LISA_KIND: frozenset(),
+    GIA_KIND: frozenset(),
+    CASH_KIND: frozenset(),
+}
+
+
+class UkWrapperError(ValueError):
+    """A wrapper query the shipped UK data cannot answer."""
+
+
+def _unknown_kind(kind: WrapperKindId) -> NoReturn:
+    """Reject a wrapper kind the UK region does not define."""
+    msg = f"unknown UK wrapper kind {kind!r}"
+    raise UkWrapperError(msg)
+
+
+@dataclass(frozen=True, slots=True)
+class UkWrapperRuleset:
+    """UK implementation of the core ``WrapperRuleset`` protocol.
+
+    Holds the tax-year files its figures come from, plus the age rules
+    behind the pension access gate. Figure queries (``tax_treatment``,
+    ``annual_contribution_limit``) share the tax system's coverage
+    semantics: shipped data beats extrapolation, and the query's tax
+    year is always resolved — even when the answer needs no yearly
+    figure — so a query outside coverage fails loudly rather than
+    answering from the wrong year. Access gates read the effective-dated
+    age rules instead and carry no tax-year coverage constraint.
+    """
+
+    tax_years: tuple[TaxYearFile, ...]
+    ages: UkAgeRules
+    future_years: FutureYearsExtension | None = None
+
+    def __post_init__(self) -> None:
+        """Require at least one year, ascending and non-overlapping."""
+        try:
+            self._series()
+        except UkTaxYearError as exc:
+            raise UkWrapperError(str(exc)) from exc
+
+    @classmethod
+    def from_shipped_data(
+        cls, future_years: FutureYearsExtension | None = None
+    ) -> UkWrapperRuleset:
+        """Build a ruleset over every shipped data file."""
+        years = available_tax_years()
+        return cls(
+            tax_years=tuple(load_tax_year(year) for year in years),
+            ages=UkAgeRules.from_shipped_data(),
+            future_years=future_years,
+        )
+
+    def tax_treatment(self, kind: WrapperKindId, period: Period) -> WrapperTaxTreatment:
+        """The in/during/out treatment of ``kind`` during ``period`` (§4.2).
+
+        Pension kinds are EET with the year's tax-free lump-sum
+        fraction on the way out; ISAs and LISAs are TEE; GIA and cash
+        accounts are taxed as growth arises, with withdrawals
+        themselves tax-free (module docstring).
+        """
+        year = self._year_for(period)
+        if kind in _PENSION_KINDS:
+            return WrapperTaxTreatment(
+                contributions=ContributionTaxTreatment.TAX_RELIEVED,
+                growth=GrowthTaxTreatment.TAX_FREE,
+                withdrawals=WithdrawalTaxTreatment.PARTIALLY_TAX_FREE,
+                tax_free_fraction=year.pension.tax_free_lump_sum_fraction,
+            )
+        if kind in _TAX_FREE_SAVINGS_KINDS:
+            return WrapperTaxTreatment(
+                contributions=ContributionTaxTreatment.FROM_TAXED_INCOME,
+                growth=GrowthTaxTreatment.TAX_FREE,
+                withdrawals=WithdrawalTaxTreatment.TAX_FREE,
+            )
+        if kind in _TAXABLE_KINDS:
+            return WrapperTaxTreatment(
+                contributions=ContributionTaxTreatment.FROM_TAXED_INCOME,
+                growth=GrowthTaxTreatment.TAXABLE,
+                withdrawals=WithdrawalTaxTreatment.TAX_FREE,
+            )
+        _unknown_kind(kind)
+
+    def contribution_terms(
+        self, kind: WrapperKindId, date_of_birth: date, period: Period
+    ) -> ContributionTerms:
+        """The contribution terms of ``kind`` for one person and period.
+
+        The ISA annual allowance is per person per tax year, shared
+        across all their ISAs and LISAs through the ``uk.isa`` group;
+        the LISA allowance is a sub-cap inside it, and LISA
+        contributions carry the year's bonus rate within the exact
+        18-to-50 contribution window (planning §6) — the engine
+        intersects the window with the period and the run window and
+        pro-rates by whole months. Pension, GIA and cash kinds are
+        uncapped
+        here — the pension annual allowance is a cross-pension measure
+        of pension input amounts (roadmap 3.3), not a per-kind cap.
+        """
+        year = self._year_for(period)
+        if kind == ISA_KIND:
+            return ContributionTerms(
+                caps=(ContributionCap(ISA_ALLOWANCE_GROUP, year.isa.annual_allowance),)
+            )
+        if kind == LISA_KIND:
+            return ContributionTerms(
+                caps=(
+                    ContributionCap(LISA_ALLOWANCE_GROUP, year.isa.lisa_allowance),
+                    ContributionCap(ISA_ALLOWANCE_GROUP, year.isa.annual_allowance),
+                ),
+                bonus_rate=year.isa.lisa_bonus_rate,
+                window=self.ages.lisa_contribution_window(date_of_birth),
+            )
+        if kind in _PENSION_KINDS or kind in _TAXABLE_KINDS:
+            return ContributionTerms()
+        _unknown_kind(kind)
+
+    def permitted_relief_mechanics(
+        self, kind: WrapperKindId
+    ) -> frozenset[ReliefMechanic]:
+        """The relief mechanics ``kind`` may operate (module docstring)."""
+        mechanics = _RELIEF_MECHANICS.get(kind)
+        if mechanics is None:
+            _unknown_kind(kind)
+        return mechanics
+
+    def bears_default_fees(self, kind: WrapperKindId) -> bool:
+        """Whether ``kind`` bears the default platform/fund fees (§7).
+
+        Cash savings accounts price no platform or fund charges — the
+        rate on the account is the whole deal — so the cash kind is
+        exempt from the shipped fee defaults (issue #118); every other
+        UK kind is a platform-administered account those defaults
+        describe. Cash *held inside* another wrapper (a SIPP or ISA
+        cash slice) still bears that wrapper's fees.
+        """
+        if kind not in _ALL_KINDS:
+            _unknown_kind(kind)
+        return kind != CASH_KIND
+
+    def lump_sum_allowance(self, period: Period) -> Money | None:
+        """The year's lump sum allowance (planning §6; roadmap 5.2).
+
+        The per-person lifetime cap on pension tax-free cash — PCLS
+        and the tax-free elements of UFPLS payments. The engine tracks
+        usage across the run; this only answers the period's figure,
+        with the usual coverage semantics (class docstring).
+        """
+        return self._year_for(period).pension.lump_sum_allowance
+
+    def is_access_open(
+        self, kind: WrapperKindId, date_of_birth: date, period: Period
+    ) -> bool:
+        """Whether *new* access to ``kind`` may open in ``period``.
+
+        Pension kinds follow the NMPA access gate (§4.1), including the
+        2028 step-up; LISAs the charge-free access age of 60 (module
+        docstring); ISAs, GIAs and cash are always accessible. Only
+        *new* pension access (crystallisation, UFPLS) is gated — funds
+        already crystallised and benefits already in payment are never
+        re-gated (planning §5.1), so someone who crystallised at 55
+        before the 2028 step keeps drawing at 56 even while this gate
+        is shut.
+        """
+        if kind in _PENSION_KINDS:
+            return self.ages.is_pension_access_open(date_of_birth, period)
+        if kind == LISA_KIND:
+            return self.ages.is_lisa_access_open(date_of_birth, period)
+        if kind == ISA_KIND or kind in _TAXABLE_KINDS:
+            return True
+        _unknown_kind(kind)
+
+    def _series(self) -> TaxYearSeries:
+        """The shared year-resolution series over this ruleset's files."""
+        return TaxYearSeries(tax_years=self.tax_years, future_years=self.future_years)
+
+    def _year_for(self, period: Period) -> TaxYearFile:
+        """The shipped or synthesized file fully containing ``period``."""
+        try:
+            return self._series().year_for(period)
+        except UkTaxYearError as exc:
+            raise UkWrapperError(str(exc)) from exc

glidepath/regions/uk/years.py

@@ -0,0 +1,92 @@
+"""Tax-year data resolution shared by the UK rule implementations (§5.3).
+
+Both the tax system (roadmap 2.3) and the wrapper ruleset (roadmap 3.1)
+answer period queries from the same per-tax-year data files, with the
+same coverage semantics: shipped data always beats extrapolation, the
+future-years extension (roadmap 2.5) only reaches *past* the last
+shipped year, and a query outside coverage fails loudly. This module
+holds that resolution once; the consumers wrap
+:class:`UkTaxYearError` in their own error types.
+"""
+
+from dataclasses import dataclass
+from itertools import pairwise
+from typing import TYPE_CHECKING
+
+from glidepath.regions.uk.extension import extend_tax_year
+from glidepath.regions.uk.schema import tax_year_start_year
+
+if TYPE_CHECKING:
+    from datetime import date
+
+    from glidepath.core import Period
+    from glidepath.regions.uk.extension import FutureYearsExtension
+    from glidepath.regions.uk.schema import TaxYearFile
+
+
+class UkTaxYearError(ValueError):
+    """A query no shipped or synthesized tax-year data can answer."""
+
+
+@dataclass(frozen=True, slots=True)
+class TaxYearSeries:
+    """An ascending run of tax-year files plus an optional extension.
+
+    The single source of "which year's figures govern this period" for
+    every UK ruleset (planning §5.3).
+    """
+
+    tax_years: tuple[TaxYearFile, ...]
+    future_years: FutureYearsExtension | None = None
+
+    def __post_init__(self) -> None:
+        """Require at least one year, ascending and non-overlapping."""
+        if not self.tax_years:
+            msg = "at least one tax-year file is required"
+            raise UkTaxYearError(msg)
+        for previous, current in pairwise(self.tax_years):
+            if current.meta.start_date <= previous.meta.end_date:
+                msg = "tax-year files must be in ascending, non-overlapping order"
+                raise UkTaxYearError(msg)
+
+    def year_for(self, period: Period) -> TaxYearFile:
+        """The shipped or synthesized file fully containing ``period``.
+
+        Raises:
+            UkTaxYearError: If no file covers the period's start, or the
+                period extends beyond that file's tax year.
+        """
+        year = self.year_containing(period.start)
+        if period.end > year.meta.end_date:
+            msg = (
+                f"period {period.start}..{period.end} extends beyond"
+                f" tax year {year.meta.tax_year}"
+            )
+            raise UkTaxYearError(msg)
+        return year
+
+    def year_containing(self, day: date) -> TaxYearFile:
+        """The shipped file covering ``day``, or an extension past the last.
+
+        Raises:
+            UkTaxYearError: If ``day`` falls outside shipped coverage and
+                the extension cannot reach it.
+        """
+        for year in self.tax_years:
+            if year.meta.start_date <= day <= year.meta.end_date:
+                return year
+        last = self.tax_years[-1]
+        if self.future_years is not None and day > last.meta.end_date:
+            return extend_tax_year(
+                last,
+                tax_year_start_year(day),
+                policy=self.future_years.policy,
+                cpi=self.future_years.cpi,
+            )
+        problem = (
+            "the future-years extension only reaches past the last shipped year"
+            if self.future_years is not None
+            else "no future-years extension is configured (planning §5.3)"
+        )
+        msg = f"no shipped tax-year data covers {day}; {problem}"
+        raise UkTaxYearError(msg)

glidepath-0.2.0.dist-info/METADATA

@@ -0,0 +1,189 @@
+Metadata-Version: 2.4
+Name: glidepath
+Version: 0.2.0
+Summary: Desktop retirement and investment planner (UK-first, region-extensible).
+License-Expression: MIT AND CC-BY-NC-SA-4.0
+License-File: LICENSE
+License-File: LICENSE-DATA
+Requires-Dist: pyside6>=6.11.1
+Requires-Python: >=3.14
+Description-Content-Type: text/markdown
+
+<p align="center">
+  <img src="src/glidepath/gui/assets/wordmark.png" alt="glidepath" width="420">
+</p>
+
+[![CI](https://github.com/williajm/glidepath/actions/workflows/ci.yml/badge.svg?branch=main)](https://github.com/williajm/glidepath/actions/workflows/ci.yml)
+[![Quality Gate](https://sonarcloud.io/api/project_badges/measure?project=williajm_glidepath&metric=alert_status)](https://sonarcloud.io/summary/new_code?id=williajm_glidepath)
+[![Coverage](https://sonarcloud.io/api/project_badges/measure?project=williajm_glidepath&metric=coverage)](https://sonarcloud.io/summary/new_code?id=williajm_glidepath)
+[![Python 3.14](https://img.shields.io/badge/python-3.14-blue)](https://github.com/williajm/glidepath/blob/main/.python-version)
+[![uv](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/uv/main/assets/badge/v0.json)](https://github.com/astral-sh/uv)
+[![Ruff](https://img.shields.io/endpoint?url=https://raw.githubusercontent.com/astral-sh/ruff/main/assets/badge/v2.json)](https://github.com/astral-sh/ruff)
+[![Checked with mypy](https://www.mypy-lang.org/static/mypy_badge.svg)](https://mypy-lang.org/)
+[![License: MIT](https://img.shields.io/github/license/williajm/glidepath)](LICENSE)
+
+<p align="center">
+  <a href="https://williajm.github.io/glidepath/"><b>williajm.github.io/glidepath</b></a>
+</p>
+
+A desktop retirement and investment planner. UK-first, built so other
+regions can be added later. Every number in a plan is a **fact** you
+stated, a **decision** you made, or an **assumption** the app defaulted
+— always inspectable, never silently guessed. All data stays local;
+nothing is transmitted.
+
+<p align="center">
+  <img src="docs/screenshots/charts.png"
+       alt="The charts tab: the Monte Carlo fan chart — nested percentile bands deepening toward the median line — beside the success-rate readout and the retirement-age and backtest cards"
+       width="800">
+</p>
+
+*(All screenshots show example data, not anyone's real finances.)*
+
+What it models today (single person, UK):
+
+- **Wrappers** — workplace DC, SIPP, S&S ISA, LISA, GIA and cash, with
+  UK contribution relief mechanics and dividend/savings taxation.
+- **Defined benefit pensions** — deferred entitlements or active
+  CARE-style accrual, with revaluation, early/late factors and
+  commutation; **state pension** from your official DWP forecast,
+  including deferral.
+- **Tax** — rUK and Scottish income tax from verified 2026/27 data
+  files; pension allowances (AA/taper/MPAA, lump-sum allowance).
+- **Projection** — deterministic or Monte Carlo runs from the app:
+  success rate, probability of ruin, ending-pot percentiles, and a
+  probability fan chart on its own tab, reproducible from a seed. With
+  a de-risking glide path, tax-aware decumulation with optional
+  go-go/slow-go/no-go retirement spending multipliers, and annuity
+  purchases entered in the facts form. (The engine also models
+  alternative withdrawal strategies — fixed %, guardrails, natural
+  yield — and tax-free-cash strategies; the app currently runs the
+  fixed-real defaults, with no strategy picker in the UI yet.)
+- **"When can I retire?"** — a solver for the earliest retirement age
+  that sustains a target income (a replacement rate you choose, 66% of
+  employment income by default), met deterministically or at a Monte
+  Carlo success target.
+- **Historical backtesting** — replays the plan over every rolling
+  window of world market history since 1900 (global equities in
+  sterling terms, UK gilts and cash, deflated by UK inflation):
+  the share of historical starting years the plan survives, the worst
+  starting year, and the range of outcomes as chart bands —
+  sequence-of-returns risk that independent Monte Carlo draws miss.
+- **Scenarios** — named what-ifs over your decisions and assumptions,
+  with a side-by-side comparison; plans saved as a local JSON file.
+
+## More screenshots
+
+Facts entry — everything on this screen is either a fact you state or
+a choice you make; anything estimated lives in the assumptions
+inspector instead:
+
+<p align="center">
+  <img src="docs/screenshots/facts.png"
+       alt="The facts tab: the About you, Household spending, and State pension cards of the entry form, with the example plan's values filled in"
+       width="800">
+</p>
+
+Stated vs assumed — the provenance view: the facts you stated, the
+choices in effect, and every assumption the run used with its value,
+default/overridden status, source, and date:
+
+<p align="center">
+  <img src="docs/screenshots/stated_vs_assumed.png"
+       alt="The stated-vs-assumed tab: tables of stated facts, choices in effect, assumptions used with sources, and the plan structure"
+       width="800">
+</p>
+
+## Disclaimer
+
+Glidepath is a personal modelling tool for exploring retirement scenarios.
+It is not financial advice and is not regulated; its outputs depend on
+assumptions that will not match reality. Do not make financial decisions
+based solely on this tool.
+
+## Run
+
+Requires only [uv](https://docs.astral.sh/uv/). Install the latest
+release [from PyPI](https://pypi.org/project/glidepath/) and launch it:
+
+```sh
+uv tool install glidepath
+glidepath
+```
+
+(`pipx install glidepath` works too. Glidepath is a desktop app
+distributed through PyPI, not a library — importing `glidepath`
+modules is not a supported API.)
+
+Or run straight from a checkout:
+
+```sh
+git clone https://github.com/williajm/glidepath.git
+cd glidepath
+uv run glidepath
+```
+
+The first run from a checkout creates a virtual environment and
+installs the locked dependencies automatically, then launches the
+desktop app. Accept the
+disclaimer and a fresh install
+opens with an example plan already projected, so every tab has
+something to show — replace its values with your own facts, or clear
+the form and start blank. Charts label each bar with the tax year and
+your age and switch between today's money and nominal; Help → "How to
+use glidepath" walks through every tab. Save your plan from the File
+menu as a `.glidepath.json` file you own, stored wherever you choose;
+the next launch reopens your last plan automatically.
+
+## Developing
+
+Development additionally requires GNU Make, which drives every workflow
+command:
+
+```sh
+make sync          # create the platform venv from the lockfile (fails if the lock has drifted)
+make hooks         # install the pre-commit hooks (required before committing)
+```
+
+One-time per machine: set `UV_PROJECT_ENVIRONMENT` user-wide (`.venv-win`
+on Windows, `.venv-wsl` in WSL) so bare `uv` commands and the git hooks use
+the same venv as make. See `CLAUDE.md`. (Skipping this only matters for a
+shared Windows/WSL checkout — for trying the app, uv's default `.venv` is
+fine.)
+
+## Everyday commands
+
+```sh
+make check   # all merge gates: ruff, format, mypy --strict, pytest (>=90% cov), dep age
+make fix     # auto-fix lint issues and reformat
+make test    # tests with coverage
+make deps    # the ONLY way to add/upgrade dependencies (7-day cooldown lock)
+make audit   # pip-audit the lockfile for known CVEs
+```
+
+Dependencies are never added with plain `uv add`/`uv lock`: run `make deps`
+so the 7-day supply-chain cooldown is applied. CI runs every `make check`
+gate plus `make audit` and the SonarCloud quality gate on each PR — so a
+clean `make check` locally does not quite guarantee a green pipeline. See
+`CLAUDE.md` for the full policies.
+
+## Releases
+
+Releases are `vX.Y.Z` tags on `main`; each GitHub Release carries its
+notes from [`CHANGELOG.md`](CHANGELOG.md). There are no packaged builds
+yet — run from source as above.
+
+## Data licences
+
+The code is MIT-licensed (see `LICENSE`). One data file is not: the
+historical return series
+(`src/glidepath/regions/uk/data/returns_history.toml`) is derived from
+the [JST Macrohistory Database](https://www.macrohistory.net/database/)
+(Jordà, Schularick & Taylor; return series per Jordà, Knoll, Kuvshinov,
+Schularick & Taylor 2019) and is distributed under
+[CC BY-NC-SA 4.0](https://creativecommons.org/licenses/by-nc-sa/4.0/) —
+attribution required, non-commercial use only, share-alike. The package
+metadata declares `MIT AND CC-BY-NC-SA-4.0` accordingly; `LICENSE-DATA`
+and the file's own header carry the full notice, and
+`scripts/build_returns_history.py` regenerates the file from the
+upstream dataset.

glidepath-0.2.0.dist-info/RECORD

@@ -0,0 +1,93 @@
+glidepath/__init__.py,sha256=Vi-6JCIWmCK4aG7z8SdSFe3dgy472Aw2GdB7oXREBYM,96
+glidepath/app/__init__.py,sha256=Z7avWMx9HBGF7U3NhYrdQLPm-zgxTN-ek_DUT_8AN6w,9102
+glidepath/app/backtest.py,sha256=An1Pt-7dZVvAZZYVimBjSWijfbQZlhSRO3gEZuihwSc,10375
+glidepath/app/charts.py,sha256=ekEGk_IpkL7vcclOWLXS4jhLbLE1fq6wIqIgnVIktX0,26623
+glidepath/app/copy.py,sha256=p9WuE5btMaOs8GLwZakdaHVzN1QJHvZx0bUc_rBpA8k,8567
+glidepath/app/display.py,sha256=UiJ6jpa1OdGj1e_kYQjJF3QfVg9bDPV_gMzZB2Z55hk,5333
+glidepath/app/drawdown.py,sha256=RAK-kInYpm8qlNBGjhi08bWk-Z0r-Rla6zHbDmRmWiw,15406
+glidepath/app/example.py,sha256=mk1qG5QeItZ0TrwEQbp2jQLiV9TTfSIDvey6wdJmaXI,2659
+glidepath/app/exports.py,sha256=gByQk6TyLOvJuRj9FqlB5qfSolfulCwBolcK9IRja8c,17226
+glidepath/app/files.py,sha256=OgbwsLICeM-fMIs5vNowRvwWGt4TMDvwlYq7IEmUIGM,8492
+glidepath/app/firstrun.py,sha256=8X9LsiwCcJAR8lgjFpk1e2osCO89DW4OSf8xYNpTJeE,3977
+glidepath/app/forms.py,sha256=FRYJ-BDMUsB7fZ4XgCGRDO4qIL2eppTK82qfxzmf2lA,66976
+glidepath/app/inspector.py,sha256=SVikOMErDnrJ9guNcS-ifW_J9k13h5mJqNdkG66BhwE,18009
+glidepath/app/labels.py,sha256=ldY_Vjn00KoDwt8YWX5xR1FFtAjMPO6IDq15J5w2Tr0,2327
+glidepath/app/montecarlo.py,sha256=14MabwPhhOyDUR3MKfgh_Wc7MyidKLZDPR6Su7sMBXY,14044
+glidepath/app/plan.py,sha256=jAjSqmlCiFkDtFvpN5w6aaL-mVGJwfTI-_cN-PLKzcA,12691
+glidepath/app/retirement.py,sha256=pkcAok4UKKK7ES5wFeNSe62d1u08Uvwtjtegilvd3T0,15855
+glidepath/app/scenarios.py,sha256=QaWj-uStyW1v7_CdVb4OPkOknPrGz0phhK1JKmzlpLI,28316
+glidepath/app/shell.py,sha256=LtSlMMGijRulXWU8SAf1HcZDi_FLTKzMgk6Ay7lQT3E,5338
+glidepath/app/tables.py,sha256=Cf-9c7bt7BstdG2Tzfe9FNBfafGyEziZtAg8Zb7ZlNY,4869
+glidepath/core/__init__.py,sha256=xUVGH8pt8qLlk-XM8j9gHN1DBMHx4B6VlR3DeCA00Q8,9118
+glidepath/core/annuities.py,sha256=zs2oOsoCWhyEnPJrxPXzcGt-nDxkHKdrLk8n3zfAOgA,9477
+glidepath/core/backtest.py,sha256=Xc0v3rD4L-gogNowt-xZDnBxqL_YU5UGyIn3PwMT5lY,20265
+glidepath/core/comparison.py,sha256=6iuSZMA_Fk8UI05oBd4xF5ZJ29Bqn4lzgQ5jZkp9noU,10419
+glidepath/core/config.py,sha256=1hotIfVhzbXvZ17G5Mp0up4DQ_SG6vRU4_i8ZgNyhAM,3022
+glidepath/core/contributions.py,sha256=o3QT77_oO-Ki5ckOpuWBi_a2ULzu1QNYcdwToKU_430,13721
+glidepath/core/engine.py,sha256=muElq7dHscX5VekhpytQCnnD6bLmpD_eQT0jtCYOjdc,126490
+glidepath/core/entities.py,sha256=gg0JKjHmxjv-Ef2cU-D6f66qnu-kaCnlDwkQxuObcB0,10452
+glidepath/core/glide.py,sha256=Hrm2hF9zllolTgwPxzWhpv7LoiwkYxqTaUD3o72w71Q,11427
+glidepath/core/investments.py,sha256=s6XefinlQiMim76b7-4lEmkHVCOixh2sntURdVFJLFk,6177
+glidepath/core/money.py,sha256=Lng5B4HAKWAopo-d-U_N7SdjpU0F3UStytSCDfe1BIM,3812
+glidepath/core/montecarlo.py,sha256=oyiC3qjk45gSWY_rTdrWnsszd-Y3-yYcx89nOJYKwQc,25350
+glidepath/core/pensions.py,sha256=YXoFgkkFXrSN-yHOm8SM6Bqbt3N8_b5KtjkIZ7kDnUQ,12407
+glidepath/core/periods.py,sha256=L1ecdl--bFW8kWWxFrxO4fUuANO3myv2-eAJL733bJs,13978
+glidepath/core/provenance.py,sha256=BMflWxqO0zNwwhLdQx3Gz-m0AFG8RtmmLOvmBujBkrE,9272
+glidepath/core/randomness.py,sha256=gM28ebJWV7Yi5mPiHIc5vhaF2yw-FRiGwaNySSljbIo,5470
+glidepath/core/region.py,sha256=zaw5dBI_62dYhnmDtIs4J0zhNkg1z1oeXeXAyERhDU8,1742
+glidepath/core/reporting.py,sha256=qeHw0QrKs-N1vTVc9uYlh1oA_JcqKBEh3pmZm2U0VIE,8552
+glidepath/core/results.py,sha256=r1BseA-Grv-gnorHCjAhcV__tMrS26t1lsKrfxdHEWI,20518
+glidepath/core/retirement.py,sha256=eFpf0_vofntqlN-23MoDWhijEaUHhty4R2ErZD60uzA,12453
+glidepath/core/returns.py,sha256=JpBaV7sAt6jNKrBTe6MyIfbLMsqzUGOzUk-_359GEDA,12584
+glidepath/core/scenarios.py,sha256=YZ1lkS9M8Y28wmbJVkM4v9DG0ij4btwC_1RJpFlD9PI,22466
+glidepath/core/state_pension.py,sha256=vmBksTi2ZEd8mfW5H7tLjF9zY7PfeqnpLQpYGGQGL-Y,10557
+glidepath/core/tax.py,sha256=1befR5b1p7knvyKSavvo9qwnwmOJeDpLsz1Z0O1IDs4,5134
+glidepath/core/withdrawals.py,sha256=LlQ-7GgsjV-_yalTd1OdxwLUqL3NdoECQ2VPJNqqSHU,19640
+glidepath/core/wrappers.py,sha256=DSg4leOBmrcvPhjuOFNeez6h6NAFuOxFlp92srAk6xc,11213
+glidepath/gui/__init__.py,sha256=MNnse5aChZ4X-xWHc646jfYxQjwdJoVnyKT8OcWXuHM,266
+glidepath/gui/assets/icon_128.png,sha256=Mo1TMH1xskDBFBUh2vr4s695OIVdAhdf4yXgycgfAIM,12367
+glidepath/gui/assets/icon_16.png,sha256=npOGODf3xu2MZ0H3pvs7lQPY1WwP2sBeWOIVPly59vM,524
+glidepath/gui/assets/icon_24.png,sha256=7VOticK7lUklv7gfQfSaqtCWAUFdyqZXjxFitDt3r3M,910
+glidepath/gui/assets/icon_256.png,sha256=LC9Qfqyn5y9Q1XXRUQSpo8D9xePPso0M0LN5MU4hH8k,47043
+glidepath/gui/assets/icon_32.png,sha256=sOYguevAWV3iVOfhw_V12y3YMvJY9cuR0a3eI5VyF2I,1349
+glidepath/gui/assets/icon_48.png,sha256=ZOV6Eb-2hIVKgMcsYQv28t2aF4PuaWX9rNIqM37_5nQ,2476
+glidepath/gui/assets/icon_64.png,sha256=HIXqq4oiEN0560296QzhBAZ1TjlmwCKnm2LoeRHw1NM,3886
+glidepath/gui/assets/wordmark.png,sha256=rzZvG2fyq3V5O3LRBaDxALlA7JVEK0NtFPLE5hIoGs0,139710
+glidepath/gui/charts.py,sha256=s6MA1SW9VO6AA613oOZsB1X-CcBaKhx5wCV0Voorkqg,34168
+glidepath/gui/forms.py,sha256=UBENTCZrice_SndzhsOSj6_CgT4C1pEyDMYJdOC7LSE,14087
+glidepath/gui/inspector.py,sha256=8aljbZaC5qWXiaA30ASoKuiP3dKMF5l6cmSZOiE-Bf4,6990
+glidepath/gui/main.py,sha256=H14yrEdQS5ZwnRpF85KGlFapk80wwEO0PBfjWPG7Kko,1829
+glidepath/gui/scenarios.py,sha256=Ozal-Tm7b7i65E-DavzGuccYxUMLrRRvyUFnKoJ2ctE,16651
+glidepath/gui/style.py,sha256=GrEEnMzV8emmKu1sOx6xxVcJoIDHzDO7sxZF8BJ0rIk,10036
+glidepath/gui/tableview.py,sha256=ePJE1vNRWq7p_lDTqSRf5R88WAdlMj_koIiDrD1koig,2331
+glidepath/gui/widgets.py,sha256=cdQl6pf6hjXjSxcT6cd83B_pJsRa2pKW9xSv2SDQ8fs,39509
+glidepath/persistence/__init__.py,sha256=g84BDLvNuz9nIF1dYMEWmyd4__qNTDlPu-FTZyeXFjU,1364
+glidepath/persistence/assumptions.py,sha256=jhwIxznXOFrmzNOjWrKAxTXvrQVMEReg3DI-Iowb_7I,4328
+glidepath/persistence/decode.py,sha256=lSXEsyhoTw6yG6WXx436IydlCA6JiAT7eVRZeaAJ5Ig,25173
+glidepath/persistence/document.py,sha256=6QRWaKy6yZtWemBW_hoQu0utBxFsnLYGr1NK-s6UtKU,3998
+glidepath/persistence/encode.py,sha256=5qNEsHawdb-N6uiFPnCTPlOClZCeKsiwsQtQGXPq6ag,15209
+glidepath/persistence/migrations.py,sha256=kAzbfZX9Qvu3YxDMD2afrr3TdDgLGgV0_7-O4iO-qlA,6461
+glidepath/persistence/values.py,sha256=KbdVMnSCkgBZOAC3GHTysclTH5dbqq0rUQbhJwvU2NA,9857
+glidepath/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+glidepath/regions/__init__.py,sha256=KVe-NFgzrNCKjCLUpGkyilNCZywKNXGr0P811vorztk,362
+glidepath/regions/uk/__init__.py,sha256=Ma0wbPoMbS66pCUhL71OlJDbISiaCHBDVTZWr9Qa0HA,4542
+glidepath/regions/uk/ages.py,sha256=Syr0DZ2IhEWkIcpnRoFVXOO5sWpxn2dHYdyVt4FPP1Q,6434
+glidepath/regions/uk/contributions.py,sha256=yCs3uJv8b41ZHxLheRjVLecNtQ1ZyDyGMQUdbATS7aY,30879
+glidepath/regions/uk/data/age_rules.toml,sha256=l8AiAJl27VmkgNthjnYJJ92biFz2c3hHq3l4BlFehCA,4114
+glidepath/regions/uk/data/assumptions_default.toml,sha256=tjB0Nv9006yrfyCnsc2dMP3mi8J_1ob1iHNBMAJ5HyU,6515
+glidepath/regions/uk/data/returns_history.toml,sha256=x0I5PgFRv_iGQNpxRA04bmm6RENXDrcDWkY9I_cWZ88,13003
+glidepath/regions/uk/data/tax_year_2026_27.toml,sha256=bIeF1z8JdmhFZAjkwZAI7hNvdAyCWiBhXoTbc1p0A3w,4301
+glidepath/regions/uk/extension.py,sha256=xrTxlEm1FA028AJR9OAjM4qffwKEzJ84jMgHE59icmE,19720
+glidepath/regions/uk/loader.py,sha256=OMi0qyuLEKjxjPQ9vByBEho3Q1xL-jF908Mumv-698Y,25812
+glidepath/regions/uk/region.py,sha256=OWAM1-jIqybX3nqMNHL8-m64lrDUgU5GO3x2mCfHq40,6629
+glidepath/regions/uk/schema.py,sha256=ojCp-8PFstxIcoQpcxRtaUD-5GD_zERJTspfZWuU9EI,19878
+glidepath/regions/uk/state_pension.py,sha256=Pcaq-TiMp4zkN9EMfLwMTwHI2Ntb4B_ybiGhQcIb8Ao,5102
+glidepath/regions/uk/tax.py,sha256=hYnQRz8kLGqn3iUqHkdc-lTTA4RZnTODBj6BJRI66vE,18666
+glidepath/regions/uk/wrappers.py,sha256=dKW8QMC0BFeHII02lC7XdVsx4sRRaqVNf6g_GdOX-sU,12319
+glidepath/regions/uk/years.py,sha256=3J-AuuugkWif-vn-RTwQ8S2C8CWByAgan0VikxH1Jkw,3544
+glidepath-0.2.0.dist-info/licenses/LICENSE,sha256=jZIkRQTP4p9jTFpLIOYNhSic-5vp3eK7RGTe3Qpcvbo,1065
+glidepath-0.2.0.dist-info/licenses/LICENSE-DATA,sha256=dCGRR-wYyTIvTWSZ_L9Za6Hy2VaZoMFZyfT7EVqZgVU,1256
+glidepath-0.2.0.dist-info/WHEEL,sha256=l3MmIxu8qaet7ng2J9fFoJnYGj8IREj7jXTbgsuzmy4,81
+glidepath-0.2.0.dist-info/entry_points.txt,sha256=PqQpL7yA9dpYn3ebDjHc3e0rpNfV4D5pD5BL9-sH0uc,51
+glidepath-0.2.0.dist-info/METADATA,sha256=il6iMNMrsYnLZJD6vzfLBiKbKEeXdHsnJ9gS_CK3MFs,8646
+glidepath-0.2.0.dist-info/RECORD,,

glidepath-0.2.0.dist-info/WHEEL

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

glidepath-0.2.0.dist-info/entry_points.txt

@@ -0,0 +1,3 @@
+[gui_scripts]
+glidepath = glidepath.gui.main:main
+