From c11af3de2669f20c0fe8cb131753d811fe225fb6 Mon Sep 17 00:00:00 2001 From: Richard Evans Date: Wed, 18 Nov 2026 21:40:50 -0700 Subject: [PATCH 1/3] Updated files with r_fdc != r_p case --- CHANGELOG.md | 1 + docs/book/content/api/aggregates.rst | 3 +- docs/book/content/api/pensions.rst | 2 +- ogcore/SS.py | 24 +++++- ogcore/aggregates.py | 106 ++++++++++++++++++++++++++- ogcore/default_parameters.json | 21 +++++- ogcore/fiscal.py | 12 ++- ogcore/pensions.py | 42 +++++++++-- tests/test_SS.py | 53 +++++++++++++- tests/test_aggregates.py | 71 ++++++++++++++++-- 10 files changed, 306 insertions(+), 29 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index d9d3ee834..50985a0eb 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,6 +17,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Adds tests of the FDC accounts against hand calculations, the fairness of the annuity, the earnings band, a finite-difference check of the accrual derivative, cohort-specific contribution rates, and calendar-indexed returns. - Solves the steady state with the FDC pillar. Households pay contributions and receive annuity benefits through their budget constraint (kept out of `net_taxes`, so FDC flows are neither government revenue nor outlays). The labor first order condition values the annuity a contribution buys, through `household.fdc_labor_wedge`, so contributions are not treated as a pure tax. The fund's assets (`aggregates.get_F`) add to domestic savings in the capital market, the balances of members who die before retirement are bequeathed, and immigrants arrive with the FDC holdings of their age. The steady-state output adds `F`, `fdc_contrib`, `fdc_benefits`, `fdc_holdings`, `agg_fdc_contrib`, and `agg_fdc_benefits`. With `fdc_tau = 0` (the default) results are unchanged. `TPI.run_TPI` raises `NotImplementedError` when the pillar is on, until the time path is added. - Adds `household.fdc_active`, `household.get_fdc`, `household.fdc_net_flow`, `household.fdc_labor_wedge`, `aggregates.get_F`, `pensions.fdc_holdings`, `pensions.fdc_bequeathable`, and `pensions.fdc_survivor_claims`, with tests of the labor FOC wedge against its closed form on an Euler-equation consumption path, the fund's flow identity, and a steady-state solution with the pillar on. +- Accounts for the spread between the portfolio return r_p and the FDC return r_fdc = r_p - r_fdc_wedge, which the steady state previously dropped, so that a nonzero `r_fdc_wedge` broke the resource constraint. The fund invests the balances it owes households (`aggregates.get_F`, credited r_fdc, including the balances bequeathed by members who die before retirement, which `pensions.fdc_bequeathable` now credits at r_fdc instead of r_p) and keeps the spread (`aggregates.get_fdc_spread`) as a pension reserve that earns r_p and adds to domestic savings (`aggregates.get_pension_reserves`). The new parameter `pension_reserve_max_GDPratio` (default 0.5, range 0.2 to 0.8) caps the reserve as a share of GDP; reserves above the cap are paid to the government as pension reserve revenue, a new optional argument of `fiscal.get_G_ss` and `fiscal.get_TR` that is not tax revenue. With a negative wedge the reserve stays at zero and the government covers the shortfall. `pensions.fdc_bequeathable` now takes `r_p`, and `pensions.fdc_wedge_ss` returns the steady-state wedge by age. The steady-state output adds `fdc_spread`, `pension_reserves`, and `pension_reserve_revenue`. Adds tests of the reserve rule and a steady-state solution with a nonzero wedge, with the reserve below and at its ceiling. ## [0.24.6] - 2026-11-15 diff --git a/docs/book/content/api/aggregates.rst b/docs/book/content/api/aggregates.rst index d7ae92df7..9bfb4dab2 100644 --- a/docs/book/content/api/aggregates.rst +++ b/docs/book/content/api/aggregates.rst @@ -9,6 +9,7 @@ ogcore.aggregates ------------------------------------------ .. automodule:: ogcore.aggregates - :members: get_L, get_I, get_B, get_F, get_BQ, get_RM, get_C, revenue, + :members: get_L, get_I, get_B, get_F, get_fdc_spread, + get_pension_reserves, get_BQ, get_RM, get_C, revenue, get_payroll_tax_revenue, get_r_p, resource_constraint, get_capital_outflows, get_K_splits, get_ptilde diff --git a/docs/book/content/api/pensions.rst b/docs/book/content/api/pensions.rst index 135a72f3f..0174ab7a2 100644 --- a/docs/book/content/api/pensions.rst +++ b/docs/book/content/api/pensions.rst @@ -19,5 +19,5 @@ ogcore.pensions deriv_NDC_loop, delta_ret_loop, PS_1dim_loop, PS_2dim_loop, DB_1dim_loop, DB_2dim_loop, DB_3dim_loop, NDC_1dim_loop, NDC_2dim_loop, FDCLifetime, fdc_earn_bands, fdc_mort_rates, fdc_annuity_factor_loop, - fdc_lifetime_loop, fdc_lifetime, fdc_ss, fdc_holdings, + fdc_lifetime_loop, fdc_lifetime, fdc_ss, fdc_holdings, fdc_wedge_ss, fdc_bequeathable, fdc_survivor_claims diff --git a/ogcore/SS.py b/ogcore/SS.py index 5d5bba16f..2096a5a07 100644 --- a/ogcore/SS.py +++ b/ogcore/SS.py @@ -531,6 +531,11 @@ def inner_loop(outer_loop_vars, p, client, scattered_p=None): L = aggr.get_L(nssmat, p, "SS") B = aggr.get_B(bssmat, p, "SS", False) F = aggr.get_F(fdc, p, "SS") + # pension reserve the fund holds beyond the balances it owes, from + # the spread between r_p and r_fdc, capped at a share of GDP + Z_pen, pension_reserve_revenue = aggr.get_pension_reserves( + r_p, aggr.get_fdc_spread(fdc, p, "SS"), Y, p, "SS" + ) # Find gov't debt r_gov = fiscal.get_r_gov(r, p.debt_ratio_ss, p, "scalar", t=-1) @@ -567,9 +572,10 @@ def inner_loop(outer_loop_vars, p, client, scattered_p=None): K_demand_open_vec[-1] = firm.get_K( p.world_int_rate[-1], w_open, L_M, p, "SS", -1 ) - # the FDC fund's assets add to domestic savings + # the FDC fund's assets (owed balances and reserve) add to + # domestic savings K, K_d, K_f = aggr.get_K_splits( - B + F, K_demand_open_vec.sum(), D_d, p.zeta_K[-1] + B + F + Z_pen, K_demand_open_vec.sum(), D_d, p.zeta_K[-1] ) K_M = max(0.001, K - K_vec.sum()) # make sure K_M > 0 L_vec[-1] = L_M @@ -617,7 +623,7 @@ def inner_loop(outer_loop_vars, p, client, scattered_p=None): # FDC balances of those who die before retirement are bequeathed new_BQ = aggr.get_BQ( new_r_p, - bssmat + pensions.fdc_bequeathable(fdc, p), + bssmat + pensions.fdc_bequeathable(fdc, new_r_p, p), None, p, "SS", @@ -728,6 +734,7 @@ def inner_loop(outer_loop_vars, p, client, scattered_p=None): new_borrowing, debt_service, p, + pension_reserve_revenue, ) new_TR = fiscal.get_TR( Y, @@ -740,6 +747,7 @@ def inner_loop(outer_loop_vars, p, client, scattered_p=None): foreign_aid, p, "SS", + pension_reserve_revenue, ) G_vec = np.zeros(p.M) @@ -993,6 +1001,10 @@ def SS_solver( "SS", ) Fss = aggr.get_F(fdc_ss, p, "SS") + fdc_spread_ss = aggr.get_fdc_spread(fdc_ss, p, "SS") + Zss, pension_reserve_revenue_ss = aggr.get_pension_reserves( + new_r_p, fdc_spread_ss, Yss, p, "SS" + ) ( Dss, D_d_ss, @@ -1009,7 +1021,7 @@ def SS_solver( p.world_int_rate[-1], w_open, L_vec_ss[m], p, "SS", m ) Kss, K_d_ss, K_f_ss = aggr.get_K_splits( - Bss + Fss, K_demand_open_ss.sum(), D_d_ss, p.zeta_K[-1] + Bss + Fss + Zss, K_demand_open_ss.sum(), D_d_ss, p.zeta_K[-1] ) # Yss = firm.get_Y(Kss, K_g_ss, Lss, p, 'SS') I_g_ss = fiscal.get_I_g(Yss, Ig_baseline, p, "SS") @@ -1255,6 +1267,7 @@ def SS_solver( new_borrowing, debt_service, p, + pension_reserve_revenue_ss, ) # Compute total investment (not just domestic) @@ -1404,6 +1417,9 @@ def SS_solver( "bequest_tax": bq_tax_ss[: p.T, ...], "pension_benefits": pension_ss[: p.T, ...], "F": Fss, + "fdc_spread": fdc_spread_ss, + "pension_reserves": Zss, + "pension_reserve_revenue": pension_reserve_revenue_ss, "fdc_contrib": fdc_contrib_ss, "fdc_benefits": fdc_benefits_ss, "fdc_holdings": fdc_holdings_ss, diff --git a/ogcore/aggregates.py b/ogcore/aggregates.py index 685139a05..9bdf5a790 100644 --- a/ogcore/aggregates.py +++ b/ogcore/aggregates.py @@ -223,6 +223,15 @@ def get_F(fdc, p, method): """ if fdc is None: return 0.0 + return _fdc_owed_terms(fdc, p, method).sum() + + +def _fdc_owed_terms(fdc, p, method): + """ + Terms of ``get_F`` by the age s - 1 at which the holdings were + carried out of the previous period (S x J): the balances owed to + households of age s at the start of the period, before its return. + """ if method != "SS": raise NotImplementedError( "FDC fund assets are only computed in the steady state so far" @@ -232,11 +241,102 @@ def get_F(fdc, p, method): imm_extended = np.append( p.imm_rates[-1, 1:, :], np.zeros((1, p.J)), axis=0 ) - F = ( + terms = ( fdc.holdings * np.exp(-p.g_y) * p.omega_SS + claims * omega_extended * imm_extended - ).sum() - return F / (1.0 + p.g_n_ss) + ) + return terms / (1.0 + p.g_n_ss) + + +def get_fdc_spread(fdc, p, method): + r""" + Spread the funded defined contribution (FDC) fund earns on the + balances it owes households. The fund invests the owed balances + $\hat{F}_t$ in the household portfolio, which earns $r_{p,t}$, but + credits the accounts (including those bequeathed by members who die + before retirement) only $r_{fdc} = r_{p} - r_{fdc\_wedge}$. The + difference goes to the pension reserve (``get_pension_reserves``): + + .. math:: + \hat{\Pi}_{t} = \sum_{s=E+1}^{E+S}\sum_{j=0}^{J} + r_{fdc\_wedge,s}\,\hat{f}_{j,s,t} + + where $\hat{f}_{j,s,t}$ are the terms of ``get_F`` owed to members + of age s. + + Args: + fdc (pensions.FDCLifetime or None): the accounts by age and + lifetime income group, None when the pillar is off + p (OG-Core Specifications object): model parameters + method (str): 'SS' (the time path is not supported yet) + + Returns: + spread (scalar): the spread, 0.0 when the pillar is off + (negative when ``r_fdc_wedge`` is negative) + """ + if fdc is None: + return 0.0 + terms = _fdc_owed_terms(fdc, p, method) + # holdings carried out of age s - 1 earn the return of age s + wedge_next = np.append(pensions.fdc_wedge_ss(p)[1:], 0.0) + return float((wedge_next[:, None] * terms).sum()) + + +def get_pension_reserves(r_p, spread, Y, p, method): + r""" + Steady-state pension reserve $\hat{Z}$ of the funded defined + contribution (FDC) fund, the assets it holds beyond the balances + owed to households, and the pension reserve revenue $\hat{\Psi}$ it + pays to the government. + + The reserve is invested in the household portfolio and earns + $r_p$, receives the spread $\hat{\Pi}$ (``get_fdc_spread``), and + may not exceed ``pension_reserve_max_GDPratio`` times GDP. Any + reserve above that ceiling is paid to the government: + + .. math:: + (1 + \bar{g}_{n})e^{g_y}\hat{Z} = (1 + \bar{r}_{p})\hat{Z} + + \hat{\Pi} - \hat{\Psi} + + Without the ceiling the reserve would settle at + $\hat{Z}^{*} = \hat{\Pi}/[(1 + \bar{g}_{n})e^{g_y} - 1 - \bar{r}_p]$ + only when $\bar{r}_p$ is below the growth rate; otherwise it grows + without bound relative to the economy and so stops at the ceiling. + The reserve may not fall below zero: when the spread is negative + (``r_fdc_wedge`` < 0) the government covers the shortfall, which is + negative revenue. + + Args: + r_p (scalar): steady-state household portfolio return + spread (scalar): spread on the owed balances, $\hat{\Pi}$ + Y (scalar): steady-state GDP + p (OG-Core Specifications object): model parameters + method (str): 'SS' (the time path is not supported yet) + + Returns: + (tuple): pension reserve quantities + + * Z (scalar): pension reserve $\hat{Z}$ + * revenue (scalar): pension reserve revenue $\hat{\Psi}$ + """ + if method != "SS": + raise NotImplementedError( + "Pension reserves are only computed in the steady state so far" + ) + r_p = float(np.squeeze(r_p)) + Y = float(np.squeeze(Y)) + Z_max = max(p.pension_reserve_max_GDPratio * Y, 0.0) + # growth rate less the reserve's return: the share of the reserve + # needed each period to keep pace with the economy, net of earnings + net_growth = (1.0 + p.g_n_ss) * np.exp(p.g_y) - 1.0 - r_p + if spread <= 0.0: + Z = 0.0 + elif net_growth > 0.0: + Z = min(spread / net_growth, Z_max) + else: + Z = Z_max + revenue = spread - net_growth * Z + return Z, revenue def get_BQ(r, b_splus1, j, p, method, preTP): diff --git a/ogcore/default_parameters.json b/ogcore/default_parameters.json index 871a5c3c6..a5348b7ea 100644 --- a/ogcore/default_parameters.json +++ b/ogcore/default_parameters.json @@ -4192,7 +4192,7 @@ "description": "Percentage point wedge between the return households earn on savings r_p and the return earned on funded defined contribution (FDC) account balances, r_fdc = r_p - r_fdc_wedge. A positive value means FDC accounts earn less than household savings (for example, because of fund management fees); a negative value means they earn more.", "section_1": "Fiscal Policy Parameters", "section_2": "Government Pension Parameters", - "notes": "Only used when fdc_tau is positive. May vary over time: set value for base year, click '+' to add value for next year. All future years not specified are set to last value entered. A single value is held constant over the time path (it is not indexed to trend growth). The wedge that applies to an FDC account is the one the account holder's cohort faces in each period. Changes by birth cohort are entered through pension_regimes with a single number.", + "notes": "Only used when fdc_tau is positive. May vary over time: set value for base year, click '+' to add value for next year. All future years not specified are set to last value entered. A single value is held constant over the time path (it is not indexed to trend growth). The wedge that applies to an FDC account is the one the account holder's cohort faces in each period. Changes by birth cohort are entered through pension_regimes with a single number. The fund invests the balances it owes in the household portfolio, which earns r_p, so it keeps the spread r_fdc_wedge times those balances as a pension reserve, capped at pension_reserve_max_GDPratio times GDP; reserves above the cap are paid to the government as pension reserve revenue. With a negative wedge the reserve stays at zero and the government covers the shortfall.", "type": "float", "number_dims": 1, "value": [ @@ -4209,6 +4209,25 @@ } } }, + "pension_reserve_max_GDPratio": { + "title": "Ceiling on the pension reserve of the funded defined contribution fund as a share of GDP.", + "description": "Maximum pension reserve, as a share of GDP, that the funded defined contribution (FDC) fund may hold beyond the balances it owes households. The reserve is invested in the household portfolio, earns r_p, and accumulates the spread r_fdc_wedge times the owed balances. Reserves above this ceiling are paid to the government as pension reserve revenue, which enters the government budget constraint but is not tax revenue.", + "section_1": "Fiscal Policy Parameters", + "section_2": "Government Pension Parameters", + "notes": "Only used when fdc_tau is positive. The reserve settles below the ceiling (and pays no revenue) only if r_p is below the growth rate (1 + g_n) e^{g_y} - 1 and the spread is small enough; otherwise it stays at the ceiling. Currently applied in the steady state only.", + "type": "float", + "value": [ + { + "value": 0.5 + } + ], + "validators": { + "range": { + "min": 0.2, + "max": 0.8 + } + } + }, "db_earn_cap_factor": { "title": "Cap on the labor income that earns a defined benefit, as a multiple of initial-period average labor income.", "description": "Labor income up to db_earn_cap_factor in period t times avg_labor_inc_t1_model_units (average labor income in the first model period) earns a defined benefit (computed with the Defined Benefits parameters). Under the Defined Benefits system with pension_earn_cap true, labor income above this cap earns no benefit. Under the hybrid defined benefit and notional defined contribution system, this is the upper cutoff of the defined benefit band and the lower cutoff of the notional defined contribution band, and labor income up to it is subject to the payroll tax tau_payroll.", diff --git a/ogcore/fiscal.py b/ogcore/fiscal.py index 674a8adb3..5c73ef143 100644 --- a/ogcore/fiscal.py +++ b/ogcore/fiscal.py @@ -269,12 +269,13 @@ def get_G_ss( new_borrowing, debt_service, p, + pension_reserve_revenue=0.0, ): r""" Calculate the steady-state values of government spending. .. math:: - \bar{G} = \bar{Rev} + \overline{FA} + \bar{G} = \bar{Rev} + \bar{\Psi} + \overline{FA} + \bar{D}\bigl[(1 + \bar{g}_n)e^{g_y} - (1 + \bar{r}_{gov})\bigr] - \bar{I}_g - \bar{TR} - \overline{UBI} @@ -290,6 +291,9 @@ def get_G_ss( new_borrowing (scalar): steady-state amount of new borrowing debt_service (scalar): steady-state debt service costs p (OG-Core Specifications object): model parameters + pension_reserve_revenue (scalar): pension reserves above the + ceiling that the funded defined contribution fund pays the + government, $\bar{\Psi}$ (not tax revenue) Returns: G (tuple): steady-state government spending @@ -300,6 +304,7 @@ def get_G_ss( else: G = ( total_tax_revenue + + pension_reserve_revenue + new_borrowing + foreign_aid - (agg_pension_outlays + TR + debt_service + UBI_outlays + I_g) @@ -337,6 +342,7 @@ def get_TR( foreign_aid, p, method, + pension_reserve_revenue=0.0, ): r""" Function to compute aggregate transfers. Note that this excludes @@ -364,6 +370,9 @@ def get_TR( government p (OG-Core Specifications object): model parameters method (str): whether doing SS or TP calculation + pension_reserve_revenue (array_like): pension reserves above + the ceiling that the funded defined contribution fund pays + the government (not tax revenue) Returns: new_TR (array_like): new value of aggregate government transfers @@ -372,6 +381,7 @@ def get_TR( if p.budget_balance: new_TR = ( total_tax_revenue + + pension_reserve_revenue + foreign_aid - agg_pension_outlays - G diff --git a/ogcore/pensions.py b/ogcore/pensions.py index 215ea4fec..8de6aa3e3 100644 --- a/ogcore/pensions.py +++ b/ogcore/pensions.py @@ -3032,20 +3032,45 @@ def fdc_holdings(fdc): return fdc.holdings -def fdc_bequeathable(fdc, p): +def fdc_wedge_ss(p): + """ + Steady-state wedge ``r_fdc_wedge`` between the portfolio return + r_p and the FDC return r_fdc at each age, the value + ``fdc_lifetime`` uses for a household with t_birth None. + + Args: + p (OG-Core Specifications object): model parameters + + Returns: + wedge (Numpy array): wedge at each age, length S (zeros if the + parameter is absent) + """ + if not hasattr(p, "r_fdc_wedge"): + return np.zeros(p.S) + wedge_arr = cohort_array("r_fdc_wedge", p) + return np.asarray(wedge_arr[-1, :], dtype=float).ravel()[: p.S] + + +def fdc_bequeathable(fdc, r_p, p): """ End-of-period holdings that go to bequests if the household dies before the next period: the account holdings at ages before the retirement age. After retirement the holdings of those who die stay in the annuity pool. - The holdings are returned in the next period's detrended units, + The account of a member who dies is credited the FDC return + r_fdc = r_p - r_fdc_wedge, like the account of a survivor, and the + fund keeps the spread. Because ``aggregates.get_BQ`` multiplies the + savings it is given by (1 + r_p), the holdings are scaled here by + (1 + r_fdc) / (1 + r_p), with r_fdc the return at the next age. + They are also returned in the next period's detrended units, e^{-g_y} times the holdings, the units of the private savings - b_{s+1} they are added to in ``aggregates.get_BQ``. + b_{s+1} they are added to. Args: fdc (FDCLifetime or None): the accounts, None when the pillar is off + r_p (scalar): steady-state household portfolio return p (OG-Core Specifications object): model parameters Returns: @@ -3055,10 +3080,13 @@ def fdc_bequeathable(fdc, p): """ if fdc is None: return 0.0 - ages = np.arange(fdc.holdings.shape[0]).reshape( - (-1,) + (1,) * (fdc.holdings.ndim - 1) - ) - return np.where(ages < fdc.R, fdc.holdings, 0.0) * np.exp(-p.g_y) + H = fdc.holdings + shape = (-1,) + (1,) * (H.ndim - 1) + ages = np.arange(H.shape[0]).reshape(shape) + r_p = float(np.squeeze(r_p)) + wedge_next = np.append(fdc_wedge_ss(p)[1:], 0.0).reshape(shape) + scale = (1.0 + r_p - wedge_next) / (1.0 + r_p) + return np.where(ages < fdc.R, H * scale, 0.0) * np.exp(-p.g_y) def fdc_survivor_claims(fdc, rho, p): diff --git a/tests/test_SS.py b/tests/test_SS.py index 84172a424..5a50f5e64 100644 --- a/tests/test_SS.py +++ b/tests/test_SS.py @@ -1605,15 +1605,19 @@ def test_SS_fsolve_scatters_once(scatter_test_params): assert client.scatter_calls == 2 -def _solve_small_SS(updates): +def _small_SS_params(updates): import json - SS.ENFORCE_SOLUTION_CHECKS = True p = Specifications(baseline=True, num_workers=1) with open(os.path.join(CUR_PATH, "testing_params.json")) as f: p.update_specifications(json.load(f)) p.update_specifications(updates) - return SS.run_SS(p, client=None) + return p + + +def _solve_small_SS(updates): + SS.ENFORCE_SOLUTION_CHECKS = True + return SS.run_SS(_small_SS_params(updates), client=None) def test_SS_funded_defined_contribution(): @@ -1634,3 +1638,46 @@ def test_SS_funded_defined_contribution(): assert fdc["B"] + fdc["F"] > base["B"] assert fdc["K"] > base["K"] and fdc["r"] < base["r"] assert fdc["fdc_contrib"].shape == fdc["n"].shape + assert fdc["pension_reserves"] == 0.0 + assert fdc["pension_reserve_revenue"] == 0.0 + + +@pytest.mark.parametrize( + "max_ratio,at_cap", + [(0.5, False), (0.2, True)], + ids=["reserve below ceiling", "reserve at ceiling"], +) +def test_SS_funded_defined_contribution_wedge(max_ratio, at_cap): + """ + With a positive wedge between r_p and r_fdc, the fund keeps the + spread on the balances it owes as a pension reserve, invested in + the capital stock and capped at pension_reserve_max_GDPratio times + GDP, and pays reserves above the cap to the government. The + resource constraint holds whether or not the ceiling binds. (With + the testing parameters r_p is below the growth rate, so the + reserve settles below a ceiling of 0.5 and reaches one of 0.2.) + """ + wedge = 0.01 + updates = { + "fdc_tau": 0.05, + "r_fdc_wedge": [wedge], + "pension_reserve_max_GDPratio": max_ratio, + } + p_ss = _small_SS_params(updates) + fdc = _solve_small_SS(updates) + assert np.abs(fdc["resource_constraint_error"]).max() < 1e-7 + assert fdc["F"] > 0.0 + assert np.isclose(fdc["fdc_spread"], wedge * fdc["F"], rtol=1e-8) + Z, revenue = fdc["pension_reserves"], fdc["pension_reserve_revenue"] + Z_max = p_ss.pension_reserve_max_GDPratio * fdc["Y"] + assert 0.0 < Z <= Z_max * (1 + 1e-10) + # steady-state flow identity of the reserve + G = (1 + p_ss.g_n_ss) * np.exp(p_ss.g_y) + assert np.isclose( + G * Z, (1 + fdc["r_p"]) * Z + fdc["fdc_spread"] - revenue + ) + # the reserve pays revenue to the government only at the ceiling + if at_cap: + assert np.isclose(Z, Z_max) and revenue > 0.0 + else: + assert Z < Z_max and np.isclose(revenue, 0.0) diff --git a/tests/test_aggregates.py b/tests/test_aggregates.py index 036046ab0..064ea02a3 100644 --- a/tests/test_aggregates.py +++ b/tests/test_aggregates.py @@ -2079,28 +2079,83 @@ def test_get_F_off(): assert aggr.get_F(None, Specifications(), "SS") == 0.0 -def test_get_F_fund_identity(): +@pytest.mark.parametrize("wedge", [0.0, 0.01], ids=["no wedge", "wedge"]) +def test_get_F_fund_identity(wedge): """ - The fund's assets earn r_p; less the bequests of members who die - before retirement, they pay for the start-of-period balances of - the members alive (and the immigrants who arrive), each in the - period's detrended units. + The fund's owed balances earn r_p; less the bequests of members who + die before retirement (credited r_fdc) and the spread kept for the + pension reserve, they pay for the start-of-period balances of the + members alive (and the immigrants who arrive), each in the period's + detrended units. """ from ogcore import pensions p_f = Specifications() - p_f.update_specifications({"fdc_tau": 0.08}) + p_f.update_specifications({"fdc_tau": 0.08, "r_fdc_wedge": [wedge]}) r_p, w = 0.05, 1.1 n = np.linspace(0.3, 0.5, p_f.S)[:, None] * np.ones((1, p_f.J)) fdc = pensions.fdc_ss(r_p, w, p_f.e[-1], n, p_f) F = aggr.get_F(fdc, p_f, "SS") + spread = aggr.get_fdc_spread(fdc, p_f, "SS") BQ_f = np.sum( aggr.get_BQ( - r_p, pensions.fdc_bequeathable(fdc, p_f), None, p_f, "SS", False + r_p, + pensions.fdc_bequeathable(fdc, r_p, p_f), + None, + p_f, + "SS", + False, ) ) balances = (p_f.omega_SS * fdc.balance).sum() assert F > 0 and BQ_f > 0 - assert np.isclose((1 + r_p) * F - BQ_f, balances, rtol=1e-7) + assert np.isclose(spread, wedge * F, rtol=1e-10) + assert np.isclose((1 + r_p) * F - spread - BQ_f, balances, rtol=1e-7) with pytest.raises(NotImplementedError): aggr.get_F(fdc, p_f, "TPI") + + +def test_get_fdc_spread_off(): + assert aggr.get_fdc_spread(None, Specifications(), "SS") == 0.0 + + +@pytest.mark.parametrize( + "r_p,spread,Z_expected", + [ + (0.05, 0.0, 0.0), + (0.05, 0.02, "cap"), + (0.0, 0.001, "interior"), + (0.0, 0.5, "cap"), + (0.05, -0.02, 0.0), + ], + ids=[ + "no spread", + "r_p above growth", + "below cap", + "above cap", + "negative spread", + ], +) +def test_get_pension_reserves(r_p, spread, Z_expected): + """ + The reserve follows its steady-state flow identity, settles below + the ceiling only when r_p is below the growth rate, never exceeds + the ceiling or falls below zero, and pays revenue only at a bound. + """ + p_z = Specifications() + Y = 2.0 + G = (1 + p_z.g_n_ss) * np.exp(p_z.g_y) + Z, revenue = aggr.get_pension_reserves(r_p, spread, Y, p_z, "SS") + Z_max = p_z.pension_reserve_max_GDPratio * Y + assert np.isclose(G * Z, (1 + r_p) * Z + spread - revenue) + assert 0.0 <= Z <= Z_max + 1e-12 + if Z_expected == "cap": + assert np.isclose(Z, Z_max) and revenue > 0 + elif Z_expected == "interior": + assert 0.0 < Z < Z_max + assert np.isclose(Z, spread / (G - 1 - r_p)) + assert np.isclose(revenue, 0.0) + else: + assert Z == 0.0 and revenue == spread + with pytest.raises(NotImplementedError): + aggr.get_pension_reserves(r_p, spread, Y, p_z, "TPI") From 4a325ec48df098f41b24295bf9485c1d51cbb32c Mon Sep 17 00:00:00 2001 From: Richard Evans Date: Thu, 19 Nov 2026 02:50:03 -0700 Subject: [PATCH 2/3] Updated files --- CHANGELOG.md | 2 +- ogcore/SS.py | 16 ++++++---- ogcore/aggregates.py | 55 +++++++++++++++++++++++----------- ogcore/default_parameters.json | 4 +-- ogcore/fiscal.py | 18 ++++++----- tests/test_SS.py | 51 +++++++++++++++++++------------ tests/test_aggregates.py | 21 +++++++++---- 7 files changed, 110 insertions(+), 57 deletions(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index 50985a0eb..0cba1fc5e 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -17,7 +17,7 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0 - Adds tests of the FDC accounts against hand calculations, the fairness of the annuity, the earnings band, a finite-difference check of the accrual derivative, cohort-specific contribution rates, and calendar-indexed returns. - Solves the steady state with the FDC pillar. Households pay contributions and receive annuity benefits through their budget constraint (kept out of `net_taxes`, so FDC flows are neither government revenue nor outlays). The labor first order condition values the annuity a contribution buys, through `household.fdc_labor_wedge`, so contributions are not treated as a pure tax. The fund's assets (`aggregates.get_F`) add to domestic savings in the capital market, the balances of members who die before retirement are bequeathed, and immigrants arrive with the FDC holdings of their age. The steady-state output adds `F`, `fdc_contrib`, `fdc_benefits`, `fdc_holdings`, `agg_fdc_contrib`, and `agg_fdc_benefits`. With `fdc_tau = 0` (the default) results are unchanged. `TPI.run_TPI` raises `NotImplementedError` when the pillar is on, until the time path is added. - Adds `household.fdc_active`, `household.get_fdc`, `household.fdc_net_flow`, `household.fdc_labor_wedge`, `aggregates.get_F`, `pensions.fdc_holdings`, `pensions.fdc_bequeathable`, and `pensions.fdc_survivor_claims`, with tests of the labor FOC wedge against its closed form on an Euler-equation consumption path, the fund's flow identity, and a steady-state solution with the pillar on. -- Accounts for the spread between the portfolio return r_p and the FDC return r_fdc = r_p - r_fdc_wedge, which the steady state previously dropped, so that a nonzero `r_fdc_wedge` broke the resource constraint. The fund invests the balances it owes households (`aggregates.get_F`, credited r_fdc, including the balances bequeathed by members who die before retirement, which `pensions.fdc_bequeathable` now credits at r_fdc instead of r_p) and keeps the spread (`aggregates.get_fdc_spread`) as a pension reserve that earns r_p and adds to domestic savings (`aggregates.get_pension_reserves`). The new parameter `pension_reserve_max_GDPratio` (default 0.5, range 0.2 to 0.8) caps the reserve as a share of GDP; reserves above the cap are paid to the government as pension reserve revenue, a new optional argument of `fiscal.get_G_ss` and `fiscal.get_TR` that is not tax revenue. With a negative wedge the reserve stays at zero and the government covers the shortfall. `pensions.fdc_bequeathable` now takes `r_p`, and `pensions.fdc_wedge_ss` returns the steady-state wedge by age. The steady-state output adds `fdc_spread`, `pension_reserves`, and `pension_reserve_revenue`. Adds tests of the reserve rule and a steady-state solution with a nonzero wedge, with the reserve below and at its ceiling. +- Accounts for the spread between the portfolio return r_p and the FDC return r_fdc = r_p - r_fdc_wedge, which the steady state previously dropped, so that a nonzero `r_fdc_wedge` broke the resource constraint. The fund invests the balances it owes households (`aggregates.get_F`, credited r_fdc, including the balances bequeathed by members who die before retirement, which `pensions.fdc_bequeathable` now credits at r_fdc instead of r_p) and keeps the spread (`aggregates.get_fdc_spread`) as a pension reserve that earns r_p and adds to domestic savings (`aggregates.get_pension_reserves`). The new parameter `pension_reserve_max_GDPratio` (default 0.5, range 0.2 to 0.8) caps the reserve as a share of GDP; reserves above the cap are paid to the government as pension reserve revenue, a new optional argument of `fiscal.get_G_ss` and `fiscal.get_TR` that is not tax revenue. The reserve also has a floor of zero: at the end of any period in which it would fall below zero (as with a negative wedge), the government transfers enough to the reserve that it begins the next period at zero or above, a pension reserve transfer that is netted against the revenue in the budget constraint. `pensions.fdc_bequeathable` now takes `r_p`, and `pensions.fdc_wedge_ss` returns the steady-state wedge by age. The steady-state output adds `fdc_spread`, `pension_reserves`, `pension_reserve_revenue`, and `pension_reserve_transfer`. Adds tests of the reserve rule and steady-state solutions with a nonzero wedge, with the reserve below its ceiling, at its ceiling, and at its floor. ## [0.24.6] - 2026-11-15 diff --git a/ogcore/SS.py b/ogcore/SS.py index 2096a5a07..abebfc0a7 100644 --- a/ogcore/SS.py +++ b/ogcore/SS.py @@ -533,9 +533,12 @@ def inner_loop(outer_loop_vars, p, client, scattered_p=None): F = aggr.get_F(fdc, p, "SS") # pension reserve the fund holds beyond the balances it owes, from # the spread between r_p and r_fdc, capped at a share of GDP - Z_pen, pension_reserve_revenue = aggr.get_pension_reserves( + Z_pen, Psi, Phi = aggr.get_pension_reserves( r_p, aggr.get_fdc_spread(fdc, p, "SS"), Y, p, "SS" ) + # net pension reserve revenue: payments above the ceiling less + # transfers that keep the reserve from falling below zero + pension_reserve_revenue = Psi - Phi # Find gov't debt r_gov = fiscal.get_r_gov(r, p.debt_ratio_ss, p, "scalar", t=-1) @@ -1002,9 +1005,11 @@ def SS_solver( ) Fss = aggr.get_F(fdc_ss, p, "SS") fdc_spread_ss = aggr.get_fdc_spread(fdc_ss, p, "SS") - Zss, pension_reserve_revenue_ss = aggr.get_pension_reserves( - new_r_p, fdc_spread_ss, Yss, p, "SS" - ) + ( + Zss, + pension_reserve_revenue_ss, + pension_reserve_transfer_ss, + ) = aggr.get_pension_reserves(new_r_p, fdc_spread_ss, Yss, p, "SS") ( Dss, D_d_ss, @@ -1267,7 +1272,7 @@ def SS_solver( new_borrowing, debt_service, p, - pension_reserve_revenue_ss, + pension_reserve_revenue_ss - pension_reserve_transfer_ss, ) # Compute total investment (not just domestic) @@ -1420,6 +1425,7 @@ def SS_solver( "fdc_spread": fdc_spread_ss, "pension_reserves": Zss, "pension_reserve_revenue": pension_reserve_revenue_ss, + "pension_reserve_transfer": pension_reserve_transfer_ss, "fdc_contrib": fdc_contrib_ss, "fdc_benefits": fdc_benefits_ss, "fdc_holdings": fdc_holdings_ss, diff --git a/ogcore/aggregates.py b/ogcore/aggregates.py index 9bdf5a790..71c7e3537 100644 --- a/ogcore/aggregates.py +++ b/ogcore/aggregates.py @@ -286,25 +286,31 @@ def get_pension_reserves(r_p, spread, Y, p, method): r""" Steady-state pension reserve $\hat{Z}$ of the funded defined contribution (FDC) fund, the assets it holds beyond the balances - owed to households, and the pension reserve revenue $\hat{\Psi}$ it - pays to the government. + owed to households, the pension reserve revenue $\hat{\Psi}$ it + pays to the government, and the transfer $\hat{\Phi}$ it receives + from the government. The reserve is invested in the household portfolio and earns $r_p$, receives the spread $\hat{\Pi}$ (``get_fdc_spread``), and - may not exceed ``pension_reserve_max_GDPratio`` times GDP. Any - reserve above that ceiling is paid to the government: + must lie between zero and ``pension_reserve_max_GDPratio`` times + GDP at the beginning of every period. At the end of each period, + any reserve above the ceiling is paid to the government + ($\hat{\Psi}$), and any shortfall below zero is made up by a + transfer from the government ($\hat{\Phi}$), so that .. math:: (1 + \bar{g}_{n})e^{g_y}\hat{Z} = (1 + \bar{r}_{p})\hat{Z} - + \hat{\Pi} - \hat{\Psi} + + \hat{\Pi} - \hat{\Psi} + \hat{\Phi}, + \quad 0 \leq \hat{Z} \leq \bar{z}\bar{Y}, + \quad \hat{\Psi}, \hat{\Phi} \geq 0 Without the ceiling the reserve would settle at $\hat{Z}^{*} = \hat{\Pi}/[(1 + \bar{g}_{n})e^{g_y} - 1 - \bar{r}_p]$ only when $\bar{r}_p$ is below the growth rate; otherwise it grows without bound relative to the economy and so stops at the ceiling. - The reserve may not fall below zero: when the spread is negative - (``r_fdc_wedge`` < 0) the government covers the shortfall, which is - negative revenue. + The floor binds when the spread is negative (``r_fdc_wedge`` < 0): + the reserve starts every period at zero and the government covers + the spread each period. Args: r_p (scalar): steady-state household portfolio return @@ -316,8 +322,12 @@ def get_pension_reserves(r_p, spread, Y, p, method): Returns: (tuple): pension reserve quantities - * Z (scalar): pension reserve $\hat{Z}$ - * revenue (scalar): pension reserve revenue $\hat{\Psi}$ + * Z (scalar): pension reserve $\hat{Z}$ at the beginning + of the period + * revenue (scalar): pension reserve revenue paid to the + government, $\hat{\Psi} \geq 0$ + * transfer (scalar): transfer from the government to the + reserve, $\hat{\Phi} \geq 0$ """ if method != "SS": raise NotImplementedError( @@ -329,14 +339,25 @@ def get_pension_reserves(r_p, spread, Y, p, method): # growth rate less the reserve's return: the share of the reserve # needed each period to keep pace with the economy, net of earnings net_growth = (1.0 + p.g_n_ss) * np.exp(p.g_y) - 1.0 - r_p - if spread <= 0.0: - Z = 0.0 - elif net_growth > 0.0: - Z = min(spread / net_growth, Z_max) - else: + if spread > 0.0 and net_growth <= 0.0: + # the reserve grows faster than the economy: it reaches the + # ceiling Z = Z_max - revenue = spread - net_growth * Z - return Z, revenue + elif spread > 0.0: + Z = spread / net_growth + else: + # a stationary reserve below zero, or one that falls without + # bound: it is held at the floor + Z = 0.0 + # the floor and ceiling on the beginning-of-period reserve + Z = min(max(Z, 0.0), Z_max) + # end-of-period payment that keeps the reserve stationary at Z: + # positive above the ceiling (to the government), negative below + # the floor (from the government) + net_payment = spread - net_growth * Z + revenue = max(net_payment, 0.0) + transfer = max(-net_payment, 0.0) + return Z, revenue, transfer def get_BQ(r, b_splus1, j, p, method, preTP): diff --git a/ogcore/default_parameters.json b/ogcore/default_parameters.json index a5348b7ea..b7a9961ff 100644 --- a/ogcore/default_parameters.json +++ b/ogcore/default_parameters.json @@ -4192,7 +4192,7 @@ "description": "Percentage point wedge between the return households earn on savings r_p and the return earned on funded defined contribution (FDC) account balances, r_fdc = r_p - r_fdc_wedge. A positive value means FDC accounts earn less than household savings (for example, because of fund management fees); a negative value means they earn more.", "section_1": "Fiscal Policy Parameters", "section_2": "Government Pension Parameters", - "notes": "Only used when fdc_tau is positive. May vary over time: set value for base year, click '+' to add value for next year. All future years not specified are set to last value entered. A single value is held constant over the time path (it is not indexed to trend growth). The wedge that applies to an FDC account is the one the account holder's cohort faces in each period. Changes by birth cohort are entered through pension_regimes with a single number. The fund invests the balances it owes in the household portfolio, which earns r_p, so it keeps the spread r_fdc_wedge times those balances as a pension reserve, capped at pension_reserve_max_GDPratio times GDP; reserves above the cap are paid to the government as pension reserve revenue. With a negative wedge the reserve stays at zero and the government covers the shortfall.", + "notes": "Only used when fdc_tau is positive. May vary over time: set value for base year, click '+' to add value for next year. All future years not specified are set to last value entered. A single value is held constant over the time path (it is not indexed to trend growth). The wedge that applies to an FDC account is the one the account holder's cohort faces in each period. Changes by birth cohort are entered through pension_regimes with a single number. The fund invests the balances it owes in the household portfolio, which earns r_p, so it keeps the spread r_fdc_wedge times those balances as a pension reserve, capped at pension_reserve_max_GDPratio times GDP; reserves above the cap are paid to the government as pension reserve revenue. The reserve is never negative at the beginning of a period: any shortfall below zero (for example, with a negative wedge) is made up by a transfer from the government at the end of that period.", "type": "float", "number_dims": 1, "value": [ @@ -4211,7 +4211,7 @@ }, "pension_reserve_max_GDPratio": { "title": "Ceiling on the pension reserve of the funded defined contribution fund as a share of GDP.", - "description": "Maximum pension reserve, as a share of GDP, that the funded defined contribution (FDC) fund may hold beyond the balances it owes households. The reserve is invested in the household portfolio, earns r_p, and accumulates the spread r_fdc_wedge times the owed balances. Reserves above this ceiling are paid to the government as pension reserve revenue, which enters the government budget constraint but is not tax revenue.", + "description": "Maximum pension reserve, as a share of GDP, that the funded defined contribution (FDC) fund may hold beyond the balances it owes households. The reserve is invested in the household portfolio, earns r_p, and accumulates the spread r_fdc_wedge times the owed balances. Reserves above this ceiling are paid to the government as pension reserve revenue, which enters the government budget constraint but is not tax revenue. The reserve also has a floor of zero: at the end of any period in which it would fall below zero, the government transfers enough to the reserve that it begins the next period at zero or above.", "section_1": "Fiscal Policy Parameters", "section_2": "Government Pension Parameters", "notes": "Only used when fdc_tau is positive. The reserve settles below the ceiling (and pays no revenue) only if r_p is below the growth rate (1 + g_n) e^{g_y} - 1 and the spread is small enough; otherwise it stays at the ceiling. Currently applied in the steady state only.", diff --git a/ogcore/fiscal.py b/ogcore/fiscal.py index 5c73ef143..956f32991 100644 --- a/ogcore/fiscal.py +++ b/ogcore/fiscal.py @@ -275,7 +275,7 @@ def get_G_ss( Calculate the steady-state values of government spending. .. math:: - \bar{G} = \bar{Rev} + \bar{\Psi} + \overline{FA} + \bar{G} = \bar{Rev} + \bar{\Psi} - \bar{\Phi} + \overline{FA} + \bar{D}\bigl[(1 + \bar{g}_n)e^{g_y} - (1 + \bar{r}_{gov})\bigr] - \bar{I}_g - \bar{TR} - \overline{UBI} @@ -291,9 +291,11 @@ def get_G_ss( new_borrowing (scalar): steady-state amount of new borrowing debt_service (scalar): steady-state debt service costs p (OG-Core Specifications object): model parameters - pension_reserve_revenue (scalar): pension reserves above the - ceiling that the funded defined contribution fund pays the - government, $\bar{\Psi}$ (not tax revenue) + pension_reserve_revenue (scalar): net payment from the funded + defined contribution fund's pension reserve to the + government, $\bar{\Psi} - \bar{\Phi}$: reserves above the + ceiling less the transfer that keeps the reserve from + falling below zero (not tax revenue) Returns: G (tuple): steady-state government spending @@ -370,9 +372,11 @@ def get_TR( government p (OG-Core Specifications object): model parameters method (str): whether doing SS or TP calculation - pension_reserve_revenue (array_like): pension reserves above - the ceiling that the funded defined contribution fund pays - the government (not tax revenue) + pension_reserve_revenue (array_like): net payment from the + funded defined contribution fund's pension reserve to the + government: reserves above the ceiling less the transfer + that keeps the reserve from falling below zero (not tax + revenue) Returns: new_TR (array_like): new value of aggregate government transfers diff --git a/tests/test_SS.py b/tests/test_SS.py index 5a50f5e64..5b70e2e07 100644 --- a/tests/test_SS.py +++ b/tests/test_SS.py @@ -1640,24 +1640,30 @@ def test_SS_funded_defined_contribution(): assert fdc["fdc_contrib"].shape == fdc["n"].shape assert fdc["pension_reserves"] == 0.0 assert fdc["pension_reserve_revenue"] == 0.0 + assert fdc["pension_reserve_transfer"] == 0.0 @pytest.mark.parametrize( - "max_ratio,at_cap", - [(0.5, False), (0.2, True)], - ids=["reserve below ceiling", "reserve at ceiling"], + "wedge,max_ratio,bound", + [(0.01, 0.5, None), (0.01, 0.2, "ceiling"), (-0.01, 0.5, "floor")], + ids=[ + "reserve below ceiling", + "reserve at ceiling", + "negative wedge, reserve at floor", + ], ) -def test_SS_funded_defined_contribution_wedge(max_ratio, at_cap): +def test_SS_funded_defined_contribution_wedge(wedge, max_ratio, bound): """ - With a positive wedge between r_p and r_fdc, the fund keeps the - spread on the balances it owes as a pension reserve, invested in - the capital stock and capped at pension_reserve_max_GDPratio times - GDP, and pays reserves above the cap to the government. The - resource constraint holds whether or not the ceiling binds. (With - the testing parameters r_p is below the growth rate, so the - reserve settles below a ceiling of 0.5 and reaches one of 0.2.) + With a wedge between r_p and r_fdc, the fund keeps the spread on + the balances it owes as a pension reserve, invested in the capital + stock, which must lie between zero and pension_reserve_max_GDPratio + times GDP. Reserves above the ceiling are paid to the government, + and with a negative wedge the government transfers enough to keep + the reserve at zero. The resource constraint holds in each case. + (With the testing parameters r_p is below the growth rate, so with + a positive wedge the reserve settles below a ceiling of 0.5 and + reaches one of 0.2.) """ - wedge = 0.01 updates = { "fdc_tau": 0.05, "r_fdc_wedge": [wedge], @@ -1668,16 +1674,23 @@ def test_SS_funded_defined_contribution_wedge(max_ratio, at_cap): assert np.abs(fdc["resource_constraint_error"]).max() < 1e-7 assert fdc["F"] > 0.0 assert np.isclose(fdc["fdc_spread"], wedge * fdc["F"], rtol=1e-8) - Z, revenue = fdc["pension_reserves"], fdc["pension_reserve_revenue"] + Z = fdc["pension_reserves"] + revenue = fdc["pension_reserve_revenue"] + transfer = fdc["pension_reserve_transfer"] Z_max = p_ss.pension_reserve_max_GDPratio * fdc["Y"] - assert 0.0 < Z <= Z_max * (1 + 1e-10) + assert 0.0 <= Z <= Z_max * (1 + 1e-10) + assert revenue >= 0.0 and transfer >= 0.0 # steady-state flow identity of the reserve G = (1 + p_ss.g_n_ss) * np.exp(p_ss.g_y) assert np.isclose( - G * Z, (1 + fdc["r_p"]) * Z + fdc["fdc_spread"] - revenue + G * Z, + (1 + fdc["r_p"]) * Z + fdc["fdc_spread"] - revenue + transfer, ) - # the reserve pays revenue to the government only at the ceiling - if at_cap: - assert np.isclose(Z, Z_max) and revenue > 0.0 + if bound == "ceiling": + assert np.isclose(Z, Z_max) and revenue > 0.0 and transfer == 0.0 + elif bound == "floor": + assert fdc["fdc_spread"] < 0.0 + assert Z == 0.0 and revenue == 0.0 + assert np.isclose(transfer, -fdc["fdc_spread"]) else: - assert Z < Z_max and np.isclose(revenue, 0.0) + assert 0.0 < Z < Z_max and revenue == 0.0 and transfer == 0.0 diff --git a/tests/test_aggregates.py b/tests/test_aggregates.py index 064ea02a3..f7329972f 100644 --- a/tests/test_aggregates.py +++ b/tests/test_aggregates.py @@ -2140,22 +2140,31 @@ def test_get_pension_reserves(r_p, spread, Z_expected): """ The reserve follows its steady-state flow identity, settles below the ceiling only when r_p is below the growth rate, never exceeds - the ceiling or falls below zero, and pays revenue only at a bound. + the ceiling or falls below zero, pays revenue to the government + only at the ceiling, and receives a transfer from the government + only at the floor. """ p_z = Specifications() Y = 2.0 G = (1 + p_z.g_n_ss) * np.exp(p_z.g_y) - Z, revenue = aggr.get_pension_reserves(r_p, spread, Y, p_z, "SS") + Z, revenue, transfer = aggr.get_pension_reserves( + r_p, spread, Y, p_z, "SS" + ) Z_max = p_z.pension_reserve_max_GDPratio * Y - assert np.isclose(G * Z, (1 + r_p) * Z + spread - revenue) + assert np.isclose(G * Z, (1 + r_p) * Z + spread - revenue + transfer) assert 0.0 <= Z <= Z_max + 1e-12 + assert revenue >= 0.0 and transfer >= 0.0 + assert revenue == 0.0 or transfer == 0.0 if Z_expected == "cap": - assert np.isclose(Z, Z_max) and revenue > 0 + assert np.isclose(Z, Z_max) and revenue > 0 and transfer == 0.0 elif Z_expected == "interior": assert 0.0 < Z < Z_max assert np.isclose(Z, spread / (G - 1 - r_p)) - assert np.isclose(revenue, 0.0) + assert np.isclose(revenue, 0.0) and np.isclose(transfer, 0.0) + elif spread < 0.0: + # the floor binds: the government covers the shortfall + assert Z == 0.0 and revenue == 0.0 and transfer == -spread else: - assert Z == 0.0 and revenue == spread + assert Z == 0.0 and revenue == 0.0 and transfer == 0.0 with pytest.raises(NotImplementedError): aggr.get_pension_reserves(r_p, spread, Y, p_z, "TPI") From 3fe1b38ac2f384f74c70c61aa7c0b24bb09aea4c Mon Sep 17 00:00:00 2001 From: Richard Evans Date: Thu, 19 Nov 2026 03:06:06 -0700 Subject: [PATCH 3/3] Updated uv.lock --- uv.lock | 162 ++++++++++++++++++++++++++++---------------------------- 1 file changed, 81 insertions(+), 81 deletions(-) diff --git a/uv.lock b/uv.lock index a871a9f95..50133a942 100644 --- a/uv.lock +++ b/uv.lock @@ -438,11 +438,11 @@ wheels = [ [[package]] name = "cloudpickle" -version = "3.1.2" +version = "3.1.3" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/27/fb/576f067976d320f5f0114a8d9fa1215425441bb35627b1993e5afd8111e5/cloudpickle-3.1.2.tar.gz", hash = "sha256:7fda9eb655c9c230dab534f1983763de5835249750e85fbcef43aaa30a9a2414", size = 22330, upload-time = "2025-11-03T09:25:26.604Z" } +sdist = { url = "https://files.pythonhosted.org/packages/59/df/0bf7ef6c2534c140bb4c3d787e1557542e50a96b393659efaa4f39f9a45a/cloudpickle-3.1.3.tar.gz", hash = "sha256:cbe9fde14429a5db009ea05ce94e5182cf998c97b96918d50c10f73f9c2f4f33", size = 22576, upload-time = "2026-11-18T10:27:18.82Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/88/39/799be3f2f0f38cc727ee3b4f1445fe6d5e4133064ec2e4115069418a5bb6/cloudpickle-3.1.2-py3-none-any.whl", hash = "sha256:9acb47f6afd73f60dc1df93bb801b472f05ff42fa6c84167d25cb206be1fbf4a", size = 22228, upload-time = "2025-11-03T09:25:25.534Z" }, + { url = "https://files.pythonhosted.org/packages/a4/42/3b121b42b114919ffc6195a81c1c7065a465f62f46477fbdb87a07699e51/cloudpickle-3.1.3-py3-none-any.whl", hash = "sha256:1654f4f18e416447210a63c5c25a135d65a292156aa5fa519dfa4baf7726dddb", size = 22399, upload-time = "2026-11-18T10:27:17.534Z" }, ] [[package]] @@ -1954,75 +1954,75 @@ wheels = [ [[package]] name = "numpy" -version = "2.5.4" -source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/95/b0/c7453d0b6e2073c3264468b106ee1563750cecc910965e67357e3698c83e/numpy-2.5.4.tar.gz", hash = "sha256:9a94cf751c9ad8ebaa835bcd3d40dacf8534ad086b88c38029b65123c7999d2a", size = 20866315, upload-time = "2026-10-10T20:05:31.422Z" } -wheels = [ - { url = "https://files.pythonhosted.org/packages/d0/97/ba2074e92b7befea137e77ea8471e768bbd87c339b7e8c9f5a931949f977/numpy-2.5.4-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:c6342f54c67093cae5c0227eb0eb772fdb79f2a2c37a6eb278b9909ee06aa356", size = 17001609, upload-time = "2026-10-10T20:02:40.843Z" }, - { url = "https://files.pythonhosted.org/packages/ff/a9/bac826765e971d8e16e2064e9ac7525fd69b40ac17c905033a7f5442023f/numpy-2.5.4-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b11e8fda06a7d69f15ebf542660b74466c2e51094800c1fb794f47ad4faeef17", size = 12015718, upload-time = "2026-10-10T20:02:43.45Z" }, - { url = "https://files.pythonhosted.org/packages/31/2f/5ea3570fcb8ccd0882bea99436a513b2c85dad8f774a2057849130a8fb99/numpy-2.5.4-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:9cb18a327b49c5c337f972b03682f6a49855525faaf3c0d3e9c96cd0fd8880a8", size = 5451717, upload-time = "2026-10-10T20:02:46.169Z" }, - { url = "https://files.pythonhosted.org/packages/34/f2/b4fc1bafca03868220b5eaf729d2f21ebd7d7b151c0f9e144fe212bbca35/numpy-2.5.4-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:aec3fc4b32ff82421274f5d205c559c51c840c8df66a78efd7f3612dd005a26a", size = 6789926, upload-time = "2026-10-10T20:02:48.139Z" }, - { url = "https://files.pythonhosted.org/packages/dc/96/8319e2457ae4333c62c815c7006b869a4f60985c1e01024c2f8c6c040fe5/numpy-2.5.4-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:fe4d21ab149f15e4e6043dfb0de87e6e5f34ac176cde83060e9802981fca2ac2", size = 15695312, upload-time = "2026-10-10T20:02:50.115Z" }, - { url = "https://files.pythonhosted.org/packages/43/a3/c799c62e19c337e6d3770b08e475887fb30ce8477d3c09efca6b2f0228a6/numpy-2.5.4-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:fbde6962867ee75b48b0ee29b2b9372ec5d617799dbaf38e82dc0596f2f7738a", size = 16727283, upload-time = "2026-10-10T20:02:53.186Z" }, - { url = "https://files.pythonhosted.org/packages/39/6b/3604e53fb00314d0dc1b94ec9125a1484f649c0a17480b1f0f0c7a9d6250/numpy-2.5.4-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:381a7a3d2e65e64c0ec302795ab9dc12bb1e73f150904699c153716177eebdaf", size = 17047890, upload-time = "2026-10-10T20:02:56.038Z" }, - { url = "https://files.pythonhosted.org/packages/4a/7a/e8b58a5289a0d464c52885de47c35a935cdd70c03a4c3ab94a5126416dd0/numpy-2.5.4-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:b89d0aaae2fe498c648f4c4795c084db535af5bd98ef942b2a3681fb74ce8645", size = 18485839, upload-time = "2026-10-10T20:02:59.018Z" }, - { url = "https://files.pythonhosted.org/packages/6f/c9/47094f597015009f310b8c900def59065ef1ff5a6fe7b51fc65ec58ec2c6/numpy-2.5.4-cp312-cp312-win32.whl", hash = "sha256:9968ab7e49b93ac6e1c3b2239732183152c9150f16308d30b66a372cffe3483c", size = 6138936, upload-time = "2026-10-10T20:03:01.626Z" }, - { url = "https://files.pythonhosted.org/packages/12/33/fefe62073dc8acfd0f2b9ed7c003af2f50aa61555e113e6db02b8f79f145/numpy-2.5.4-cp312-cp312-win_amd64.whl", hash = "sha256:a7b1b6353e36a7e50de2973a38d705c88ee93adcf120673cee7f45a4a3fa223a", size = 12573091, upload-time = "2026-10-10T20:03:04.349Z" }, - { url = "https://files.pythonhosted.org/packages/1a/07/161270b0c2eec56e4c905f6d6d22e1b836887b2cb189d3f5820aa588e9dd/numpy-2.5.4-cp312-cp312-win_arm64.whl", hash = "sha256:aa1cce2ff3f8d953de38b76bf44602caeb69f101430208f64a10067f7cb4b1d3", size = 10521630, upload-time = "2026-10-10T20:03:06.767Z" }, - { url = "https://files.pythonhosted.org/packages/67/14/1c3ee0118a8fce08565a5d8482631608426a33af10a01077fada5dc7c119/numpy-2.5.4-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:2377da2dd3ba2c1200956acbab2a358c83b8e1f8531191672d1cd6ad83250d53", size = 16997729, upload-time = "2026-10-10T20:03:09.291Z" }, - { url = "https://files.pythonhosted.org/packages/83/8c/b0ea9477fb1f0d4484bbc5cba21678cc9969704d8d7f3f158d1db35f8e14/numpy-2.5.4-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7415db95818b39ec475a5eea54d9e3b6bc83e3912158e46da3438cdce399804d", size = 12009826, upload-time = "2026-10-10T20:03:11.946Z" }, - { url = "https://files.pythonhosted.org/packages/e2/84/6a3d75b3ba3dfe84ac0053450753d1e6d250a8bf80f66474cc46d1fb643f/numpy-2.5.4-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:6d6a71b9d9a97c03633aa12565ef2825ffa036cc1d99cfd50dacf0f128af4fe2", size = 5445803, upload-time = "2026-10-10T20:03:14.329Z" }, - { url = "https://files.pythonhosted.org/packages/61/18/bb993f267ca20b376e07092a16793a5b31ed3138751e9ba480011a14d742/numpy-2.5.4-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:d8200f16437b289a5bb927c6e184eccc3e8389bc0070fea4cd5b9e13c1757959", size = 6786220, upload-time = "2026-10-10T20:03:16.602Z" }, - { url = "https://files.pythonhosted.org/packages/db/b6/135bb0953b61dc21c6cafa14b424ae666944e4899cf140e00c2b322a1a45/numpy-2.5.4-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:1c2e71b04c6cad90026e544501bbe0ab9290fa8a4d845e7e8c0d124fb429c988", size = 15689178, upload-time = "2026-10-10T20:03:18.721Z" }, - { url = "https://files.pythonhosted.org/packages/da/24/3bd070f3269dc609d8f26b2643f62ef91bb415841c0b294805aaf7fe06da/numpy-2.5.4-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:6ffa07666f8da0eef81d149934a626d0d95fbd6838432a33e66245423a9062c0", size = 16718044, upload-time = "2026-10-10T20:03:21.386Z" }, - { url = "https://files.pythonhosted.org/packages/c7/8e/9d15bd356b0a019c965312b1a3c6a727cac4cae5bc40045fbc12ce4cff9c/numpy-2.5.4-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:2fa3328f784fc8277fc48026f6cad516f5c561c5d8e2e39b3c9e0c8f23223b34", size = 17048364, upload-time = "2026-10-10T20:03:24.468Z" }, - { url = "https://files.pythonhosted.org/packages/dc/fe/9d5b560db964f15871885f2250795d15945f8699e17ef90c0c2ff4c875b2/numpy-2.5.4-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:b86966fbe4ad7de710422175572bcdc75fdedadfb54bc6fab7deabccddd7780b", size = 18474904, upload-time = "2026-10-10T20:03:27.895Z" }, - { url = "https://files.pythonhosted.org/packages/e9/98/d27552990f1bd611ef3e7466adadc78312ea2df63b83aad47fdc3d3ca8df/numpy-2.5.4-cp313-cp313-win32.whl", hash = "sha256:5258bc06526964be5face2fc6f756857a3f24f21ec3e72ca131337a75b165d6c", size = 6134537, upload-time = "2026-10-10T20:03:30.511Z" }, - { url = "https://files.pythonhosted.org/packages/90/8c/140a40398a66b4471211be1affdb6ed24c486d581bd28d07b7f2fcb69540/numpy-2.5.4-cp313-cp313-win_amd64.whl", hash = "sha256:8b4d2fd2d34e5f8c9235ee787de5631a37a28402b15cb80814df973d2be54129", size = 12566113, upload-time = "2026-10-10T20:03:32.612Z" }, - { url = "https://files.pythonhosted.org/packages/34/52/01d205e5e8ccb27b2b0b141e801f22b830198c979111b0fa44771438d9a9/numpy-2.5.4-cp313-cp313-win_arm64.whl", hash = "sha256:bc39ac66a7a9a3fbd6134fda43136b60ffde99c8f4501e64e0d2b24da137babf", size = 10519523, upload-time = "2026-10-10T20:03:35.163Z" }, - { url = "https://files.pythonhosted.org/packages/99/ba/005cb5edd580d2f84d7ca3206b92dc17d4388e56e6f87ffe8f2762f83139/numpy-2.5.4-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:c668b2f0d651605b58892644b0e302c7157f7159544227758c896982ef384b18", size = 17005499, upload-time = "2026-10-10T20:03:37.961Z" }, - { url = "https://files.pythonhosted.org/packages/f3/49/fee7587c33ee35f7977f9051d7f2023d4e7246d62710c80f20c2361ea232/numpy-2.5.4-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:ffa6ce09a1c6a08e9667dd9c97aa0b14184e8d18f2a14b78b2a2328c9147f076", size = 12019666, upload-time = "2026-10-10T20:03:40.606Z" }, - { url = "https://files.pythonhosted.org/packages/d5/b2/c6ce165acffceb15a82c07b9cc77d391f86b3f379ba62911908ae5d34b91/numpy-2.5.4-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:956555e0603a4d38019ae6925711cb9dc43195c076a928accf7ea5d50bddfe53", size = 5455617, upload-time = "2026-10-10T20:03:43.138Z" }, - { url = "https://files.pythonhosted.org/packages/77/7f/dd85ce260a669a89be06842cf355d7353a33e6cfbc590fb8ebb947d88dc9/numpy-2.5.4-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:2c2c4afffdeb7920e445028dd71eb932cac3e704792e964bc2a232426d4f1255", size = 6791932, upload-time = "2026-10-10T20:03:44.874Z" }, - { url = "https://files.pythonhosted.org/packages/63/d6/34b0a2b0741386a63025a65a2c09caaaaaad6d0ca95b66cd65c30dd7fcb5/numpy-2.5.4-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:4054173604cd8658796053f1f3bc0befb68ec1c0762c57fdad61e199256a8617", size = 15710899, upload-time = "2026-10-10T20:03:46.839Z" }, - { url = "https://files.pythonhosted.org/packages/16/d5/928078d2b28f26829b138b4a6c3980045022fb409f570657a224ae60ef4e/numpy-2.5.4-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:d549420b8858885cea8838a727842249218b9c1da24dd517e25c9c7a948310a3", size = 16721710, upload-time = "2026-10-10T20:03:49.489Z" }, - { url = "https://files.pythonhosted.org/packages/f9/cf/673fd1b8f4cd78eb6320e87ec4c90ac19c095644259e3749853a405c70f4/numpy-2.5.4-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:823874a507a84af050493b622affde94b6f7c3a0dc22cb2801381bc03b871c00", size = 17066182, upload-time = "2026-10-10T20:03:52.25Z" }, - { url = "https://files.pythonhosted.org/packages/f3/92/a77b5061b1b3e2643928c37976d79ee173e1b171ed158b7a3c61056b41bc/numpy-2.5.4-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:4e263278bfb5ee6409db8aedbc4cc32973b1b82bc1e8d3c668551d04d83a7e37", size = 18480315, upload-time = "2026-10-10T20:03:55.39Z" }, - { url = "https://files.pythonhosted.org/packages/bb/1d/1486ef3d3fb2279fd93c4c43c1bbbf1ca389a19816696684409f71babaab/numpy-2.5.4-cp314-cp314-win32.whl", hash = "sha256:cfd73180400042a7c532d30c5e287bdd03c59ff9ee1b4c0316af0539e29dfe23", size = 6185739, upload-time = "2026-10-10T20:03:58.186Z" }, - { url = "https://files.pythonhosted.org/packages/52/9a/e1e512ebc948d5b9dd33b08736760f0ebbed2848fd4eda1f553088a6dcee/numpy-2.5.4-cp314-cp314-win_amd64.whl", hash = "sha256:2ca144f15135b6212a5c47b1e2aeca6e412f102f95a2d5d88d8aec77eb255de3", size = 12703552, upload-time = "2026-10-10T20:04:00.28Z" }, - { url = "https://files.pythonhosted.org/packages/2c/05/de709a982d7bbcd688a3fad71f002e9ff80c2db39e03ee726609b610f1d1/numpy-2.5.4-cp314-cp314-win_arm64.whl", hash = "sha256:468397ba3c64427474706e5c9123fe266395496714dc684294eac75cd4930d1e", size = 10803901, upload-time = "2026-10-10T20:04:02.659Z" }, - { url = "https://files.pythonhosted.org/packages/13/34/083570ada3bb2a30fbe5d77c8c6fef9141144a15d33e6f793a67e9749ab8/numpy-2.5.4-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:1ef3aa6d7e29bb13677323114280b05acc57607fa2300e66432d665d5418a162", size = 12138695, upload-time = "2026-10-10T20:04:05.012Z" }, - { url = "https://files.pythonhosted.org/packages/94/06/1f9c24db48eef0c2d1207e3b11fffb0478e39dfd8c1e1be7476936885eed/numpy-2.5.4-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:98b053943e5a0474ec0da309d2cb9d3f18ea57f8a2067c2ab7b5f763d1068380", size = 5574615, upload-time = "2026-10-10T20:04:07.316Z" }, - { url = "https://files.pythonhosted.org/packages/da/0f/593fba2e1560e949123bc7d2fc48b5893d56e58cd4bd5a273d2fbf60b220/numpy-2.5.4-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:b64a85f40e154983960a4167d4c1d57a50c7f109b3d3264a3a984154e90a8454", size = 6889383, upload-time = "2026-10-10T20:04:09.918Z" }, - { url = "https://files.pythonhosted.org/packages/eb/9f/b799dfdce4e05e80ed4bc815c71ff343a11533b2c0ffc221cae8538cda63/numpy-2.5.4-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a813ed7719bf45463c51779e6a98d0385fe905e48447526938a4b8337333d551", size = 15753763, upload-time = "2026-10-10T20:04:12.278Z" }, - { url = "https://files.pythonhosted.org/packages/34/88/16c5f12f86f5ad2817c4d103205131fc6c8acb3d1878af05a1a4f23ec859/numpy-2.5.4-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c9b80cdf5cedba0e90d93fa5f9a333c4d65bd545cd669b71bb97ce2b703c9d73", size = 16757212, upload-time = "2026-10-10T20:04:14.799Z" }, - { url = "https://files.pythonhosted.org/packages/ff/4f/a1fe40e18a898e6a5089f4f0d891f0a493eb0574d5b34458f0fbe5aa3e5c/numpy-2.5.4-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:2199ed071f460487c8db2c0e5c0b564494190edb4772fe80f9aad88b2604def5", size = 17116471, upload-time = "2026-10-10T20:04:17.58Z" }, - { url = "https://files.pythonhosted.org/packages/aa/46/e923a11c78e65c1722e7aaad817c06bd591324174b9d28ce5d31eee4d432/numpy-2.5.4-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:64f9c9878c1938476365e11ccfb6b770f3b9e5f045ccddc514235041e6959365", size = 18524063, upload-time = "2026-10-10T20:04:20.365Z" }, - { url = "https://files.pythonhosted.org/packages/5a/fa/84ab064514440c1f64a1b21088f2c82756defdd05e07c75ab233899565b2/numpy-2.5.4-cp314-cp314t-win32.whl", hash = "sha256:64d1c8ac28a4077cf987e0a71a7a0ef7e2df70722f07f0baa42dbb7eb6938647", size = 6340926, upload-time = "2026-10-10T20:04:22.865Z" }, - { url = "https://files.pythonhosted.org/packages/7e/7e/6cd886876f435b10685db9b9f7eeb70356f99e052116f4e5f11c5792c714/numpy-2.5.4-cp314-cp314t-win_amd64.whl", hash = "sha256:067374eb538c34c745436365cf7b0112595c1d326f21ce4ff340f61230239fbb", size = 12901584, upload-time = "2026-10-10T20:04:24.99Z" }, - { url = "https://files.pythonhosted.org/packages/38/1b/3c1684f6a06f7307f2335fca6e486cb162847fb97e91d65f8eb5cabad213/numpy-2.5.4-cp314-cp314t-win_arm64.whl", hash = "sha256:e94aef2c639da4a960ad0db8e06471208d8589974953d78b61d345b4eb99e394", size = 10891152, upload-time = "2026-10-10T20:04:27.52Z" }, - { url = "https://files.pythonhosted.org/packages/08/f4/3224deff3af2bef6bc0b175369698d8cb348f3d91d9bb0286cd5c9eae9e0/numpy-2.5.4-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:8dddfbee2e68d26d0d7d7d9cb247b1fd4409241cce32d815a11d97ec2cfde179", size = 17003231, upload-time = "2026-10-10T20:04:30.021Z" }, - { url = "https://files.pythonhosted.org/packages/be/75/fee0b8c6d94b44b2fdfae74f6a4ad5a138739589a8aebaec28ce4e713ed5/numpy-2.5.4-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:81e3420b27048b65eb14c3acf0c174a8cb0e023277716110347d2dcb26026dad", size = 12018300, upload-time = "2026-10-10T20:04:32.519Z" }, - { url = "https://files.pythonhosted.org/packages/47/c0/d0b335a499a04b65f532c3f034346ef390f81299060f928492dabc1e0272/numpy-2.5.4-cp315-cp315-macosx_14_0_arm64.whl", hash = "sha256:0b4724a19de67bea8cfc4970798efa78bcbbe2ac2613cfac16721a42d44de2a5", size = 5454250, upload-time = "2026-10-10T20:04:34.943Z" }, - { url = "https://files.pythonhosted.org/packages/5a/0e/461b3783c03d668052e6a21b01b673db6ffcb7831fd32d9aa5368c1cd426/numpy-2.5.4-cp315-cp315-macosx_14_0_x86_64.whl", hash = "sha256:2132418bf8dd124a427ca9e6a1daf9ee1a87185344c95119ceae868b99466da1", size = 6789644, upload-time = "2026-10-10T20:04:37.258Z" }, - { url = "https://files.pythonhosted.org/packages/b3/02/5dad269b02166965a7b4ca14adaddd75dbee0de42435bfecf561b84ba5a6/numpy-2.5.4-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:325518d4245b9e331387702aa58c2ce1dc4cdcbb41dfb4ccd5dcbc7e08db1266", size = 15704353, upload-time = "2026-10-10T20:04:39.616Z" }, - { url = "https://files.pythonhosted.org/packages/93/3a/01360c8036822ed9f7aa32189a77d1476567ec1e8e1383522389e4faac45/numpy-2.5.4-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:56733449d2544178beaa4545cee357370440cf056c197f9c7bfb19dbfdd0e86d", size = 16718648, upload-time = "2026-10-10T20:04:42.383Z" }, - { url = "https://files.pythonhosted.org/packages/7d/5c/b863a2c093c4d6f21a597fcaf24ead0835c09ab16a8312d5a5a8868af683/numpy-2.5.4-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:5ec3753760c1a6d8bb91200666e545c3a9728e6269dfb5d6ce02340996698aa3", size = 17059053, upload-time = "2026-10-10T20:04:44.976Z" }, - { url = "https://files.pythonhosted.org/packages/0a/60/ced4f57f9a1258a0af74f17cb0b0c2700b5c67cd6678823c803b263e4df3/numpy-2.5.4-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:b1185012870173de7ae33d370bd45b1cf5baee747ea4b97036b65f4e93016877", size = 18477406, upload-time = "2026-10-10T20:04:47.863Z" }, - { url = "https://files.pythonhosted.org/packages/f9/bd/0ef22dafaafcc7d4bb3ca26b8d2afbd55dedad8eaba99a8c864e1997456f/numpy-2.5.4-cp315-cp315-win32.whl", hash = "sha256:298eca75243f2cbbfdb460560b9fb2a1792a33cf2ab4286efd43d92e8d3df508", size = 6185133, upload-time = "2026-10-10T20:04:50.467Z" }, - { url = "https://files.pythonhosted.org/packages/50/bc/d2651b155ecc608a77e6f4d15495c11f14f19bb98f8bf0c5b0d38f86dda1/numpy-2.5.4-cp315-cp315-win_amd64.whl", hash = "sha256:332f3378fe077dd850e677ec01bdcc4f22368fb5d50ef10b2c79230b1bf5a592", size = 12703085, upload-time = "2026-10-10T20:04:52.63Z" }, - { url = "https://files.pythonhosted.org/packages/dc/d2/45e404f8abb26fb9eda12b94012936873e827b1be76f2ee7890be128312e/numpy-2.5.4-cp315-cp315-win_arm64.whl", hash = "sha256:d4cccbbc78717966f764cd3af4fb70276fa01fc7a2688af11c78901fa5c04f05", size = 10801451, upload-time = "2026-10-10T20:04:55.677Z" }, - { url = "https://files.pythonhosted.org/packages/c6/c3/2ae14e09cfdb67dc187a342e15308a21c15bf4d2071f8079e6aee5fe56dc/numpy-2.5.4-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:950ea81d57ef070665581b6e1b5f6a029306423cd1739c5b95fe78aa30db6b9d", size = 17097121, upload-time = "2026-10-10T20:04:58.403Z" }, - { url = "https://files.pythonhosted.org/packages/f5/cf/305ae624ef8a039414317224abe9ec9c2fe7ea3c2e1cf204d43ff6b2ffb9/numpy-2.5.4-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:c05ede731b03fb1b7591faca9389ade3267d2bddf1ad8882bb3f2cc5e101694f", size = 12135439, upload-time = "2026-10-10T20:05:01.65Z" }, - { url = "https://files.pythonhosted.org/packages/a9/a8/f75c63813aef95827bb2c0d13b12803016853056e8792c280058cdbfe783/numpy-2.5.4-cp315-cp315t-macosx_14_0_arm64.whl", hash = "sha256:5fbf7141bbfd63aea22f435c9062a032b9ea0082fe9845dad7f021d3f1234e71", size = 5571451, upload-time = "2026-10-10T20:05:04.135Z" }, - { url = "https://files.pythonhosted.org/packages/6f/0f/f17763f983868b5c49b4101ebd7e00760bd1769478a6bb6a8de6e085bbac/numpy-2.5.4-cp315-cp315t-macosx_14_0_x86_64.whl", hash = "sha256:3573cd22564692a5b899ec344e5d5b9cc4576f2985b96f22af3564ed54f2710f", size = 6883356, upload-time = "2026-10-10T20:05:06.249Z" }, - { url = "https://files.pythonhosted.org/packages/67/a7/8af04c5a79e047996cfa38854dcfbececdd0343a7c933a46fdd03ef6f5da/numpy-2.5.4-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:6c109eac9cd439193678f69d70733c1108487546ca8eafc107b510ae10c1aecd", size = 15750991, upload-time = "2026-10-10T20:05:08.376Z" }, - { url = "https://files.pythonhosted.org/packages/57/7a/648254290d0c504faa8f2d07aa206660c728802c781a6f3fc68ab7cb5d71/numpy-2.5.4-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:80d6ef6e8620eb2c2b4c4caad50b5935d6db3cde2d51581b55dcc79e14016d1d", size = 16757675, upload-time = "2026-10-10T20:05:11.393Z" }, - { url = "https://files.pythonhosted.org/packages/b8/fe/4a8c3cdb0c70400cfe4c5bec42d3099a5673802a95064614b33e07b82aa1/numpy-2.5.4-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:77045a4b175bbf5316ec08003880804336c78f92281a1b72222b274ea85ec5ac", size = 17113846, upload-time = "2026-10-10T20:05:14.49Z" }, - { url = "https://files.pythonhosted.org/packages/1b/7e/619692bb67778702c0e9eb2d468568a7573f4e269386ea61aed01ee4e557/numpy-2.5.4-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:0f02a46e49cfb6c73bdb7aea1c0d3461dbae9aba613542b65f657cd3d17b9fab", size = 18522915, upload-time = "2026-10-10T20:05:17.33Z" }, - { url = "https://files.pythonhosted.org/packages/b7/b5/4da41c328788f575838f97a098fe8ca691ebc6f6fd73ad4a262ee40b184d/numpy-2.5.4-cp315-cp315t-win32.whl", hash = "sha256:ad62a416ddcf863bf44bba76fbf6b53366ab0692e294f51cae4b5fbe0d246788", size = 6335804, upload-time = "2026-10-10T20:05:19.921Z" }, - { url = "https://files.pythonhosted.org/packages/98/94/6482ddfa3d312490cb9358f375bf2ad56427dbea8769187158e94d653753/numpy-2.5.4-cp315-cp315t-win_amd64.whl", hash = "sha256:38f47be9f74ab870d2633b5456ae519c43758a8d1fd05342f0ce4ecc034396ee", size = 12890095, upload-time = "2026-10-10T20:05:21.875Z" }, - { url = "https://files.pythonhosted.org/packages/48/7f/c2d1b436b6e7cfebac140c2579a298344b85f2991a2ce5c3615cefb29400/numpy-2.5.4-cp315-cp315t-win_arm64.whl", hash = "sha256:7a14a461d9340f1b46b8648578aed9cdb8b3b018a8fac6c1dde2c9192a01a87f", size = 10883718, upload-time = "2026-10-10T20:05:28.547Z" }, +version = "2.5.5" +source = { registry = "https://pypi.org/simple" } +sdist = { url = "https://files.pythonhosted.org/packages/4e/3a/8770c288c47f0b5c2a786d3c20e79f66fd245f2d42cd232d7cd5e00e83e5/numpy-2.5.5.tar.gz", hash = "sha256:5cddc243c75114ba845f01b1f87aca1572dbf7b6c2d88636ed3e1d2bccd7f1bf", size = 20873892, upload-time = "2026-11-15T21:32:28.607Z" } +wheels = [ + { url = "https://files.pythonhosted.org/packages/20/74/5b99f425938870958d43dc9f7b17c684e793ce47ec46b7885cdc7acea285/numpy-2.5.5-cp312-cp312-macosx_10_13_x86_64.whl", hash = "sha256:7da9a248f149cfbb220c6da964a59c8d051d516704f7758acfb81eb382a05d97", size = 14750374, upload-time = "2026-11-15T21:30:10.113Z" }, + { url = "https://files.pythonhosted.org/packages/5c/f4/06db317e93dd6d618786004c1761214b113832bb77294c8513776956702a/numpy-2.5.5-cp312-cp312-macosx_11_0_arm64.whl", hash = "sha256:b96e9ee49ccbdb5676359f852a4497f7a9c5df6c377d8877f5330d6fd3ff42e4", size = 10749920, upload-time = "2026-11-15T21:30:13.092Z" }, + { url = "https://files.pythonhosted.org/packages/8a/92/6de34324a266b73c04ba977db5864b9016500076b26f09078a565f527d34/numpy-2.5.5-cp312-cp312-macosx_14_0_arm64.whl", hash = "sha256:a3856a97e48ed8371c680fb04120b99fbcc29f2076ebe6dc3deb34f77947c5ca", size = 5513680, upload-time = "2026-11-15T21:30:15.201Z" }, + { url = "https://files.pythonhosted.org/packages/1e/a1/6563b74cd67e3873f9897afebb3244529b1494d4c0df30f3201329a7e316/numpy-2.5.5-cp312-cp312-macosx_14_0_x86_64.whl", hash = "sha256:f5e8603f0892d1b848e12124863b5b29af72383ee9b25ddc6fe4967d4c1ee6ef", size = 6797540, upload-time = "2026-11-15T21:30:17.172Z" }, + { url = "https://files.pythonhosted.org/packages/c2/22/82184e9a5b50a4a298e9f8fe0bd8cfc483672dbfea8a3b57c78e2376b139/numpy-2.5.5-cp312-cp312-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a0750f2156d53446caca85663d0b65d67214e1664b9050454a731ea1418d176a", size = 15284117, upload-time = "2026-11-15T21:30:19.167Z" }, + { url = "https://files.pythonhosted.org/packages/99/61/522b973ba38987b22a4a71beaed2ea6ac9fd4f687baaa2bc9a45100625e0/numpy-2.5.5-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:704d819265e5d1064d932968e9ee85fff2103ccc78c05b878c06943ba27b8507", size = 15720599, upload-time = "2026-11-15T21:30:21.273Z" }, + { url = "https://files.pythonhosted.org/packages/25/cd/182cf60bd9c34e617c516f138f2f68988760062fa65fca8fcc97875cf7cf/numpy-2.5.5-cp312-cp312-musllinux_1_2_aarch64.whl", hash = "sha256:86868185bf4b6c4e5a8628ac42cfa165cd9530266c731f7dd1d11b4ad7e7cd1c", size = 16503566, upload-time = "2026-11-15T21:30:24.023Z" }, + { url = "https://files.pythonhosted.org/packages/f3/57/4fa4723e80be805f68af552731ed483974b2a11e511284a9ef6aafbcb3cf/numpy-2.5.5-cp312-cp312-musllinux_1_2_x86_64.whl", hash = "sha256:7fb87c4bcc73850ef433a0c42f096b010d3d3d284e9d00028bb030b43df3d078", size = 17082560, upload-time = "2026-11-15T21:30:26.224Z" }, + { url = "https://files.pythonhosted.org/packages/d5/0b/73d2bd5be85d3178a862e8354e2d6441b4040fadf1e7d999e01b0bdfa5c6/numpy-2.5.5-cp312-cp312-win32.whl", hash = "sha256:263b2aa236d752b18f90c5107137d24b2e3856d7db37725609f0ab5bcdb58881", size = 6146378, upload-time = "2026-11-15T21:30:28.328Z" }, + { url = "https://files.pythonhosted.org/packages/d1/71/b1ce51834c21020d189332979d38ba7350eb6cd7ca8c8ec424a663b0ca6f/numpy-2.5.5-cp312-cp312-win_amd64.whl", hash = "sha256:919eb420662b0b4ba34889df503f3d5329775b0c1d5f7e5f5af4fba8315b1e30", size = 12580189, upload-time = "2026-11-15T21:30:30.025Z" }, + { url = "https://files.pythonhosted.org/packages/c2/5e/09ae9d0d02fbfe6b160043349bbe73e6bbbbfb2565bb46146dd943687271/numpy-2.5.5-cp312-cp312-win_arm64.whl", hash = "sha256:f6622e32cb46c60bee3b2c7dd7f5c22bdc86fcb8630336b4822ec81c3986111a", size = 10535386, upload-time = "2026-11-15T21:30:32.112Z" }, + { url = "https://files.pythonhosted.org/packages/0f/fa/4ae71d860267f2f9eaf7640516f693acf61c9575d48157cdea459c0215aa/numpy-2.5.5-cp313-cp313-macosx_10_13_x86_64.whl", hash = "sha256:228e3d90e967495d61ddc79dd64e95267aae3bcf1b1c516a6186429106a0b444", size = 14747053, upload-time = "2026-11-15T21:30:34.251Z" }, + { url = "https://files.pythonhosted.org/packages/d4/9a/01a332ebb0899ddb14d782f86ed66d080463e5387a8778029462d1902019/numpy-2.5.5-cp313-cp313-macosx_11_0_arm64.whl", hash = "sha256:7e71ac4284c700afa654e2d15b1b174166710dca932f24045e5dc92001b5bda0", size = 10744599, upload-time = "2026-11-15T21:30:36.23Z" }, + { url = "https://files.pythonhosted.org/packages/03/bd/a1a721ab8da5632c811caf56b7735646a440eddbbf6e57817ae1a900c9c9/numpy-2.5.5-cp313-cp313-macosx_14_0_arm64.whl", hash = "sha256:e0cf407a83118faf0463ade48a4533982f1737c7c58aac29e08855f7d9ad2977", size = 5508218, upload-time = "2026-11-15T21:30:38.357Z" }, + { url = "https://files.pythonhosted.org/packages/9c/63/eb5311935b313926d9127ec59632cc74bdf1fa815089fba4dbee9c6dd90c/numpy-2.5.5-cp313-cp313-macosx_14_0_x86_64.whl", hash = "sha256:ac910558645a4b006f70596b450712b8564730c1b2ac10291fcedd656d321ec0", size = 6794377, upload-time = "2026-11-15T21:30:40.026Z" }, + { url = "https://files.pythonhosted.org/packages/57/06/de83b859944409bb9058bc6110581a3d7fc1f54d6df1222744911d7f6b19/numpy-2.5.5-cp313-cp313-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:ae2b8285d0b4eed24739c3ca9ec0fa424a0247489c01e1d5fe2815a599e11d33", size = 15278148, upload-time = "2026-11-15T21:30:41.819Z" }, + { url = "https://files.pythonhosted.org/packages/40/d6/68dd5a83914bbcaf32b3165993f7955979916708cb0156d1e28231e18803/numpy-2.5.5-cp313-cp313-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:824025655df929268bfe6b47ed91a00d14209a6f760847cf150be446829e1ce4", size = 15713899, upload-time = "2026-11-15T21:30:44.066Z" }, + { url = "https://files.pythonhosted.org/packages/1f/6e/a78932a1a838ce0d7d759cee2aca225054da8aa4151688edb5867b4af491/numpy-2.5.5-cp313-cp313-musllinux_1_2_aarch64.whl", hash = "sha256:4302902ebf82d37f446664757be59db53587822c8b35f16368ca69fe66ec4315", size = 16501259, upload-time = "2026-11-15T21:30:46.469Z" }, + { url = "https://files.pythonhosted.org/packages/bc/08/f4da0ebfa6b684c18f1c300b279bd706f68f3828a2c9aaa1bca54c93a16f/numpy-2.5.5-cp313-cp313-musllinux_1_2_x86_64.whl", hash = "sha256:3cedc2980b45794a6a2cfee9c8c3a80f04517082cc1d387e4cc895506c481696", size = 17077101, upload-time = "2026-11-15T21:30:48.916Z" }, + { url = "https://files.pythonhosted.org/packages/1b/81/0ccf314229450ec76363f3f6ec13d0ef54a24c53188787fc13136d6e52e6/numpy-2.5.5-cp313-cp313-win32.whl", hash = "sha256:10396f7c5ebc37d8f3cbdec44e3313912ccc2dc5841cc905de5de54ebbe8e2d3", size = 6141929, upload-time = "2026-11-15T21:30:51.528Z" }, + { url = "https://files.pythonhosted.org/packages/45/74/bb9161943fb65caf24e4bb04c788f5c7815e6cb78ac595e7f46781033c82/numpy-2.5.5-cp313-cp313-win_amd64.whl", hash = "sha256:e0608d1585557b68dcb6a70a41654f7536567960afad79d91752d2863b242b68", size = 12573354, upload-time = "2026-11-15T21:30:53.308Z" }, + { url = "https://files.pythonhosted.org/packages/ac/b0/792631d03588912e948c1249c03a78ca9af0c548670f8fd63ea014cbc14a/numpy-2.5.5-cp313-cp313-win_arm64.whl", hash = "sha256:e0b87886bb45621d9279dad4ab9f2d154b5db0b019d378c107b8f71527b06a4a", size = 10528296, upload-time = "2026-11-15T21:30:55.681Z" }, + { url = "https://files.pythonhosted.org/packages/6a/9a/f1493d897f51947644c45516ba63a67e66a7b06692f930fe37c58346cfbd/numpy-2.5.5-cp314-cp314-macosx_10_15_x86_64.whl", hash = "sha256:ab3ff087826c49d07953d0219eb00663ce5b1a0ef0a6b757e1ac041b09387428", size = 14754557, upload-time = "2026-11-15T21:30:58.008Z" }, + { url = "https://files.pythonhosted.org/packages/18/46/5d1c70b54257a56b3137d6fcc90c6db306f6177c02951eac7ebb42e7e1c7/numpy-2.5.5-cp314-cp314-macosx_11_0_arm64.whl", hash = "sha256:7ca51125c76817de53473dae31ddc17213776472761bea9cca68a1a0037a4827", size = 10754769, upload-time = "2026-11-15T21:31:00.146Z" }, + { url = "https://files.pythonhosted.org/packages/4c/e1/016c3d9c9c6e5a457d615cfbcf6bcd01a4cabde82c639776be23365186c1/numpy-2.5.5-cp314-cp314-macosx_14_0_arm64.whl", hash = "sha256:229743571f901a082f031f511dc4f926b4b4a714075d98b1ff2af62d836365ac", size = 5518338, upload-time = "2026-11-15T21:31:02.38Z" }, + { url = "https://files.pythonhosted.org/packages/12/7f/f2369b42edb1a32a7f048c2126e6ab5b8bc527308ce9eb6e680ad9c3d2e7/numpy-2.5.5-cp314-cp314-macosx_14_0_x86_64.whl", hash = "sha256:1c24be6a82f5f257afc4dbefde4c3b56dee02146dfed2be2811940e79576b237", size = 6800110, upload-time = "2026-11-15T21:31:04.211Z" }, + { url = "https://files.pythonhosted.org/packages/26/5b/5cd4b88a64bb57ca6d3bd6a9e057db445544a2179a2ebf985660e0454648/numpy-2.5.5-cp314-cp314-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:cc6eb7502facce90349b4097a26821af224aaa0ab36e78304711cdb544352882", size = 15300777, upload-time = "2026-11-15T21:31:05.967Z" }, + { url = "https://files.pythonhosted.org/packages/a4/1f/fcdce1061fba2bfb2e9bfda01fbd8132d5f7522a4f7c8e2b2f629d54ee38/numpy-2.5.5-cp314-cp314-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:c48960d420e90cf305cb1fde0d4e6082cc90512cda87a9acf0b6e04e91cf4abe", size = 15718051, upload-time = "2026-11-15T21:31:08.12Z" }, + { url = "https://files.pythonhosted.org/packages/5c/bd/9b7de1d0b747e3d1d24874b1cba374c8b0eab6c2034b785387677ecc4dba/numpy-2.5.5-cp314-cp314-musllinux_1_2_aarch64.whl", hash = "sha256:5e202d5facc9c0681834018062466d0b3eabd48c540c3570f72905c97f641a90", size = 16518123, upload-time = "2026-11-15T21:31:10.714Z" }, + { url = "https://files.pythonhosted.org/packages/66/14/60c3fc30e63876e44212392eacd4ea1bd201c29835c99f42daa04c2501e4/numpy-2.5.5-cp314-cp314-musllinux_1_2_x86_64.whl", hash = "sha256:e10e81d1db6c8fa507f61bebfd1ea383971dbc40c2005ed4db88fac5538b1ef6", size = 17079719, upload-time = "2026-11-15T21:31:13.245Z" }, + { url = "https://files.pythonhosted.org/packages/ac/b9/c0d3a63804a58823155ae221ce48afa4530e0cab8a33fcfb76a7b46b11ef/numpy-2.5.5-cp314-cp314-win32.whl", hash = "sha256:ef2a874cc70e2132c1c499268bdc34e211a715e481bc33c97b8a0190f2559295", size = 6193548, upload-time = "2026-11-15T21:31:15.602Z" }, + { url = "https://files.pythonhosted.org/packages/74/e2/494516771374b43060c1b778b371cba53d576abd3aee1275eecd73896e3b/numpy-2.5.5-cp314-cp314-win_amd64.whl", hash = "sha256:20145b11776d2f7570cd61351b156a51d3a341822282095baa819d87272bc710", size = 12710543, upload-time = "2026-11-15T21:31:17.461Z" }, + { url = "https://files.pythonhosted.org/packages/1b/e7/abe56b23f4dddf8277429d0efa442abac4c1940ec776c1b707c1e58435e8/numpy-2.5.5-cp314-cp314-win_arm64.whl", hash = "sha256:2abd39cfbb3d2af11e9bc8cc92b08cd089b0975fe9b1a30c8b7c740c67d397ce", size = 10812026, upload-time = "2026-11-15T21:31:19.692Z" }, + { url = "https://files.pythonhosted.org/packages/06/76/2974340b984ecd43bb4ee91c06a3fd59968330752c316d36fb8a23310ac1/numpy-2.5.5-cp314-cp314t-macosx_11_0_arm64.whl", hash = "sha256:f82a7567c590ff266f8c18fd527a0662edde074de11be256541a656e274f2b05", size = 10857031, upload-time = "2026-11-15T21:31:21.953Z" }, + { url = "https://files.pythonhosted.org/packages/38/d2/cc6d1f0f4c848f18e30d0f464a70598369336591920952f6aee440da4a2f/numpy-2.5.5-cp314-cp314t-macosx_14_0_arm64.whl", hash = "sha256:31e5be6cd4b896004cb9e416741612ade530fc9a04bceca5219cf66a675113b4", size = 5620763, upload-time = "2026-11-15T21:31:24.1Z" }, + { url = "https://files.pythonhosted.org/packages/c7/d0/2d014e5b68965530ebe46c0d2b07b1242210a029acba5800f53fcb4d4973/numpy-2.5.5-cp314-cp314t-macosx_14_0_x86_64.whl", hash = "sha256:b3d328eebe0056c634878c251131d73d74e0c4af317a3aea718816d6fa0bb963", size = 6897520, upload-time = "2026-11-15T21:31:25.976Z" }, + { url = "https://files.pythonhosted.org/packages/b1/ee/a0fb000c6a57602a7a2958f72a5d07837dd88cb9a158f1edb0a279126428/numpy-2.5.5-cp314-cp314t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:e99bf8a3d54693f2063fa6c7d13955d460a9f543d9dbc80e69a92da288259b28", size = 15342131, upload-time = "2026-11-15T21:31:27.707Z" }, + { url = "https://files.pythonhosted.org/packages/93/43/85cfae380e4e2fe1d246c39a12c88c7a224e751604b6fa13236df3b86600/numpy-2.5.5-cp314-cp314t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:479e43c183049ec1a820eeb36549e493924f56b3e893a1d5865d0fff12abad47", size = 15751077, upload-time = "2026-11-15T21:31:29.851Z" }, + { url = "https://files.pythonhosted.org/packages/cd/41/5938f05404d2f4531409b658cfd578b0b653a87f22915759afa7f414b4f3/numpy-2.5.5-cp314-cp314t-musllinux_1_2_aarch64.whl", hash = "sha256:9f44875964889bd9088cf838d191b58c04088d10b4dc9b140e9da2431ecfbb60", size = 16569544, upload-time = "2026-11-15T21:31:32.017Z" }, + { url = "https://files.pythonhosted.org/packages/a0/b1/75f51d9e2fb970228bd7599d46f34eb0829070b4df8b293c43fdf1c81c44/numpy-2.5.5-cp314-cp314t-musllinux_1_2_x86_64.whl", hash = "sha256:2a9c502cdb9a3050ac1686774624cc278658b11f72e11b971a3a8542d6ded357", size = 17122494, upload-time = "2026-11-15T21:31:34.267Z" }, + { url = "https://files.pythonhosted.org/packages/71/1b/68f54066eb445a98e7c677863d1ece9667151f8d8565eea5860d8445fb72/numpy-2.5.5-cp314-cp314t-win32.whl", hash = "sha256:dec156cda7322bcb1479ca992794705fe226a911b0ffebe13bff97fa1f3be63c", size = 6350011, upload-time = "2026-11-15T21:31:36.491Z" }, + { url = "https://files.pythonhosted.org/packages/58/29/c57eca063b680b23c0ca8d07789b3011a9e962fd4994a656b11f7a21226e/numpy-2.5.5-cp314-cp314t-win_amd64.whl", hash = "sha256:84dfb1611993a3525b250c955b1e2ebab6ce0ed36e4ab4dd5746432dd362fb5d", size = 12909875, upload-time = "2026-11-15T21:31:38.311Z" }, + { url = "https://files.pythonhosted.org/packages/72/06/70b2717589eb8ba57bce789c0f1e477fc5869c720fa0ad444e31fb9aef55/numpy-2.5.5-cp314-cp314t-win_arm64.whl", hash = "sha256:567994389edd2963b643d63d826138402a63401176f1daf84dbb3204eb838b39", size = 10899621, upload-time = "2026-11-15T21:31:40.518Z" }, + { url = "https://files.pythonhosted.org/packages/9c/61/8578c9fdbfb59ba2c4ee633102666937ce4e66f8c3de8bc700573c856af5/numpy-2.5.5-cp315-cp315-macosx_10_15_x86_64.whl", hash = "sha256:ad0c8b963f9281f2eb118e283eb61964c716c8e344ed8e8c309b49c586d41ed1", size = 14752489, upload-time = "2026-11-15T21:31:42.902Z" }, + { url = "https://files.pythonhosted.org/packages/a7/ef/d0f38ea7ca697c03af3d687cb70d8ddc8414dcf430f8f7194ab7359d80f6/numpy-2.5.5-cp315-cp315-macosx_11_0_arm64.whl", hash = "sha256:d7d9be35d50366fe5ac28188364154c9e1e22ad1b977a06c9465c0680c8eeefe", size = 10753050, upload-time = "2026-11-15T21:31:45.123Z" }, + { url = "https://files.pythonhosted.org/packages/84/b7/de9e6d1ffbc33cc7bcf452c7924a7953daaf06bde559b73ebef93b7f85c6/numpy-2.5.5-cp315-cp315-macosx_14_0_arm64.whl", hash = "sha256:d0c7c0dfabdcb7cde080b7c9ef301c7533e90110198b39965141a903c7dddcf8", size = 5516639, upload-time = "2026-11-15T21:31:47.537Z" }, + { url = "https://files.pythonhosted.org/packages/ac/ac/a95824882c5818a7e31893ebdab2944f5e65b4108bc8bed9e240e3c624be/numpy-2.5.5-cp315-cp315-macosx_14_0_x86_64.whl", hash = "sha256:b7dd0287b6cdd35a27d5678a56b1bc508ff206c2b78b30b4821dd5c3197b393a", size = 6797936, upload-time = "2026-11-15T21:31:49.2Z" }, + { url = "https://files.pythonhosted.org/packages/08/64/c39a7b41df0d433ff37fd4fdd6e32b3fa3b51a82110bbcd386d0e37f5da6/numpy-2.5.5-cp315-cp315-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:a207eb88a18e30add597c366c1db7e79f48fc94084b8e7dbd0eefb95a645db12", size = 15294336, upload-time = "2026-11-15T21:31:50.908Z" }, + { url = "https://files.pythonhosted.org/packages/d0/ce/ef0ca1a7dbf657a68ec52ce150cc477a7cdd8d09c7ef77662cdecbca39e4/numpy-2.5.5-cp315-cp315-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:9c3e1ac3cd5d3329f4d38709ff4c21f0621bbe8779c094d6de8ec8347246fcdc", size = 15713633, upload-time = "2026-11-15T21:31:53.261Z" }, + { url = "https://files.pythonhosted.org/packages/dd/08/023029d269a7adec40749ef98439af4260ee92bc203d8a7749cc4eee8183/numpy-2.5.5-cp315-cp315-musllinux_1_2_aarch64.whl", hash = "sha256:095113ee2ceab6a9501b184eff5ea806973d3a63d74a8cbc15e4911e754da9c1", size = 16510376, upload-time = "2026-11-15T21:31:55.401Z" }, + { url = "https://files.pythonhosted.org/packages/9f/0b/38e65a5ff61b174df3a930898a3b31e94b24caaf4155c719d18417ad63b1/numpy-2.5.5-cp315-cp315-musllinux_1_2_x86_64.whl", hash = "sha256:bea7de36bb304a850710c1dfbb35e7cdb9a005928106a3adfc6dc3a753469dec", size = 17078342, upload-time = "2026-11-15T21:31:57.714Z" }, + { url = "https://files.pythonhosted.org/packages/4d/3e/09a62f920e5869888387ba988eeba560057c1f718404cc737e5dbc07e81e/numpy-2.5.5-cp315-cp315-win32.whl", hash = "sha256:fd47c92e0d1e53f9498b1a30305072434fbae6b5a305cbcab514f959e9ce0fab", size = 6192918, upload-time = "2026-11-15T21:31:59.798Z" }, + { url = "https://files.pythonhosted.org/packages/5a/7e/a4c5b4b30dbab285b380130dbf780bccece06de020221491058ea2c66310/numpy-2.5.5-cp315-cp315-win_amd64.whl", hash = "sha256:ae9cfe4e985139c5f2db69d4310de7348bd0abc02cfdc06991c4419065f6fdca", size = 12710024, upload-time = "2026-11-15T21:32:01.352Z" }, + { url = "https://files.pythonhosted.org/packages/7d/57/bdec7de41e7442b9ea0ac938b7597f754d4d625d853551466e8a208e3e64/numpy-2.5.5-cp315-cp315-win_arm64.whl", hash = "sha256:08f1b9abf1707fa89c125aaa17e78389c063fb20ce37a141b47821e996f4a1db", size = 10814707, upload-time = "2026-11-15T21:32:03.326Z" }, + { url = "https://files.pythonhosted.org/packages/f0/e9/7f20d2144d4fbe2876d567a1ae1266cb62a67498af7d3006e2a0ba93deed/numpy-2.5.5-cp315-cp315t-macosx_10_15_x86_64.whl", hash = "sha256:3d59ab8f6bfc4ffd29b0f558450e17922c1bc88459882e37726fbcd5834afbfd", size = 14845589, upload-time = "2026-11-15T21:32:05.476Z" }, + { url = "https://files.pythonhosted.org/packages/66/02/ded297ac4c917f7cf90254a50f888f992c028e2ed9a3efd82349c12d4904/numpy-2.5.5-cp315-cp315t-macosx_11_0_arm64.whl", hash = "sha256:bf6fa5a4d73b3a9699a57b8824d4863acde7241808a5305882222843537f02a2", size = 10851494, upload-time = "2026-11-15T21:32:07.944Z" }, + { url = "https://files.pythonhosted.org/packages/c6/ac/1ae013866575827dcec6239ca413b76c05652fa5ac405afd8d904940197c/numpy-2.5.5-cp315-cp315t-macosx_14_0_arm64.whl", hash = "sha256:d64daa409e9b1ac818b0c59e47b005f802e130c8281e40c6a2f7e70c43f75e0f", size = 5615246, upload-time = "2026-11-15T21:32:09.876Z" }, + { url = "https://files.pythonhosted.org/packages/f5/e2/2d89896606a325e584157fe669578ac1b22558e4b3e45e0cb554970e5a19/numpy-2.5.5-cp315-cp315t-macosx_14_0_x86_64.whl", hash = "sha256:ff5c1ab54a637c0adcdbb69ad10e5c4f1c4dedba69c0d1de383249b70c36908f", size = 6890873, upload-time = "2026-11-15T21:32:11.545Z" }, + { url = "https://files.pythonhosted.org/packages/4f/a0/de0484dbe0665ae69cbf9c2bb777c2fa4f402e03a102384c54fe54048d44/numpy-2.5.5-cp315-cp315t-manylinux_2_27_aarch64.manylinux_2_28_aarch64.whl", hash = "sha256:178cb1eaed819b2cb4e398c554b0776d1499f307e30cb58b9bae1921de35dae6", size = 15340077, upload-time = "2026-11-15T21:32:13.223Z" }, + { url = "https://files.pythonhosted.org/packages/39/d8/60a70cb61b8063e4dfc5b8b55f93c247cb7f1a36515d810e70ca94446396/numpy-2.5.5-cp315-cp315t-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b6e30929e3443f46aa7be2749fb003fefbbad6b6a1e2168bf8850a55b657914a", size = 15752447, upload-time = "2026-11-15T21:32:15.629Z" }, + { url = "https://files.pythonhosted.org/packages/09/14/db7e8f5560a329a118bcea53da883f077bac5f00124799c5ac7e9eb1823e/numpy-2.5.5-cp315-cp315t-musllinux_1_2_aarch64.whl", hash = "sha256:2efb2ae4e0414b6bd636dde7235c158cd65dd52891ff64a320a4847a8ce7400f", size = 16566475, upload-time = "2026-11-15T21:32:17.974Z" }, + { url = "https://files.pythonhosted.org/packages/ec/33/060b8c68e2ed79fe50a20139f7f89fa2d9862f2d3e127fc353d8e6b2589c/numpy-2.5.5-cp315-cp315t-musllinux_1_2_x86_64.whl", hash = "sha256:32dce94d74bb4d5bb058d65b0d9dad7fa61d07ff9375fd7695d8aa7ea82ee73d", size = 17120613, upload-time = "2026-11-15T21:32:20.094Z" }, + { url = "https://files.pythonhosted.org/packages/99/3a/ab02c902cb380d0b950eccda4f0b67ac4f66ba490c98756d38adc4b3ccb5/numpy-2.5.5-cp315-cp315t-win32.whl", hash = "sha256:b5d08742de581c9eb61102768ccca125a2982913de399611b56981a07278de74", size = 6344124, upload-time = "2026-11-15T21:32:22.058Z" }, + { url = "https://files.pythonhosted.org/packages/fd/49/b04b1f12231e6fbcf26fd5e7949f629530e11c46a6fcd91923f61b017243/numpy-2.5.5-cp315-cp315t-win_amd64.whl", hash = "sha256:410eab02c6718cb42d06ccbb8604659f3522d2ce06ae70cacd5042092659f5af", size = 12898288, upload-time = "2026-11-15T21:32:23.871Z" }, + { url = "https://files.pythonhosted.org/packages/36/7b/935a5896b0bd441c6dd6da81f39bc5ebf8d5da891b7dcff768e1e1c088b5/numpy-2.5.5-cp315-cp315t-win_arm64.whl", hash = "sha256:b6ecbc1ff292c6799067d8064a4dd35cd25ba9d1a24aa41dd635d701691a49b5", size = 10891314, upload-time = "2026-11-15T21:32:26.357Z" }, ] [[package]] @@ -2335,11 +2335,11 @@ wheels = [ [[package]] name = "platformdirs" -version = "4.14.5" +version = "4.14.7" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/d7/9a/8475be631fb33ca1466915e70fd594c42a4e84b512db650eaa14f90fe75d/platformdirs-4.14.5.tar.gz", hash = "sha256:32e9921db7385aa8169bee4fe9501923e5715ba9fb7ea3b9c69b0d8e0639f7a1", size = 71464, upload-time = "2026-11-04T16:54:50.358Z" } +sdist = { url = "https://files.pythonhosted.org/packages/a6/2c/ec57eede0db493e61443c76ac7b4d24e94a24050afb3d598bf3678487f75/platformdirs-4.14.7.tar.gz", hash = "sha256:5472257c1cf97a14658af52997011c7e59e4aebf3a24950b973c11b579e1b074", size = 75132, upload-time = "2026-11-17T20:03:32.656Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/7c/ae/ecbbbfd0e4343a6a521d49b3c8656fb4643dee2a4f6eaf941cf3280391a8/platformdirs-4.14.5-py3-none-any.whl", hash = "sha256:8e778c6fa421516f4d3369449f8df3b0e1b72c0e0005fe88e3ec772d0a14e750", size = 35402, upload-time = "2026-11-04T16:54:48.875Z" }, + { url = "https://files.pythonhosted.org/packages/f8/46/3737af9f971f3934794103256d7f1ed6200a62be0c7b7ff09ac4cf6b3422/platformdirs-4.14.7-py3-none-any.whl", hash = "sha256:391513b74707c42335fff3ea17eaac657a7ee9ffcadd809634d34ea594d0122c", size = 89658, upload-time = "2026-11-17T20:03:31.16Z" }, ] [[package]] @@ -2353,14 +2353,14 @@ wheels = [ [[package]] name = "progressbar2" -version = "4.7.0" +version = "4.7.1" source = { registry = "https://pypi.org/simple" } dependencies = [ { name = "python-utils", marker = "python_full_version < '3.15'" }, ] -sdist = { url = "https://files.pythonhosted.org/packages/1e/dd/63ac006e821594bf6ec5cd7557f16c44d8c209108578ea01bc1f715baafc/progressbar2-4.7.0.tar.gz", hash = "sha256:f4122439b00dca41424f787ea5148478685d265742078c1c7c3ede31f06bd001", size = 751542, upload-time = "2026-11-05T10:39:31.333Z" } +sdist = { url = "https://files.pythonhosted.org/packages/d4/cb/6c2cb8c9652fdfe1bd15ae723e5e97a77316daf9b3c6835b8b35ef07ece4/progressbar2-4.7.1.tar.gz", hash = "sha256:e7e1c1b6fe6495051c41c44fc50980ba37f8d874deb94ea680528b1a0442ff1a", size = 757162, upload-time = "2026-11-17T11:11:29.153Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/3c/91/4e41878c890ff425b33135df7e97a992a55c8e96044a0d931c39d21f30bc/progressbar2-4.7.0-py3-none-any.whl", hash = "sha256:ff929d767c1fd7656bcefa7f2132aa174aa8746d7de580edfcfc1c6a738825da", size = 151038, upload-time = "2026-11-05T10:39:29.234Z" }, + { url = "https://files.pythonhosted.org/packages/f3/5f/2a28152843f3060ed2b70a722f4e5d32427a4d31c36e2ea15d59ac8f6559/progressbar2-4.7.1-py3-none-any.whl", hash = "sha256:9363f41c3d815568eda4c4ddc13903b7aa646551e7238cf2870f521678e9fe73", size = 151909, upload-time = "2026-11-17T11:11:27.482Z" }, ] [[package]] @@ -3091,11 +3091,11 @@ wheels = [ [[package]] name = "soupsieve" -version = "4.1.1" +version = "4.1.2" source = { registry = "https://pypi.org/simple" } -sdist = { url = "https://files.pythonhosted.org/packages/1f/52/ee5646b65d98a252e807ccc37725363942372a4113072e0bce7ed22f8b84/soupsieve-4.1.1.tar.gz", hash = "sha256:b296bd2d2f65b1a78149f3d7bf6736a147d2c9e2dfbde0e4404639d748a02e03", size = 169784, upload-time = "2026-11-14T17:23:32.467Z" } +sdist = { url = "https://files.pythonhosted.org/packages/17/35/bf779c1cc376bc216a2d94e3b3d9ee48347296af29bedfc6caaf96bc132f/soupsieve-4.1.2.tar.gz", hash = "sha256:c6539a2638f26991463527337e39d630e3cbb86d024f52282a510535b8a7e09f", size = 178884, upload-time = "2026-11-18T17:21:03.858Z" } wheels = [ - { url = "https://files.pythonhosted.org/packages/cd/65/7fae69a095696195334a934eab23aeb12e2715e6c3f08025d2f91942750e/soupsieve-4.1.1-py3-none-any.whl", hash = "sha256:8ff3422dab0b720fb667ee79864d80531a0e57994a13eb701697719ffcb751f6", size = 55089, upload-time = "2026-11-14T17:23:31.001Z" }, + { url = "https://files.pythonhosted.org/packages/1e/33/f5082b3c480db024453077592057200955aed2a376327b8921d553404ca7/soupsieve-4.1.2-py3-none-any.whl", hash = "sha256:96b4115212a3abee1f572d62da706cca090b088cb5effa278db5702122e63a2c", size = 59295, upload-time = "2026-11-18T17:21:02.593Z" }, ] [[package]]