policyengine-uk 2.40.1__py3-none-any.whl → 2.65.6__py3-none-any.whl

policyengine_uk/tests/policy/reforms/nov_2025_budget/income_tax_freeze.yaml

@@ -0,0 +1,83 @@
+# Tests for November 2025 Autumn Budget income tax threshold freeze extension
+# The budget extends the freeze on personal allowance, higher rate threshold, and additional rate threshold
+# from April 2028 to April 2031 (covering tax years 2028-29, 2029-30, 2030-31)
+
+# Personal allowance freeze tests
+- name: Personal allowance frozen at 12570 in 2028-29
+  period: 2028
+  input:
+    employment_income: 50000
+  output:
+    personal_allowance: 12570
+
+- name: Personal allowance frozen at 12570 in 2029-30
+  period: 2029
+  input:
+    employment_income: 50000
+  output:
+    personal_allowance: 12570
+
+- name: Personal allowance frozen at 12570 in 2030-31
+  period: 2030
+  input:
+    employment_income: 50000
+  output:
+    personal_allowance: 12570
+
+# Higher rate threshold tests (PA + basic rate band = 12570 + 37700 = 50270)
+- name: Income at 50270 pays basic rate only in 2028-29
+  period: 2028
+  input:
+    employment_income: 50270
+  output:
+    higher_rate_earned_income: 0
+
+- name: Income at 50271 pays higher rate in 2028-29
+  period: 2028
+  input:
+    employment_income: 50271
+  output:
+    higher_rate_earned_income: 1
+
+- name: Income at 50270 pays basic rate only in 2030-31
+  period: 2030
+  input:
+    employment_income: 50270
+  output:
+    higher_rate_earned_income: 0
+
+- name: Income at 50271 pays higher rate in 2030-31
+  period: 2030
+  input:
+    employment_income: 50271
+  output:
+    higher_rate_earned_income: 1
+
+# Additional rate threshold tests (125140)
+- name: Income at 125140 pays higher rate only in 2028-29
+  period: 2028
+  input:
+    employment_income: 125140
+  output:
+    add_rate_earned_income: 0
+
+- name: Income at 125141 pays additional rate in 2028-29
+  period: 2028
+  input:
+    employment_income: 125141
+  output:
+    add_rate_earned_income: 1
+
+- name: Income at 125140 pays higher rate only in 2030-31
+  period: 2030
+  input:
+    employment_income: 125140
+  output:
+    add_rate_earned_income: 0
+
+- name: Income at 125141 pays additional rate in 2030-31
+  period: 2030
+  input:
+    employment_income: 125141
+  output:
+    add_rate_earned_income: 1

policyengine_uk/tests/policy/reforms/parametric/basic_income/basic_income.yaml

@@ -21,6 +21,7 @@
     benunits:
       benunit:
         members: [working_age, senior, child]
+        would_claim_child_benefit: true
   output:
     basic_income: [52, 104, 156]
     child_benefit: 1820

policyengine_uk/tests/test_behavioral_responses.py

