policyengine-uk 2.35.0__py3-none-any.whl

policyengine_uk/tests/policy/reforms/parametric/winter_fuel_allowance/taxable_income_test.yaml

@@ -0,0 +1,202 @@
+- name: 2024 baseline - pensioner without benefits gets no WFA
+  period: 2024
+  absolute_error_margin: 1
+  input:
+    # In 2024, require_benefits defaults to true
+    age: 67
+    country: "ENGLAND"
+    total_income: 15000
+    pension_credit: 0
+    income_support: 0
+    esa_income: 0
+    jsa_income: 0
+  output:
+    winter_fuel_allowance: 0
+
+- name: Enable income test - pensioner under threshold gets WFA despite no benefits
+  period: 2024
+  absolute_error_margin: 1
+  input:
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.use_maximum_taxable_income: true
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.maximum_taxable_income: 20000
+    age: 67
+    country: "ENGLAND"
+    total_income: 15000
+    pension_credit: 0
+    income_support: 0
+    esa_income: 0
+    jsa_income: 0
+  output:
+    winter_fuel_allowance: 200
+
+- name: Enable income test - pensioner over threshold gets no WFA
+  period: 2024
+  absolute_error_margin: 1
+  input:
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.use_maximum_taxable_income: true
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.maximum_taxable_income: 20000
+    age: 67
+    country: "ENGLAND"
+    total_income: 25000
+    pension_credit: 0
+    income_support: 0
+    esa_income: 0
+    jsa_income: 0
+  output:
+    winter_fuel_allowance: 0
+
+- name: Enable income test - pensioner exactly at threshold gets no WFA
+  period: 2024
+  absolute_error_margin: 1
+  input:
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.use_maximum_taxable_income: true
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.maximum_taxable_income: 20000
+    age: 67
+    country: "ENGLAND"
+    total_income: 20000
+    pension_credit: 0
+    income_support: 0
+    esa_income: 0
+    jsa_income: 0
+  output:
+    winter_fuel_allowance: 0
+
+- name: Enable income test - pensioner £1 under threshold gets WFA
+  period: 2024
+  absolute_error_margin: 1
+  input:
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.use_maximum_taxable_income: true
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.maximum_taxable_income: 20000
+    age: 67
+    country: "ENGLAND"
+    total_income: 19999
+    pension_credit: 0
+    income_support: 0
+    esa_income: 0
+    jsa_income: 0
+  output:
+    winter_fuel_allowance: 200
+
+- name: Higher rate WFA for 80+ under threshold
+  period: 2024
+  absolute_error_margin: 1
+  input:
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.use_maximum_taxable_income: true
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.maximum_taxable_income: 20000
+    age: 82
+    country: "ENGLAND"
+    total_income: 15000
+    pension_credit: 0
+    income_support: 0
+    esa_income: 0
+    jsa_income: 0
+  output:
+    winter_fuel_allowance: 300
+
+- name: Wales pensioner under threshold gets WFA
+  period: 2024
+  absolute_error_margin: 1
+  input:
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.use_maximum_taxable_income: true
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.maximum_taxable_income: 20000
+    age: 67
+    country: "WALES"
+    total_income: 15000
+    pension_credit: 0
+    income_support: 0
+    esa_income: 0
+    jsa_income: 0
+  output:
+    winter_fuel_allowance: 200
+
+- name: Scotland pensioner unaffected by England/Wales income test
+  period: 2024
+  absolute_error_margin: 1
+  input:
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.use_maximum_taxable_income: true
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.maximum_taxable_income: 20000
+    age: 67
+    country: "SCOTLAND"
+    total_income: 15000  # Would qualify in England/Wales
+    pension_credit: 0
+    income_support: 0
+    esa_income: 0
+    jsa_income: 0
+  output:
+    winter_fuel_allowance: 0  # Scotland handled separately
+
+- name: Northern Ireland pensioner unaffected by England/Wales income test
+  period: 2024
+  absolute_error_margin: 1
+  input:
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.use_maximum_taxable_income: true
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.maximum_taxable_income: 20000
+    age: 67
+    country: "NORTHERN_IRELAND"
+    total_income: 15000  # Would qualify in England/Wales
+    pension_credit: 0
+    income_support: 0
+    esa_income: 0
+    jsa_income: 0
+  output:
+    winter_fuel_allowance: 0  # Northern Ireland handled separately
+
+- name: Income test provides alternative to benefits requirement
+  period: 2024
+  absolute_error_margin: 1
+  input:
+    # require_benefits is true by default in 2024, but income test provides alternative
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.use_maximum_taxable_income: true
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.maximum_taxable_income: 20000
+    age: 67
+    country: "ENGLAND"
+    total_income: 15000
+    pension_credit: 0
+    income_support: 0
+    esa_income: 0
+    jsa_income: 0
+  output:
+    winter_fuel_allowance: 200
+
+- name: Test different income threshold - £30k threshold
+  period: 2024
+  absolute_error_margin: 1
+  input:
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.use_maximum_taxable_income: true
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.maximum_taxable_income: 30000
+    age: 67
+    country: "ENGLAND"
+    total_income: 25000  # Under new threshold
+    pension_credit: 0
+    income_support: 0
+    esa_income: 0
+    jsa_income: 0
+  output:
+    winter_fuel_allowance: 200
+
+- name: Test different income threshold - £30k threshold exceeded
+  period: 2024
+  absolute_error_margin: 1
+  input:
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.use_maximum_taxable_income: true
+    gov.dwp.winter_fuel_payment.eligibility.taxable_income_test.maximum_taxable_income: 30000
+    age: 67
+    country: "ENGLAND"
+    total_income: 35000  # Over new threshold
+    pension_credit: 0
+    income_support: 0
+    esa_income: 0
+    jsa_income: 0
+  output:
+    winter_fuel_allowance: 0
+
+- name: 2023 baseline - everyone gets WFA regardless of income (pre-reform)
+  period: 2023
+  absolute_error_margin: 1
+  input:
+    # In 2023, require_benefits was false, so everyone eligible by age gets WFA
+    age: 67
+    country: "ENGLAND"
+    total_income: 50000
+  output:
+    winter_fuel_allowance: 200

