policyengine-uk 2.35.0__py3-none-any.whl

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

@@ -0,0 +1,102 @@
+from policyengine_uk.model_api import *
+
+
+class employer_ni_fixed_employer_cost_change(Variable):
+    label = "employer NI reform incidence"
+    entity = Person
+    definition_period = YEAR
+    value_type = float
+    unit = GBP
+
+    def formula(person, period, parameters):
+        employee_incidence = parameters(
+            period
+        ).gov.contrib.policyengine.employer_ni.employee_incidence
+        if employee_incidence == 0:
+            return 0
+        # First, calculate baseline and reformed employer NI contributions.
+
+        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 * (
+            ni_class_1_income - pen_con_subtracted_b - t_b
+        )
+        c_b = ni_class_1_income + baseline_employer_ni
+
+        # Calculate new employment income keeping employer cost constant
+
+        reform_parameters = parameters(period)
+        reform_class_1 = reform_parameters.gov.hmrc.national_insurance.class_1
+        r_r = reform_class_1.rates.employer
+        t_r = reform_class_1.thresholds.secondary_threshold * WEEKS_IN_YEAR
+        p_r = (
+            reform_parameters.gov.contrib.policyengine.employer_ni.exempt_employer_pension_contributions
+        )
+        if p_r:
+            pen_con_subtracted_r = employer_pension_contributions
+        else:
+            pen_con_subtracted_r = 0
+
+        new_ni_class_1_income = (c_b + r_r * (pen_con_subtracted_r + t_r)) / (
+            1 + r_r
+        )
+
+        # Find difference in employment income
+
+        previous_employment_income = (
+            ni_class_1_income - benefits
+        ) - employer_pension_contributions
+        new_employment_income = (
+            new_ni_class_1_income - benefits
+        ) - employer_pension_contributions
+
+        pay_change = new_employment_income - previous_employment_income
+
+        # Apply incidence percentage
+
+        interpolated_pay_change = pay_change * employee_incidence
+
+        # Where a person's prior employment income was below the secondary threshold, the formula doesn't hold, so assume no change.
+
+        below_threshold = previous_employment_income < t_b
+
+        return where(below_threshold, 0, interpolated_pay_change)

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

@@ -0,0 +1,45 @@
+from policyengine_uk.model_api import *
+
+
+class employer_ni_response_capital_incidence(Variable):
+    label = "capital response to employer NI reform"
+    entity = Person
+    definition_period = YEAR
+    value_type = float
+    unit = GBP
+
+    def formula(person, period, parameters):
+        emp_ni = parameters(period).gov.contrib.policyengine.employer_ni
+        if emp_ni.capital_incidence == 0 or emp_ni.employee_incidence == 1:
+            # If capital incidence is zero, or if the employee incidence is 100%, then there is no capital incidence.:
+            return 0
+
+        if not hasattr(person.simulation, "dataset"):
+            # In single-household simulations, we can't automatically put revenue into price increases because we don't know the revenue.
+            return 0
+
+        person_weight = person("person_weight", period)
+        baseline_employer_cost = person("baseline_employer_cost", period)
+        employer_cost = person("adjusted_employer_cost", period)
+        change_in_employer_cost = employer_cost - baseline_employer_cost
+        amount_paid_by_employers = (
+            person_weight * change_in_employer_cost
+        ).sum()
+
+        wealth = (
+            person.household("corporate_wealth", period)
+            / person.household.nb_persons()
+        )
+        total_wealth = (wealth * person_weight).sum()
+        share_of_total_wealth = wealth / total_wealth
+
+        value = (
+            amount_paid_by_employers
+            * share_of_total_wealth
+            * capital_incidence
+        )
+
+        if total_wealth == 0:
+            return 0
+
+        return value

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

@@ -0,0 +1,45 @@
+from policyengine_uk.model_api import *
+
+
+class employer_ni_response_consumer_incidence(Variable):
+    label = "price response to employer NI reform"
+    entity = Person
+    definition_period = YEAR
+    value_type = float
+    unit = GBP
+
+    def formula(person, period, parameters):
+        emp_ni = parameters(period).gov.contrib.policyengine.employer_ni
+        if emp_ni.consumer_incidence == 0 or emp_ni.employee_incidence == 1:
+            # If consumer incidence is zero, or if the employee incidence is 100%, then there is no capital incidence.:
+            return 0
+
+        if not hasattr(person.simulation, "dataset"):
+            # In single-household simulations, we can't automatically put revenue into price increases because we don't know the revenue.
+            return 0
+
+        person_weight = person("person_weight", period)
+        baseline_employer_cost = person("baseline_employer_cost", period)
+        employer_cost = person("adjusted_employer_cost", period)
+        change_in_employer_cost = employer_cost - baseline_employer_cost
+        amount_paid_by_employers = (
+            person_weight * change_in_employer_cost
+        ).sum()
+
+        consumption = (
+            person.household("consumption", period)
+            / person.household.nb_persons()
+        )
+        total_consumption = (consumption * person_weight).sum()
+        share_of_total_consumption = consumption / total_consumption
+
+        value = (
+            amount_paid_by_employers
+            * share_of_total_consumption
+            * consumer_incidence
+        )
+
+        if total_consumption == 0:
+            return 0
+
+        return value