@@ -0,0 +1,215 @@
+"""
+Tests for behavioral labor supply responses.
+
+This test module validates that the behavioral response system works correctly
+and that all the critical fixes are functioning:
+- No more simulation state corruption from sim.reset_calculations()
+- Proper NaN handling prevents calculation errors
+- Income changes are calculated before any state modifications
+- The system correctly returns appropriate FTE responses
+"""
+
+import pytest
+import yaml
+from pathlib import Path
+from policyengine_uk import Microsimulation
+from policyengine_uk.model_api import Scenario
+
+
+# Load YAML test cases
+yaml_file = (
+    Path(__file__).parent
+    / "behavioral_responses"
+    / "test_labor_supply_responses.yaml"
+)
+with open(yaml_file, "r") as f:
+    yaml_content = f.read()
+    test_cases = yaml.safe_load(yaml_content)
+
+
+class TestBehavioralResponses:
+    """Test behavioral labor supply responses functionality"""
+
+    def test_yaml_file_structure(self):
+        """Test that YAML file loads correctly and has expected structure"""
+        assert (
+            len(test_cases) == 6
+        ), f"Expected 6 test cases, got {len(test_cases)}"
+
+        for i, test_case in enumerate(test_cases):
+            assert "name" in test_case, f"Test case {i+1} missing 'name'"
+            assert "period" in test_case, f"Test case {i+1} missing 'period'"
+            assert "input" in test_case, f"Test case {i+1} missing 'input'"
+            assert "reforms" in test_case, f"Test case {i+1} missing 'reforms'"
+            assert "output" in test_case, f"Test case {i+1} missing 'output'"
+
+    def test_obr_parameter_functionality(self):
+        """Test that OBR parameter can be enabled and disabled"""
+        # Test enabling OBR
+        scenario_on = Scenario(
+            parameter_changes={
+                "gov.dynamic.obr_labour_supply_assumptions": {"2025": True}
+            }
+        )
+        sim_on = Microsimulation(scenario=scenario_on)
+        obr_on = sim_on.tax_benefit_system.parameters.gov.dynamic.obr_labour_supply_assumptions(
+            "2025"
+        )
+
+        # Test disabling OBR
+        scenario_off = Scenario(
+            parameter_changes={
+                "gov.dynamic.obr_labour_supply_assumptions": {"2025": False}
+            }
+        )
+        sim_off = Microsimulation(scenario=scenario_off)
+        obr_off = sim_off.tax_benefit_system.parameters.gov.dynamic.obr_labour_supply_assumptions(
+            "2025"
+        )
+
+        assert (
+            obr_on == True
+        ), "OBR parameter should be enabled when set to True"
+        assert (
+            obr_off == False
+        ), "OBR parameter should be disabled when set to False"
+
+    def test_dynamics_no_crash_simple(self):
+        """Test that dynamics application doesn't crash with simple scenarios"""
+        situation = {
+            "people": {"person": {"age": 30, "employment_income": 25_000}},
+            "benunits": {"benunit": {"members": ["person"]}},
+            "households": {"household": {"members": ["person"]}},
+        }
+
+        baseline = Microsimulation(situation=situation)
+
+        scenario = Scenario(
+            parameter_changes={
+                "gov.dynamic.obr_labour_supply_assumptions": {"2025": True}
+            }
+        )
+        reformed = Microsimulation(situation=situation, scenario=scenario)
+        reformed.baseline = baseline
+
+        # Test dynamics application - may fail with bin edge error on single person
+        # This is expected behavior with minimal dataset, so we catch the specific error
+        try:
+            dynamics = reformed.apply_dynamics(2025)
+            # If successful, dynamics may be None if no income change
+            if dynamics is not None:
+                assert hasattr(
+                    dynamics, "fte_impacts"
+                ), "Dynamics should have fte_impacts attribute"
+        except ValueError as e:
+            if (
+                "Bin labels must be one fewer than the number of bin edges"
+                in str(e)
+            ):
+                # This is expected with single-person scenarios due to insufficient data for binning
+                # The important thing is that our NaN handling and state corruption fixes work
+                pass
+            else:
+                # Re-raise other ValueError exceptions
+                raise
+
+    def test_basic_behavioral_response_enabled(self):
+        """Test basic behavioral response mechanism with OBR enabled"""
+        test_case = test_cases[0]  # First test case
+
+        situation = test_case["input"]
+        reforms = test_case["reforms"]
+
+        scenario = Scenario(parameter_changes=reforms)
+        baseline = Microsimulation(situation=situation)
+        reformed = Microsimulation(situation=situation, scenario=scenario)
+        reformed.baseline = baseline
+
+        # Verify OBR is enabled
+        obr_enabled = reformed.tax_benefit_system.parameters.gov.dynamic.obr_labour_supply_assumptions(
+            "2025"
+        )
+        assert obr_enabled == True, "OBR should be enabled for this test"
+
+        # Apply dynamics - should not crash
+        dynamics = reformed.apply_dynamics(2025)
+        # Test passes if no exception is raised
+
+    def test_behavioral_response_disabled(self):
+        """Test behavioral response with OBR disabled"""
+        test_case = test_cases[3]  # OBR disabled test case
+
+        situation = test_case["input"]
+        reforms = test_case["reforms"]
+
+        scenario = Scenario(parameter_changes=reforms)
+        reformed = Microsimulation(situation=situation, scenario=scenario)
+
+        # Verify OBR is disabled
+        obr_enabled = reformed.tax_benefit_system.parameters.gov.dynamic.obr_labour_supply_assumptions(
+            "2025"
+        )
+        assert obr_enabled == False, "OBR should be disabled for this test"
+
+        # With baseline linked
+        baseline = Microsimulation(situation=situation)
+        reformed.baseline = baseline
+
+        # Apply dynamics - should return None when disabled
+        dynamics = reformed.apply_dynamics(2025)
+        assert dynamics is None, "Dynamics should be None when OBR is disabled"
+
+    def test_zero_income_handling(self):
+        """Test that zero income cases don't cause NaN errors"""
+        test_case = test_cases[5]  # Zero income test case
+
+        situation = test_case["input"]
+        reforms = test_case["reforms"]
+
+        scenario = Scenario(parameter_changes=reforms)
+        baseline = Microsimulation(situation=situation)
+        reformed = Microsimulation(situation=situation, scenario=scenario)
+        reformed.baseline = baseline
+
+        # This should not crash even with zero income
+        try:
+            dynamics = reformed.apply_dynamics(2025)
+            # Test passes if no NaN-related exceptions are raised
+        except ValueError as e:
+            if "NaN" in str(e) or "inf" in str(e):
+                pytest.fail(f"NaN/inf error in zero income handling: {e}")
+            else:
+                # Other ValueError might be expected
+                pass
+
+    @pytest.mark.parametrize("test_case", test_cases)
+    def test_all_yaml_cases_structure(self, test_case):
+        """Test that all YAML test cases have valid structure and can create simulations"""
+        situation = test_case["input"]
+        reforms = test_case["reforms"]
+
+        # Should be able to create simulations without errors
+        baseline = Microsimulation(situation=situation)
+
+        if reforms:
+            scenario = Scenario(parameter_changes=reforms)
+            reformed = Microsimulation(situation=situation, scenario=scenario)
+        else:
+            reformed = Microsimulation(situation=situation)
+
+        # Basic validation - should have people
+        assert (
+            len(situation["people"]) > 0
+        ), f"Test case '{test_case['name']}' should have people"
+
+        # Should be able to calculate basic variables
+        employment_income = reformed.calculate(
+            "employment_income", test_case["period"]
+        )
+        assert (
+            employment_income is not None
+        ), f"Should be able to calculate employment_income for '{test_case['name']}'"
+
+
+if __name__ == "__main__":
+    pytest.main([__file__])