policyengine_uk/tests/test_parameter_metadata.py

@@ -0,0 +1,18 @@
+from policyengine_uk.system import system
+from policyengine_core.model_api import Parameter
+import pytest
+
+parameters = list(
+    filter(
+        lambda x: isinstance(x, Parameter),
+        system.parameters.gov.get_descendants(),
+    )
+)
+
+"""
+Remove for now.
+@pytest.mark.parametrize("parameter", parameters, ids=lambda x: x.name)
+def test_parameter_has_label(parameter):
+    assert parameter.metadata.get("label") is not None, "Missing label"
+
+"""

policyengine_uk/utils/create_triple_lock.py

@@ -0,0 +1,20 @@
+from policyengine_uk.system import system
+
+# Run this script to generate the triple lock parameter for updated CPI and average earnings forecasts from the OBR.
+
+cpi = system.parameters.gov.obr.consumer_price_index
+average_earnings = system.parameters.gov.obr.average_earnings
+
+START_YEAR = 2021
+
+triple_lock = system.parameters.gov.dwp.state_pension.triple_lock
+lock_value = triple_lock(START_YEAR - 1)
+
+for year in range(START_YEAR, 2029):
+    earnings_increase = average_earnings(year - 1) / average_earnings(year - 2)
+    cpi_increase = cpi(year - 1) / cpi(year - 2)
+    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%}"
+    )

policyengine_uk/utils/parameters.py

@@ -0,0 +1,38 @@
+from policyengine_core.model_api import *
+from policyengine_core import periods
+
+
+def str_to_instant(s):
+    return periods.Instant(tuple(map(lambda s: int(s), s.split("-"))))
+
+
+def backdate_parameters(
+    root: str = None, first_instant: str = "2021-01-01"
+) -> Reform:
+    first_instant = str_to_instant(first_instant)
+    node = root
+    for param in node.get_descendants():
+        if hasattr(param, "values_list"):
+            earliest = param.values_list[-1]
+            earliest_value = earliest.value
+            earliest_instant = str_to_instant(earliest.instant_str)
+            if first_instant < earliest_instant:
+                num_days = (earliest_instant.date - first_instant.date).days
+                param.update(
+                    period=periods.Period(("day", first_instant, num_days)),
+                    value=earliest_value,
+                )
+    return root
+
+
+def convert_to_fiscal_year_parameters(parameters):
+    YEARS = list(range(2015, 2026))
+    for param in parameters.get_descendants():
+        if isinstance(param, Parameter):
+            for year in YEARS:
+                value_mid_year = param(f"{year}-04-30")
+                param.update(
+                    period=f"{year}",
+                    value=value_mid_year,
+                )
+    return parameters