policyengine_uk/variables/contrib/policyengine/high_income_incident_tax_change.py

@@ -0,0 +1,22 @@
+from policyengine_uk.model_api import *
+
+
+class high_income_incident_tax_change(Variable):
+    label = "high income-incident tax revenue change"
+    entity = Household
+    definition_period = YEAR
+    value_type = float
+    unit = GBP
+
+    def formula(household, period, parameters):
+        if household.simulation.dataset is None:
+            return 0
+
+        total_income = household.members("total_income", period)
+        high_income = household.sum(max_(total_income - 100e3, 0))
+        weight = household("household_weight", period)
+        share = high_income / (high_income * weight).sum()
+        revenue_change = parameters(
+            period
+        ).gov.contrib.policyengine.budget.high_income_incident_tax_change
+        return revenue_change * 1e9 * share

policyengine_uk/variables/contrib/policyengine/nhs_budget_change.py

@@ -0,0 +1,50 @@
+from policyengine_uk.model_api import *
+
+
+class nhs_budget_change(Variable):
+    label = "NHS budget change"
+    entity = Household
+    definition_period = YEAR
+    value_type = float
+
+    def formula(household, period, parameters):
+        budget_increase = (
+            parameters(period).gov.contrib.policyengine.budget.nhs * 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.095,
+            2: 0.118,
+            3: 0.126,
+            4: 0.117,
+            5: 0.104,
+            6: 0.104,
+            7: 0.092,
+            8: 0.089,
+            9: 0.085,
+            10: 0.07,
+        }
+
+        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/other_public_spending_budget_change.py