policyengine_uk/tests/test_fiscal_year_parameters.py

@@ -0,0 +1,131 @@
+"""
+Tests for UK fiscal year parameter handling.
+
+The UK fiscal year runs April 6 to April 5. PolicyEngine UK converts
+parameters to use fiscal year values by sampling at April 30 of each year.
+
+This test suite verifies that annual period queries (e.g., param("2026"))
+return the correct fiscal year values, especially for policy changes
+that take effect on April 6.
+
+Key policy example:
+- Two-child limit repeal: limit=2 until April 5, 2026, then infinity
+  from April 6, 2026
+"""
+
+import pytest
+from policyengine_uk import CountryTaxBenefitSystem
+
+
+@pytest.fixture(scope="module")
+def uk_system():
+    """Create a UK tax-benefit system for testing."""
+    return CountryTaxBenefitSystem()
+
+
+class TestTwoChildLimitRepeal:
+    """Tests for the two-child limit repeal on April 6, 2026."""
+
+    def test_two_child_limit_fiscal_year_2025(self, uk_system):
+        """Test that the two-child limit is 2 for fiscal year 2025/26."""
+        params = uk_system.get_parameters_at_instant("2025")
+        child_limit = (
+            params.gov.dwp.universal_credit.elements.child.limit.child_count
+        )
+        assert child_limit == 2
+
+    def test_two_child_limit_fiscal_year_2026(self, uk_system):
+        """Test that the two-child limit is infinity for fiscal year 2026/27.
+
+        This is the key test case - the repeal happens on April 6, 2026.
+        When querying for "2026", the system should use April 30, 2026
+        as the reference date, which is AFTER the repeal date.
+        """
+        params = uk_system.get_parameters_at_instant("2026")
+        child_limit = (
+            params.gov.dwp.universal_credit.elements.child.limit.child_count
+        )
+        assert child_limit == float("inf"), (
+            f"Expected infinity for 2026 fiscal year, got {child_limit}. "
+            "The fiscal year conversion may not be covering 2026."
+        )
+
+    def test_annual_query_reflects_fiscal_year(self, uk_system):
+        """
+        Test that annual queries return fiscal year values.
+
+        For year 2026, the fiscal year is April 6, 2026 to April 5, 2027.
+        The two-child limit is repealed on April 6, 2026, so:
+        - 2025 should be 2 (fiscal year 2025/26)
+        - 2026 should be infinity (fiscal year 2026/27)
+        - 2027 should be infinity (fiscal year 2027/28)
+        """
+        params_2025 = uk_system.get_parameters_at_instant("2025")
+        params_2026 = uk_system.get_parameters_at_instant("2026")
+        params_2027 = uk_system.get_parameters_at_instant("2027")
+
+        limit_2025 = (
+            params_2025.gov.dwp.universal_credit.elements.child.limit.child_count
+        )
+        limit_2026 = (
+            params_2026.gov.dwp.universal_credit.elements.child.limit.child_count
+        )
+        limit_2027 = (
+            params_2027.gov.dwp.universal_credit.elements.child.limit.child_count
+        )
+
+        assert limit_2025 == 2
+        assert limit_2026 == float("inf")
+        assert limit_2027 == float("inf")
+
+
+class TestFiscalYearBoundary:
+    """Tests for fiscal year boundary behavior.
+
+    Note: After fiscal year conversion, the entire year is set to the
+    April 30 value. This means January-March dates return the fiscal
+    year value for that calendar year, not the previous fiscal year.
+    """
+
+    def test_january_2026_returns_fiscal_year_2026_value(self, uk_system):
+        """January 2026 should return fiscal year 2026/27 value.
+
+        After fiscal year conversion, the year 2026 is set to the
+        April 30, 2026 value (infinity, post-repeal).
+        """
+        params = uk_system.get_parameters_at_instant("2026-01-15")
+        child_limit = (
+            params.gov.dwp.universal_credit.elements.child.limit.child_count
+        )
+        # This returns inf because the whole year 2026 is set to fiscal year value
+        assert child_limit == float("inf")
+
+    def test_december_2025_returns_fiscal_year_2025_value(self, uk_system):
+        """December 2025 should return fiscal year 2025/26 value."""
+        params = uk_system.get_parameters_at_instant("2025-12-15")
+        child_limit = (
+            params.gov.dwp.universal_credit.elements.child.limit.child_count
+        )
+        # The year 2025 is set to April 30, 2025 value (2, pre-repeal)
+        assert child_limit == 2
+
+
+class TestFiscalYearCoverage:
+    """Tests to verify fiscal year conversion covers all needed years."""
+
+    @pytest.mark.parametrize(
+        "year", [2025, 2026, 2027, 2028, 2029, 2030, 2040]
+    )
+    def test_year_in_conversion_range(self, uk_system, year):
+        """
+        Test that years from 2025-2040 can be queried.
+
+        This verifies that the fiscal year conversion range covers
+        all years needed for long-term projections.
+        """
+        params = uk_system.get_parameters_at_instant(str(year))
+        assert params is not None
+        # Verify we can access a parameter
+        pa = params.gov.hmrc.income_tax.allowances.personal_allowance.amount
+        assert pa is not None
+        assert pa > 0