policyengine_uk/utils/solve_private_school_attendance_factor.py

@@ -0,0 +1,46 @@
+from policyengine import Simulation
+from policyengine_core.reforms import Reform
+from tqdm import tqdm
+
+# Initialize variables to track the best private_school_factor and its result
+best_factor = None
+smallest_difference = float("inf")
+
+# Loop over values of private_school_factor from 0.7 to 0.8 in steps of 0.01
+for factor in tqdm([round(x * 0.01, 2) for x in range(70, 91)]):
+    # Define the reform with the current private_school_factor value
+    reform = {
+        "gov.contrib.labour.private_school_vat": {
+            "2024-01-01.2100-12-31": 0.2
+        },
+        "gov.simulation.private_school_vat.private_school_factor": {
+            "2024-01-01.2100-12-31": factor
+        },
+    }
+
+    # Run the reformed microsimulation
+    reformed = Simulation(
+        scope="macro",
+        baseline=reform,
+        country="uk",
+    ).baseline_simulation
+    reformed.baseline_simulation.get_holder(
+        "attends_private_school"
+    ).delete_arrays()
+
+    # Calculate the number of students attending private school in thousands
+    private_school_attendance = (
+        reformed.calculate("attends_private_school", period=2025).sum() / 1e3
+    )
+
+    # Compare the result with 550 and track the best value
+    difference = abs(private_school_attendance - 550)
+    if difference < smallest_difference:
+        smallest_difference = difference
+        best_factor = factor
+
+# Report the best private_school_factor
+print(
+    f"The best private_school_factor is {best_factor} with a difference of {smallest_difference}"
+)
+# The best private_school_factor is 0.77 with a difference of 1.3427231160653719

policyengine_uk/variables/contrib/cec/non_primary_residence_wealth_tax.py

@@ -0,0 +1,20 @@
+from policyengine_uk.model_api import *
+
+
+class non_primary_residence_wealth_tax(Variable):
+    label = "Wealth tax (non-primary residence)"
+    documentation = (
+        "Annual tax on household net wealth excluding primary residences"
+    )
+    entity = Household
+    definition_period = YEAR
+    value_type = float
+    unit = GBP
+
+    def formula(household, period, parameters):
+        wealth = household("total_wealth", period)
+        primary_residence = household("main_residence_value", period)
+        tax = parameters(
+            period
+        ).gov.contrib.cec.non_primary_residence_wealth_tax
+        return tax.calc(max_(0, wealth - primary_residence))

policyengine_uk/variables/contrib/labour/attends_private_school.py

@@ -0,0 +1,81 @@
+from policyengine_uk.model_api import *
+
+
+def interpolate_percentile(param, percentile):
+    if str(percentile) in param:
+        return param[str(percentile)]
+    else:
+        idx = percentile - (percentile % 5)
+        p1 = idx
+        p2 = idx + 5
+        v1 = param[str(idx)]
+        v2 = param[str(idx + 5)]
+        return v1 + (v2 - v1) * (percentile - p1) / (p2 - p1)
+
+
+class attends_private_school(Variable):
+    label = "attends private school"
+    entity = Person
+    definition_period = YEAR
+    value_type = bool
+
+    def formula(person, period, parameters):
+        if not hasattr(person.simulation, "dataset"):
+            return 0
+        household = person.household
+        # To ensure that our model matches
+        # total number of students actually enrolled
+
+        ps_vat_params = parameters(period).gov.simulation.private_school_vat
+        private_school_attendance_rate = (
+            ps_vat_params.private_school_attendance_rate
+        )
+
+        population_adjustment_factor = ps_vat_params.private_school_factor
+
+        person = household.members
+
+        is_child = person("is_child", period)
+
+        taxes = household.sum(
+            person("income_tax", period) + person("national_insurance", period)
+        )
+
+        net_income = (
+            household("household_market_income", period)
+            + household("household_benefits", period)
+            - taxes
+        )
+
+        household_weight = household("household_weight", period)
+        weighted_income = MicroSeries(net_income, weights=household_weight)
+
+        if household_weight.sum() < 1e6:
+            return 0
+
+        percentile = np.zeros_like(weighted_income).astype(numpy.int64)
+        mask = household_weight > 0
+
+        percentile[mask] = (
+            weighted_income[mask]
+            .percentile_rank()
+            .clip(0, 100)
+            .values.astype(numpy.int64)
+        )
+        # STUDENT_POPULATION_ADJUSTMENT_FACTOR = 0.78
+        STUDENT_POPULATION_ADJUSTMENT_FACTOR = population_adjustment_factor
+
+        p_attends_private_school = (
+            np.array(
+                [
+                    interpolate_percentile(private_school_attendance_rate, p)
+                    for p in percentile
+                ]
+            )
+            * STUDENT_POPULATION_ADJUSTMENT_FACTOR
+            * is_child
+        )
+
+        value = random(person) < p_attends_private_school
+
+        return value