@@ -0,0 +1,53 @@
+from policyengine_uk.model_api import *
+
+
+class other_public_spending_budget_change(Variable):
+    label = "non- budget change"
+    entity = Household
+    definition_period = YEAR
+    value_type = float
+
+    def formula(household, period, parameters):
+
+        budget_increase = (
+            parameters(
+                period
+            ).gov.contrib.policyengine.budget.other_public_spending
+            * 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/pre_budget_change_household_benefits.py

@@ -0,0 +1,75 @@
+from policyengine_uk.model_api import *
+
+
+class pre_budget_change_household_benefits(Variable):
+    value_type = float
+    entity = Household
+    label = "household benefits"
+    documentation = "Total value of benefits received by household"
+    definition_period = YEAR
+    unit = GBP
+    adds = [
+        "child_benefit",
+        "esa_income",
+        "housing_benefit",
+        "income_support",
+        "jsa_income",
+        "pension_credit",
+        "universal_credit",
+        "working_tax_credit",
+        "child_tax_credit",
+        "attendance_allowance",
+        "afcs",
+        "bsp",
+        "carers_allowance",
+        "dla",
+        "esa_contrib",
+        "iidb",
+        "incapacity_benefit",
+        "jsa_contrib",
+        "pip",
+        "sda",
+        "state_pension",
+        "maternity_allowance",
+        "statutory_sick_pay",
+        "statutory_maternity_pay",
+        "ssmg",
+        "basic_income",
+        "epg_subsidy",
+        "cost_of_living_support_payment",
+        "energy_bills_rebate",
+    ]
+
+    def formula(household, period, parameters):
+        contrib = parameters(period).gov.contrib
+        uprating = contrib.benefit_uprating
+        benefits = pre_budget_change_household_benefits.adds
+        if contrib.abolish_council_tax:
+            benefits = [
+                benefit
+                for benefit in benefits
+                if benefit != "council_tax_benefit"
+            ]
+        general_benefits = add(
+            household,
+            period,
+            [
+                benefit
+                for benefit in benefits
+                if benefit not in ["basic_income"]
+            ],
+        )
+        non_sp_benefits = add(
+            household,
+            period,
+            [
+                benefit
+                for benefit in benefits
+                if benefit not in ["state_pension", "basic_income"]
+            ],
+        )
+        return (
+            add(household, period, benefits)
+            + general_benefits * uprating.all
+            + non_sp_benefits * uprating.non_sp
+        )

policyengine_uk/variables/contrib/policyengine/pre_budget_change_household_net_income.py

@@ -0,0 +1,12 @@
+from policyengine_uk.model_api import *
+
+
+class pre_budget_change_household_net_income(Variable):
+    label = "household net income"
+    documentation = "household net income"
+    entity = Household
+    definition_period = YEAR
+    value_type = float
+    unit = GBP
+    adds = ["household_market_income", "pre_budget_change_household_benefits"]
+    subtracts = ["pre_budget_change_household_tax"]

policyengine_uk/variables/contrib/policyengine/pre_budget_change_household_tax.py

@@ -0,0 +1,43 @@
+from policyengine_uk.model_api import *
+
+
+class pre_budget_change_household_tax(Variable):
+    value_type = float
+    entity = Household
+    label = "household taxes"
+    documentation = "Total taxes owed by the household"
+    definition_period = YEAR
+    unit = GBP
+    adds = [
+        "expected_sdlt",
+        "expected_ltt",
+        "expected_lbtt",
+        "corporate_sdlt",
+        "business_rates",
+        "council_tax",
+        "domestic_rates",
+        "fuel_duty",
+        "tv_licence",
+        "wealth_tax",
+        "non_primary_residence_wealth_tax",
+        "income_tax",
+        "national_insurance",
+        "LVT",
+        "carbon_tax",
+        "vat_change",
+        "capital_gains_tax",
+    ]
+
+    def formula(household, period, parameters):
+        if parameters(period).gov.contrib.abolish_council_tax:
+            return add(
+                household,
+                period,
+                [
+                    tax
+                    for tax in pre_budget_change_household_tax.adds
+                    if tax not in ["council_tax"]
+                ],
+            )
+        else:
+            return add(household, period, pre_budget_change_household_tax.adds)

policyengine_uk/variables/contrib/policyengine/pre_budget_change_ons_household_income_decile.py

@@ -0,0 +1,42 @@
+from policyengine_uk.model_api import *
+
+
+class pre_budget_change_ons_household_income_decile(Variable):
+    label = "pre-budget change household income decile (ONS matched)"
+    entity = Household
+    definition_period = YEAR
+    value_type = float
+    unit = GBP
+
+    def formula(household, period, parameters):
+        income = household("pre_budget_change_household_net_income", period)
+        equivalisation = household("household_equivalisation_bhc", period)
+        if household.simulation.dataset is not None:
+            household_weight = household("household_weight", period)
+            weighted_income = MicroSeries(
+                income / equivalisation, weights=household_weight
+            )
+            decile = weighted_income.decile_rank().values
+        else:
+            upper_bounds = [
+                16000.0,
+                20700.0,
+                24100.0,
+                27200.0,
+                31800.0,
+                37200.0,
+                45200.0,
+                53300.0,
+                68500.0,
+                np.inf,
+            ]
+
+            equivalised_income = income / equivalisation
+            decile = np.select(
+                [equivalised_income <= upper_bounds[i] for i in range(10)],
+                list(range(1, 11)),
+            )
+        # Set negatives to -1.
+        # This avoids the bottom decile summing to a negative number,
+        # which would flip the % change in the interface.
+        return where(income < 0, -1, decile)

policyengine_uk/variables/contrib/ubi_center/basic_income/basic_income.py

@@ -0,0 +1,12 @@
+from policyengine_uk.model_api import *
+
+
+class basic_income(Variable):
+    label = "Basic income"
+    entity = Person
+    definition_period = YEAR
+    value_type = float
+    unit = GBP
+
+    adds = ["bi_maximum"]
+    subtracts = ["bi_phaseout"]

policyengine_uk/variables/contrib/ubi_center/basic_income/bi_household_phaseout.py

@@ -0,0 +1,39 @@
+from policyengine_uk.model_api import *
+import warnings
+
+
+class bi_household_phaseout(Variable):
+    label = "Basic income phase-out (household)"
+    documentation = (
+        "Reduction in basic income from household-level phase-outs."
+    )
+    entity = Person
+    definition_period = YEAR
+    value_type = float
+    unit = GBP
+
+    def formula(person, period, parameters):
+        income = person("total_income", period)
+        household = person.household
+        household_income = household.sum(income)
+        bi = parameters(period).gov.contrib.ubi_center.basic_income
+        remaining_bi = person("bi_maximum", period) - person(
+            "bi_individual_phaseout", period
+        )  # Basic income remaining after individual-level phaseouts
+
+        household_bi = household.sum(remaining_bi)
+        income_over_threshold = max_(
+            household_income - bi.phase_out.household.threshold,
+            0,
+        )
+        uncapped_deduction = (
+            bi.phase_out.household.rate * income_over_threshold
+        )
+        capped_deduction = min_(household_bi, uncapped_deduction)
+
+        warnings.filterwarnings("ignore")
+
+        percent_reduction = where(
+            household_bi > 0, capped_deduction / household_bi, 0
+        )
+        return percent_reduction * remaining_bi

policyengine_uk/variables/contrib/ubi_center/basic_income/bi_individual_phaseout.py

@@ -0,0 +1,25 @@
+from policyengine_uk.model_api import *
+import warnings
+
+
+class bi_individual_phaseout(Variable):
+    label = "Basic income phase-out (individual)"
+    documentation = (
+        "Reduction in basic income from individual-level phase-outs."
+    )
+    entity = Person
+    definition_period = YEAR
+    value_type = float
+    unit = GBP
+
+    def formula(person, period, parameters):
+        income = person("total_income", period)
+        bi = parameters(period).gov.contrib.ubi_center.basic_income
+        max_bi = person("bi_maximum", period)
+        income_over_threshold = max_(
+            income - bi.phase_out.individual.threshold, 0
+        )
+        uncapped_deduction = (
+            bi.phase_out.individual.rate * income_over_threshold
+        )
+        return min_(max_bi, uncapped_deduction)

policyengine_uk/variables/contrib/ubi_center/basic_income/bi_maximum.py

@@ -0,0 +1,28 @@
+from policyengine_uk.model_api import *
+
+
+class bi_maximum(Variable):
+    label = "Basic income before phase-outs"
+    entity = Person
+    definition_period = YEAR
+    value_type = float
+    unit = GBP
+
+    def formula(person, period, parameters):
+        bi = parameters(period).gov.contrib.ubi_center.basic_income
+        weekly_flat_amount = bi.amount.flat
+        is_senior_for_bi = person("is_SP_age", period)
+        age = person("age", period)
+        is_child_for_bi = (age < bi.amount.adult_age) * (
+            age >= bi.amount.child_min_age
+        )
+        is_adult_for_bi = (age >= bi.amount.adult_age) * ~is_senior_for_bi
+        weekly_amount_by_age = select(
+            [is_child_for_bi, is_senior_for_bi, is_adult_for_bi],
+            [
+                bi.amount.by_age.child,
+                bi.amount.by_age.senior,
+                bi.amount.by_age.working_age,
+            ],
+        )
+        return (weekly_flat_amount + weekly_amount_by_age) * WEEKS_IN_YEAR

policyengine_uk/variables/contrib/ubi_center/basic_income/bi_phaseout.py

@@ -0,0 +1,11 @@
+from policyengine_uk.model_api import *
+
+
+class bi_phaseout(Variable):
+    label = "Basic income phase-out"
+    entity = Person
+    definition_period = YEAR
+    value_type = float
+    unit = GBP
+
+    adds = ["bi_individual_phaseout", "bi_household_phaseout"]

policyengine_uk/variables/contrib/ubi_center/carbon_tax.py

@@ -0,0 +1,27 @@
+from policyengine_uk.model_api import *
+
+
+class carbon_tax(Variable):
+    entity = Household
+    label = "Carbon tax"
+    definition_period = YEAR
+    value_type = float
+    unit = GBP
+
+    def formula(household, period, parameters):
+        carbon_tax = parameters(period).gov.contrib.ubi_center.carbon_tax
+        rate = carbon_tax.rate
+        emissions = household("carbon_consumption", period)
+        # Household's share of total stocks and other corporate tax exposure.
+        shareholding = household("shareholding", period)
+        total_emissions = (
+            emissions * household("household_weight", period)
+        ).sum()
+        consumer_incidence = carbon_tax.consumer_incidence * rate * emissions
+        corporate_incidence = (
+            (1 - carbon_tax.consumer_incidence)
+            * rate
+            * total_emissions
+            * shareholding
+        )
+        return consumer_incidence + corporate_incidence

policyengine_uk/variables/contrib/ubi_center/land_value_tax.py

@@ -0,0 +1,20 @@
+from policyengine_uk.model_api import *
+
+
+class LVT(Variable):
+    entity = Household
+    label = "Land value tax"
+    definition_period = YEAR
+    value_type = float
+    unit = GBP
+
+    def formula(household, period, parameters):
+        lvt = parameters(period).gov.contrib.ubi_center.land_value_tax
+        full_lvt = lvt.rate * household("land_value", period)
+        household_lvt = lvt.household_rate * household(
+            "household_land_value", period
+        )
+        corporate_lvt = lvt.corporate_rate * household(
+            "corporate_land_value", period
+        )
+        return full_lvt + household_lvt + corporate_lvt

policyengine_uk/variables/contrib/ubi_center/wealth_tax.py

@@ -0,0 +1,15 @@
+from policyengine_uk.model_api import *
+
+
+class wealth_tax(Variable):
+    label = "Wealth tax"
+    documentation = "Annual tax on household net wealth"
+    entity = Household
+    definition_period = YEAR
+    value_type = float
+    unit = GBP
+
+    def formula(household, period, parameters):
+        wealth = household("total_wealth", period)
+        tax = parameters(period).gov.contrib.ubi_center.wealth_tax
+        return tax.calc(wealth)