policyengine_uk/utils/__init__.py

@@ -0,0 +1 @@
+from .compare import compare_simulations

policyengine_uk/utils/compare.py

@@ -0,0 +1,28 @@
+import pandas as pd
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from policyengine_uk.simulation import Microsimulation
+
+
+def compare_simulations(
+    simulations: list["Microsimulation"],
+    names: list[str],
+    year: int,
+    variables: list[str],
+):
+    dfs = [
+        sim.calculate_dataframe(variables, year).rename(
+            columns=lambda x: f"{x}_{name}"
+        )
+        for sim, name in zip(simulations, names)
+    ]
+
+    df = pd.concat(dfs, axis=1).reset_index().rename(columns={"index": "id"})
+
+    # Sort columns by variable
+    columns = []
+    for var in variables:
+        columns.extend([col for col in df.columns if col.startswith(var)])
+
+    return df[columns]

policyengine_uk/utils/create_ahc_deflator.py

@@ -0,0 +1,169 @@
+import pandas as pd
+import numpy as np
+
+from policyengine_uk.system import system
+
+# Source: ONS series ref 2863
+historical_modified_cpi = pd.DataFrame(
+    {
+        "period": ["2022-01-01", "2023-01-01", "2024-01-01"],
+        "modified_cpi_index": [126.05, 133.22, 135.68],
+        "modified_cpi_yoy": [0.107, 0.057, 0.018],
+    }
+)
+
+# Source: ONS Consumer price inflation, updating weights: Annex A, Tables W1 to W3
+initial_weights = {
+    "w_water": 9.7399 / 1000,
+    "w_rent": 81.4551 / 1000,
+    "w_repair": 2.9902 / 1000,
+}
+
+cpi = (
+    system.parameters.gov.economic_assumptions.indices.obr.consumer_price_index
+)
+water_index = (
+    system.parameters.gov.economic_assumptions.indices.ofwat.water_bills
+)
+rent_index = system.parameters.gov.economic_assumptions.indices.obr.rent
+
+
+def get_parameter_values(param, start_year, end_year):
+    values = {}
+    for year in range(start_year, end_year + 1):
+        instant = f"{year}-01-01"
+        value = param(instant)
+        if value is not None:
+            values[year] = value
+    return values
+
+
+def create_modified_cpi_forecast(
+    cpi_parameter,
+    water_index_parameter,
+    rent_index_parameter,
+    historical_modified_cpi,
+    initial_weights,
+    forecast_start_year=2025,
+    forecast_end_year=2029,
+):
+    cpi_values = get_parameter_values(
+        cpi_parameter, forecast_start_year, forecast_end_year
+    )
+    water_values = get_parameter_values(
+        water_index_parameter, forecast_start_year, forecast_end_year
+    )
+    rent_values = get_parameter_values(
+        rent_index_parameter, forecast_start_year, forecast_end_year
+    )
+
+    last_historical_year = forecast_start_year - 1
+    last_cpi = cpi_parameter(f"{last_historical_year}-01-01")
+    last_water = water_index_parameter(f"{last_historical_year}-01-01")
+    last_rent = rent_index_parameter(f"{last_historical_year}-01-01")
+
+    results = []
+    for _, row in historical_modified_cpi.iterrows():
+        results.append(
+            {
+                "period": row["period"],
+                "modified_cpi_index": row["modified_cpi_index"],
+                "modified_cpi_yoy": row["modified_cpi_yoy"],
+                "data_type": "historical",
+            }
+        )
+
+    last_historical = historical_modified_cpi.iloc[-1]
+    last_modified_index = last_historical["modified_cpi_index"]
+
+    current_weights = initial_weights.copy()
+    current_weights["w_other"] = 1 - (
+        current_weights["w_water"]
+        + current_weights["w_repair"]
+        + current_weights["w_rent"]
+    )
+
+    forecast_years = sorted(cpi_values.keys())
+    prev_cpi = last_cpi
+    prev_water_index = last_water
+    prev_rent_index = last_rent
+
+    for year in forecast_years:
+        current_cpi = cpi_values[year]
+        current_water_index = water_values.get(year)
+        current_rent_index = rent_values.get(year)
+
+        pi_total = (current_cpi / prev_cpi) - 1
+        pi_repair = pi_total  # Use CPI for maintenance and repair
+        pi_water = (current_water_index / prev_water_index) - 1
+        pi_rent = (current_rent_index / prev_rent_index) - 1
+
+        housing_contribution = (
+            current_weights["w_water"] * pi_water
+            + current_weights["w_repair"] * pi_repair
+            + current_weights["w_rent"] * pi_rent
+        )
+
+        pi_other = (pi_total - housing_contribution) / current_weights[
+            "w_other"
+        ]
+
+        new_modified_index = last_modified_index * (1 + pi_other)
+
+        if len(results) >= 1:
+            prev_year_value = results[-1]["modified_cpi_index"]
+            modified_cpi_yoy = (new_modified_index / prev_year_value) - 1
+        else:
+            modified_cpi_yoy = np.nan
+
+        results.append(
+            {
+                "period": f"{year}-01-01",
+                "year": int(year),
+                "modified_cpi_index": new_modified_index,
+                "modified_cpi_yoy": modified_cpi_yoy,
+                "original_cpi_yoy": pi_total,
+                "data_type": "forecast",
+                "pi_other": pi_other,
+                "pi_total": pi_total,
+                "pi_rent": pi_rent,
+                "pi_water": pi_water,
+                "pi_repair": pi_repair,
+            }
+        )
+
+        total_weighted_growth = (
+            current_weights["w_water"] * (1 + pi_water)
+            + current_weights["w_rent"] * (1 + pi_rent)
+            + current_weights["w_repair"] * (1 + pi_repair)
+            + current_weights["w_other"] * (1 + pi_other)
+        )
+
+        current_weights["w_water"] = (
+            current_weights["w_water"] * (1 + pi_water) / total_weighted_growth
+        )
+        current_weights["w_rent"] = (
+            current_weights["w_rent"] * (1 + pi_rent) / total_weighted_growth
+        )
+        current_weights["w_repair"] = (
+            current_weights["w_repair"]
+            * (1 + pi_repair)
+            / total_weighted_growth
+        )
+        current_weights["w_other"] = (
+            current_weights["w_other"] * (1 + pi_other) / total_weighted_growth
+        )
+
+        last_modified_index = new_modified_index
+        prev_cpi = current_cpi
+        prev_water_index = current_water_index
+        prev_rent_index = current_rent_index
+
+    return pd.DataFrame(results)
+
+
+if __name__ == "__main__":
+    modified_cpi_forecast = create_modified_cpi_forecast(
+        cpi, water_index, rent_index, historical_modified_cpi, initial_weights
+    )
+    print(modified_cpi_forecast.to_markdown(index=False))

policyengine_uk/utils/create_triple_lock.py

@@ -20,5 +20,5 @@ for year in range(START_YEAR, 2029):
     triple_lock_increase = max(earnings_increase, cpi_increase, 1.025)
     lock_value *= triple_lock_increase
     print(
-        f"  {year}-01-01: {lock_value:.3f} # Earnings increase FY{year - 1}/{year - 2} = {earnings_increase-1:.1%}, CPI increase FY{year - 1}/{year - 2} = {cpi_increase-1:.1%}"
+        f"  {year}-01-01: {lock_value:.3f} # Earnings increase FY{year - 1}/{year - 2} = {earnings_increase - 1:.1%}, CPI increase FY{year - 1}/{year - 2} = {cpi_increase - 1:.1%}"
     )