policyengine_uk/variables/contrib/labour/private_school_vat.py

@@ -0,0 +1,27 @@
+from policyengine_uk.model_api import *
+
+
+class private_school_vat(Variable):
+    label = "private school VAT"
+    entity = Household
+    definition_period = YEAR
+    value_type = float
+    unit = "currency-GBP"
+
+    def formula(household, period, parameters):
+        num_children = add(household, period, ["attends_private_school"])
+
+        ps_vat_params = parameters(period).gov.simulation.private_school_vat
+        private_school_vat_basis = ps_vat_params.private_school_vat_basis
+        avg_yearly_private_school_cost = ps_vat_params.private_school_fees
+
+        private_school_vat_rate = parameters(
+            period
+        ).gov.contrib.labour.private_school_vat
+
+        return (
+            num_children
+            * avg_yearly_private_school_cost
+            * private_school_vat_rate
+            * private_school_vat_basis
+        )

policyengine_uk/variables/contrib/policyengine/consumer_incident_tax_revenue_change.py

@@ -0,0 +1,24 @@
+from policyengine_uk.model_api import *
+
+
+class consumer_incident_tax_revenue_change(Variable):
+    label = "consumer-incident tax revenue change"
+    entity = Household
+    definition_period = YEAR
+    value_type = float
+    unit = GBP
+
+    def formula(household, period, parameters):
+        consumption = household("consumption", period)
+        if (
+            household.simulation.dataset is not None
+            and household("consumption", period).sum() != 0
+        ):
+            weight = household("household_weight", period)
+            share = consumption / (consumption * weight).sum()
+        else:
+            share = consumption / 846e9
+        revenue_change = parameters(
+            period
+        ).gov.contrib.policyengine.budget.consumer_incident_tax_change
+        return revenue_change * share * 1e9

policyengine_uk/variables/contrib/policyengine/corporate_incident_tax_revenue_change.py

@@ -0,0 +1,16 @@
+from policyengine_uk.model_api import *
+
+
+class corporate_incident_tax_revenue_change(Variable):
+    label = "corporate-incident tax revenue change"
+    entity = Household
+    definition_period = YEAR
+    value_type = float
+    unit = GBP
+
+    def formula(household, period, parameters):
+        share = household("shareholding", period)
+        revenue_change = parameters(
+            period
+        ).gov.contrib.policyengine.budget.corporate_incident_tax_change
+        return revenue_change * share * 1e9

policyengine_uk/variables/contrib/policyengine/education_budget_change.py

@@ -0,0 +1,50 @@
+from policyengine_uk.model_api import *
+
+
+class education_budget_change(Variable):
+    label = "education budget change"
+    entity = Household
+    definition_period = YEAR
+    value_type = float
+
+    def formula(household, period, parameters):
+
+        budget_increase = (
+            parameters(period).gov.contrib.policyengine.budget.education * 1e9
+        )
+        if budget_increase == 0:
+            return 0
+        decile = household(
+            "pre_budget_change_ons_household_income_decile", period
+        )
+        weight = household("household_weight", period)
+        DECILE_INCIDENCE = {
+            1: 0.114,
+            2: 0.146,
+            3: 0.122,
+            4: 0.125,
+            5: 0.119,
+            6: 0.085,
+            7: 0.088,
+            8: 0.076,
+            9: 0.077,
+            10: 0.046,
+        }
+
+        decile = pd.Series(decile)
+        budget_increase_per_decile = {
+            i: budget_increase * DECILE_INCIDENCE[i] for i in range(1, 11)
+        }
+        if household.simulation.dataset is not None:
+            households_per_decile = (
+                pd.Series(weight).groupby(decile).sum().to_dict()
+            )
+        else:
+            households_per_decile = {i: 28e5 for i in range(1, 11)}
+
+        average_per_decile = {
+            i: budget_increase_per_decile[i] / households_per_decile[i]
+            for i in range(1, 11)
+        }
+
+        return decile.map(average_per_decile).replace({np.nan: 0})

policyengine_uk/variables/contrib/policyengine/employer_ni/adjusted_employer_cost.py

@@ -0,0 +1,46 @@
+from policyengine_uk.model_api import *
+
+
+class adjusted_employer_cost(Variable):
+    label = "employer cost"
+    entity = Person
+    definition_period = YEAR
+    value_type = float
+    unit = GBP
+
+    def formula(person, period, parameters):
+        employment_income = person("employment_income", period)
+        benefits = add(
+            person,
+            period,
+            [
+                "statutory_sick_pay",
+                "statutory_maternity_pay",
+                "statutory_paternity_pay",
+            ],
+        )
+        employer_pension_contributions = person(
+            "employer_pension_contributions", period
+        )
+        ni_class_1_income = (
+            employment_income + benefits + employer_pension_contributions
+        )
+
+        # Calculate employer cost
+        parameters = parameters(period)
+        class_1 = parameters.gov.hmrc.national_insurance.class_1
+        r_r = class_1.rates.employer
+        t_r = class_1.thresholds.secondary_threshold * WEEKS_IN_YEAR
+        p_r = (
+            parameters.gov.contrib.policyengine.employer_ni.exempt_employer_pension_contributions
+        )
+        pen_con_subtracted_r = employer_pension_contributions
+        if p_r:
+            pen_con_subtracted_r = employer_pension_contributions
+        else:
+            pen_con_subtracted_r = 0
+
+        employer_ni = r_r * max_(
+            0, ni_class_1_income - pen_con_subtracted_r - t_r
+        )
+        return ni_class_1_income + employer_ni

policyengine_uk/variables/contrib/policyengine/employer_ni/baseline_employer_cost.py

@@ -0,0 +1,56 @@
+from policyengine_uk.model_api import *
+
+
+class baseline_employer_cost(Variable):
+    label = "baseline employer cost"
+    entity = Person
+    definition_period = YEAR
+    value_type = float
+    unit = GBP
+
+    def formula(person, period, parameters):
+        prior_employment_income = person(
+            "employment_income_before_lsr", period
+        )
+        employment_income_behavioral_response = person(
+            "employment_income_behavioral_response", period
+        )
+        benefits = add(
+            person,
+            period,
+            [
+                "statutory_sick_pay",
+                "statutory_maternity_pay",
+                "statutory_paternity_pay",
+            ],
+        )
+        employer_pension_contributions = person(
+            "employer_pension_contributions", period
+        )
+        ni_class_1_income = (
+            prior_employment_income
+            + employment_income_behavioral_response
+            + benefits
+            + employer_pension_contributions
+        )
+
+        # Calculate baseline employer cost
+        baseline_parameters = parameters(period).baseline
+        baseline_class_1 = (
+            baseline_parameters.gov.hmrc.national_insurance.class_1
+        )
+        r_b = baseline_class_1.rates.employer
+        t_b = baseline_class_1.thresholds.secondary_threshold * WEEKS_IN_YEAR
+        p_b = (
+            baseline_parameters.gov.contrib.policyengine.employer_ni.exempt_employer_pension_contributions
+        )
+        pen_con_subtracted_b = employer_pension_contributions
+        if p_b:
+            pen_con_subtracted_b = employer_pension_contributions
+        else:
+            pen_con_subtracted_b = 0
+
+        baseline_employer_ni = r_b * max_(
+            0, ni_class_1_income - pen_con_subtracted_b - t_b
+        )
+        return ni_class_1_income + baseline_employer_ni

policyengine_uk/variables/contrib/policyengine/employer_ni/employer_cost.py

@@ -0,0 +1,26 @@
+from policyengine_uk.model_api import *
+
+
+class employer_cost(Variable):
+    label = "employer cost"
+    entity = Person
+    definition_period = YEAR
+    value_type = float
+    unit = GBP
+
+    def formula(person, period, parameters):
+        benefits = add(
+            person,
+            period,
+            [
+                "statutory_sick_pay",
+                "statutory_maternity_pay",
+                "statutory_paternity_pay",
+            ],
+        )
+        return (
+            person("employment_income", period)
+            + person("ni_employer", period)
+            + person("employer_pension_contributions", period)
+            + benefits
+        )