policyengine-us 1.420.0__py3-none-any.whl → 1.450.0__py3-none-any.whl

policyengine_us/reforms/states/ri/ctc/ri_ctc_reform.py

@@ -0,0 +1,207 @@
+from policyengine_us.model_api import *
+from policyengine_core.periods import period as period_
+from policyengine_core.periods import instant
+
+
+def create_ri_ctc() -> Reform:
+    class ri_ctc_eligible_children(Variable):
+        value_type = int
+        entity = TaxUnit
+        label = "Rhode Island CTC eligible children count"
+        definition_period = YEAR
+        defined_for = StateCode.RI
+
+        def formula(tax_unit, period, parameters):
+            p = parameters(period).gov.contrib.states.ri.ctc
+
+            person = tax_unit.members
+            age = person("age", period)
+            is_dependent = person("is_tax_unit_dependent", period)
+
+            # Check age eligibility
+            meets_age = age < p.age_limit
+
+            eligible = is_dependent & meets_age
+            return tax_unit.sum(eligible)
+
+    class ri_ctc_young_child_boost(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Rhode Island CTC young child boost"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.RI
+
+        def formula(tax_unit, period, parameters):
+            p = parameters(period).gov.contrib.states.ri.ctc
+
+            person = tax_unit.members
+            age = person("age", period)
+            is_dependent = person("is_tax_unit_dependent", period)
+
+            # Check both general CTC eligibility and young child age limit
+            meets_age = age < p.age_limit
+            meets_young_child_age = age < p.young_child_boost.age_limit
+
+            eligible_young_children = tax_unit.sum(
+                is_dependent & meets_age & meets_young_child_age
+            )
+            return eligible_young_children * p.young_child_boost.amount
+
+    class ri_ctc_maximum(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Rhode Island CTC maximum amount before phaseout"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.RI
+
+        def formula(tax_unit, period, parameters):
+            p = parameters(period).gov.contrib.states.ri.ctc
+
+            # Base credit for all eligible children
+            eligible_children = tax_unit("ri_ctc_eligible_children", period)
+            base_credit = eligible_children * p.amount
+
+            # Young child boost
+            young_child_boost = tax_unit("ri_ctc_young_child_boost", period)
+
+            return base_credit + young_child_boost
+
+    class ri_ctc_phaseout(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Rhode Island CTC phaseout amount"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.RI
+
+        def formula(tax_unit, period, parameters):
+            p = parameters(period).gov.contrib.states.ri.ctc
+
+            filing_status = tax_unit("filing_status", period)
+            agi = tax_unit("ri_agi", period)
+
+            threshold = p.phaseout.threshold[filing_status]
+            excess_income = max_(agi - threshold, 0)
+            return excess_income * p.phaseout.rate
+
+    class ri_total_ctc(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Rhode Island Child Tax Credit"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.RI
+
+        def formula(tax_unit, period, parameters):
+            p = parameters(period).gov.contrib.states.ri.ctc
+
+            # Calculate maximum credit
+            maximum = tax_unit("ri_ctc_maximum", period)
+
+            # Apply phaseout
+            phaseout = tax_unit("ri_ctc_phaseout", period)
+
+            return max_(maximum - phaseout, 0)
+
+    class ri_refundable_ctc(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Rhode Island CTC refundable portion"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.RI
+
+        def formula(tax_unit, period, parameters):
+            p = parameters(period).gov.contrib.states.ri.ctc
+
+            total_credit = tax_unit("ri_total_ctc", period)
+
+            # The refundable portion is the minimum of the cap and total credit
+            # This ensures the refundable amount never exceeds the total credit
+            # - If cap = 0: credit is nonrefundable
+            # - If 0 < cap < total_credit: credit is partially refundable
+            # - If cap >= total_credit: credit is fully refundable
+            return min_(total_credit, p.refundability.cap)
+
+    class ri_non_refundable_ctc(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Rhode Island CTC non-refundable portion"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.RI
+
+        def formula(tax_unit, period, parameters):
+            p = parameters(period).gov.contrib.states.ri.ctc
+
+            total_credit = tax_unit("ri_total_ctc", period)
+            refundable_portion = tax_unit("ri_refundable_ctc", period)
+            return max_(total_credit - refundable_portion, 0)
+
+    def modify_parameters(parameters):
+        # Add ri_refundable_ctc to refundable credits list
+        refundable = parameters.gov.states.ri.tax.income.credits.refundable
+        current_refundable = refundable(instant("2025-01-01"))
+        if "ri_refundable_ctc" not in current_refundable:
+            new_refundable = list(current_refundable) + ["ri_refundable_ctc"]
+            refundable.update(
+                start=instant("2025-01-01"),
+                stop=instant("2100-12-31"),
+                value=new_refundable,
+            )
+
+        # Add ri_non_refundable_ctc to non-refundable credits list
+        non_refundable = (
+            parameters.gov.states.ri.tax.income.credits.non_refundable
+        )
+        current_non_refundable = non_refundable(instant("2025-01-01"))
+        if "ri_non_refundable_ctc" not in current_non_refundable:
+            new_non_refundable = list(current_non_refundable) + [
+                "ri_non_refundable_ctc"
+            ]
+            non_refundable.update(
+                start=instant("2025-01-01"),
+                stop=instant("2100-12-31"),
+                value=new_non_refundable,
+            )
+
+        return parameters
+
+    class reform(Reform):
+        def apply(self):
+            self.update_variable(ri_ctc_eligible_children)
+            self.update_variable(ri_ctc_young_child_boost)
+            self.update_variable(ri_ctc_maximum)
+            self.update_variable(ri_ctc_phaseout)
+            self.update_variable(ri_total_ctc)
+            self.update_variable(ri_refundable_ctc)
+            self.update_variable(ri_non_refundable_ctc)
+            self.modify_parameters(modify_parameters)
+
+    return reform
+
+
+def create_ri_ctc_reform(parameters, period, bypass: bool = False):
+    if bypass:
+        return create_ri_ctc()
+
+    p = parameters.gov.contrib.states.ri.ctc
+
+    reform_active = False
+    current_period = period_(period)
+
+    for i in range(5):
+        if p(current_period).in_effect:
+            reform_active = True
+            break
+        current_period = current_period.offset(1, "year")
+
+    if reform_active:
+        return create_ri_ctc()
+    else:
+        return None
+
+
+ri_ctc = create_ri_ctc_reform(None, None, bypass=True)

policyengine_us/reforms/states/ri/exemption/__init__.py

@@ -0,0 +1 @@
+from .ri_exemption_reform import create_ri_exemption_reform_fn

policyengine_us/reforms/states/ri/exemption/ri_exemption_reform.py

@@ -0,0 +1,167 @@
+from policyengine_us.model_api import *
+from policyengine_core.periods import period as period_
+from policyengine_core.periods import instant
+
+
+def create_ri_exemption_reform() -> Reform:
+    class ri_eligible_dependents_count(Variable):
+        value_type = int
+        entity = TaxUnit
+        label = "Rhode Island eligible dependents count"
+        definition_period = YEAR
+        defined_for = StateCode.RI
+
+        def formula(tax_unit, period, parameters):
+            p = parameters(period).gov.contrib.states.ri.dependent_exemption
+
+            person = tax_unit.members
+            age = person("age", period)
+            is_dependent = person("is_tax_unit_dependent", period)
+
+            # Apply age limit if in effect
+            if p.age_limit.in_effect:
+                age_threshold = p.age_limit.threshold
+                eligible_dependents = is_dependent & (age < age_threshold)
+            else:
+                eligible_dependents = is_dependent
+
+            return tax_unit.sum(eligible_dependents)
+
+    class ri_dependent_exemption_maximum(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Rhode Island dependent exemption maximum before phaseout"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.RI
+
+        def formula(tax_unit, period, parameters):
+            p = parameters(period).gov.contrib.states.ri.dependent_exemption
+
+            dependents_count = tax_unit("ri_eligible_dependents_count", period)
+            return dependents_count * p.amount
+
+    class ri_dependent_exemption_phaseout(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Rhode Island dependent exemption phaseout amount"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.RI
+
+        def formula(tax_unit, period, parameters):
+            p = parameters(period).gov.contrib.states.ri.dependent_exemption
+
+            filing_status = tax_unit("filing_status", period)
+            agi = tax_unit("ri_agi", period)
+
+            threshold = p.phaseout.threshold[filing_status]
+            excess_income = max_(agi - threshold, 0)
+            return excess_income * p.phaseout.rate
+
+    class ri_dependent_exemption(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Rhode Island dependent exemption"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.RI
+
+        def formula(tax_unit, period, parameters):
+
+            maximum = tax_unit("ri_dependent_exemption_maximum", period)
+            phaseout = tax_unit("ri_dependent_exemption_phaseout", period)
+
+            return max_(maximum - phaseout, 0)
+
+    class ri_older_dependents_count(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Rhode Island older dependents count"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.RI
+
+        def formula(tax_unit, period, parameters):
+            person = tax_unit.members
+            is_dependent = person("is_tax_unit_dependent", period)
+            total_dependents = tax_unit.sum(is_dependent)
+            eligible_dependent_exemptions = tax_unit(
+                "ri_eligible_dependents_count", period
+            )
+            return max_(0, total_dependents - eligible_dependent_exemptions)
+
+    class ri_exemptions(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Rhode Island exemptions"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.RI
+
+        def formula(tax_unit, period, parameters):
+            p_base = parameters(period).gov.states.ri.tax.income.exemption
+
+            # Calculate personal exemptions base amount
+            filing_status = tax_unit("filing_status", period)
+            older_dependents = tax_unit("ri_older_dependents_count", period)
+            personal_exemptions = (
+                where(
+                    filing_status == filing_status.possible_values.JOINT,
+                    2,
+                    1,
+                )
+                + older_dependents
+            )
+            personal_exemption_base = personal_exemptions * p_base.amount
+
+            # Apply baseline phase-out to personal exemptions
+            mod_agi = tax_unit("ri_agi", period)
+            excess_agi = max_(0, mod_agi - p_base.reduction.start)
+            increments = np.ceil(excess_agi / p_base.reduction.increment)
+            reduction_rate = min_(p_base.reduction.rate * increments, 1)
+            personal_exemption_amount = personal_exemption_base * (
+                1 - reduction_rate
+            )
+
+            # Add dependent exemption (has its own phase-out logic)
+            dependent_exemption_amount = tax_unit(
+                "ri_dependent_exemption", period
+            )
+
+            return personal_exemption_amount + dependent_exemption_amount
+
+    class reform(Reform):
+        def apply(self):
+            self.update_variable(ri_eligible_dependents_count)
+            self.update_variable(ri_dependent_exemption_maximum)
+            self.update_variable(ri_dependent_exemption_phaseout)
+            self.update_variable(ri_dependent_exemption)
+            self.update_variable(ri_exemptions)
+            self.update_variable(ri_older_dependents_count)
+
+    return reform
+
+
+def create_ri_exemption_reform_fn(parameters, period, bypass: bool = False):
+    if bypass:
+        return create_ri_exemption_reform()
+
+    p = parameters.gov.contrib.states.ri.dependent_exemption
+
+    reform_active = False
+    current_period = period_(period)
+
+    for i in range(5):
+        if p(current_period).in_effect:
+            reform_active = True
+            break
+        current_period = current_period.offset(1, "year")
+
+    if reform_active:
+        return create_ri_exemption_reform()
+    else:
+        return None
+
+
+ri_exemption_reform = create_ri_exemption_reform_fn(None, None, bypass=True)

policyengine_us/reforms/states/ut/__init__.py

@@ -0,0 +1,3 @@
+from .ut_refundable_eitc import (
+    create_ut_refundable_eitc_reform,
+)

policyengine_us/reforms/states/ut/ut_refundable_eitc.py

@@ -0,0 +1,118 @@
+from policyengine_us.model_api import *
+from policyengine_core.periods import period as period_
+
+
+def create_ut_refundable_eitc() -> Reform:
+    class ut_has_qualifying_child_for_refundable_eitc(Variable):
+        value_type = bool
+        entity = TaxUnit
+        label = "Utah tax unit has qualifying child for refundable EITC"
+        defined_for = StateCode.UT
+        definition_period = YEAR
+
+        def formula(tax_unit, period, parameters):
+            person = tax_unit.members
+            p = parameters(period).gov.contrib.states.ut.eitc
+            age = person("age", period)
+            is_dependent = person("is_tax_unit_dependent", period)
+            is_qualifying_child = (age <= p.max_age) & is_dependent
+            return tax_unit.any(is_qualifying_child)
+
+    class ut_refundable_eitc(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Utah refundable EITC"
+        unit = USD
+        definition_period = YEAR
+        defined_for = "ut_has_qualifying_child_for_refundable_eitc"
+
+        adds = ["ut_eitc"]
+
+    class ut_eitc(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Utah Earned Income Tax Credit"
+        unit = USD
+        documentation = "This credit is a fraction of the federal EITC."
+        definition_period = YEAR
+        defined_for = StateCode.UT
+        reference = "https://le.utah.gov/xcode/Title59/Chapter10/59-10-S1044.html?v=C59-10-S1044_2022050420220504"
+
+        def formula(tax_unit, period, parameters):
+            p = parameters(
+                period
+            ).gov.states.ut.tax.income.credits.earned_income
+            federal_eitc = tax_unit("eitc", period)
+            return p.rate * federal_eitc
+
+    class ut_non_refundable_eitc(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Utah non-refundable EITC"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.UT
+
+        adds = ["ut_eitc"]
+        subtracts = ["ut_refundable_eitc"]
+
+    class ut_non_refundable_credits(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Utah non-refundable tax credits"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.UT
+
+        adds = [
+            "ut_non_refundable_eitc",
+            "ut_retirement_credit",
+            "ut_ss_benefits_credit",
+            "ut_at_home_parent_credit",
+            "ut_ctc",
+        ]
+
+    class ut_refundable_credits(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Utah refundable credits"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.UT
+
+        adds = ["ut_refundable_eitc"]
+
+    class reform(Reform):
+        def apply(self):
+            self.update_variable(ut_has_qualifying_child_for_refundable_eitc)
+            self.update_variable(ut_refundable_eitc)
+            self.update_variable(ut_non_refundable_eitc)
+            self.update_variable(ut_eitc)
+            self.update_variable(ut_non_refundable_credits)
+            self.update_variable(ut_refundable_credits)
+
+    return reform
+
+
+def create_ut_refundable_eitc_reform(parameters, period, bypass: bool = False):
+    if bypass:
+        return create_ut_refundable_eitc()
+
+    p = parameters.gov.contrib.states.ut.eitc
+
+    reform_active = False
+    current_period = period_(period)
+
+    for i in range(5):
+        if p(current_period).in_effect:
+            reform_active = True
+            break
+        current_period = current_period.offset(1, "year")
+
+    if reform_active:
+        return create_ut_refundable_eitc()
+    else:
+        return None
+
+
+ut_refundable_eitc = create_ut_refundable_eitc_reform(None, None, bypass=True)

policyengine_us/tests/policy/baseline/gov/aca/ptc/aca_ptc.yaml

@@ -5,7 +5,7 @@
     is_aca_ptc_eligible: true
     slcsp: 1_200
     aca_magi: 25_000
-    aca_ptc_phase_out_rate: 0.04
+    aca_required_contribution_percentage: 0.04
   output:
     aca_ptc: 200  # 1200 - 0.04 * 25000 = 200
 
@@ -16,7 +16,7 @@
     is_aca_ptc_eligible: true
     slcsp: 1_200
     aca_magi: 25_000
-    aca_ptc_phase_out_rate: 0.05
+    aca_required_contribution_percentage: 0.05
   output:
     aca_ptc: 0  # 1200 - 0.05 * 25000 = -50
 
@@ -27,6 +27,6 @@
     is_aca_ptc_eligible: false
     slcsp: 1_200
     aca_magi: 25_000
-    aca_ptc_phase_out_rate: 0.04
+    aca_required_contribution_percentage: 0.04
   output:
     aca_ptc: 0  # 1200 - 0.04 * 25000 = 200

policyengine_us/tests/policy/baseline/gov/aca/ptc/aca_required_contribution_percentage.yaml

@@ -0,0 +1,71 @@
+- name: aca_required_contribution_percentage unit test 1
+  period: 2022
+  absolute_error_margin: 0.00001
+  input:
+    aca_magi_fraction: 1.40
+  output:
+    aca_required_contribution_percentage: 0
+
+- name: aca_required_contribution_percentage unit test 2
+  period: 2022
+  absolute_error_margin: 0.00001
+  input:
+    aca_magi_fraction: 1.90
+  output:
+    aca_required_contribution_percentage: 0.0160
+
+- name: aca_required_contribution_percentage unit test 3
+  period: 2022
+  absolute_error_margin: 0.00001
+  input:
+    aca_magi_fraction: 2.40
+  output:
+    aca_required_contribution_percentage: 0.0360
+
+- name: aca_required_contribution_percentage unit test 4
+  period: 2022
+  absolute_error_margin: 0.00001
+  input:
+    aca_magi_fraction: 2.90
+  output:
+    aca_required_contribution_percentage: 0.0560
+
+- name: aca_required_contribution_percentage unit test 5
+  period: 2022
+  absolute_error_margin: 0.00001
+  input:
+    aca_magi_fraction: 3.40
+  output:
+    aca_required_contribution_percentage: 0.0700
+
+- name: aca_required_contribution_percentage unit test 6
+  period: 2022
+  absolute_error_margin: 0.00001
+  input:
+    aca_magi_fraction: 3.90
+  output:
+    aca_required_contribution_percentage: 0.0825
+
+- name: aca_required_contribution_percentage unit test 7
+  period: 2022
+  absolute_error_margin: 0.00001
+  input:
+    aca_magi_fraction: 4.40
+  output:
+    aca_required_contribution_percentage: 0.0850
+
+- name: aca_required_contribution_percentage 2025
+  period: 2025
+  absolute_error_margin: 0.00001
+  input:
+    aca_magi_fraction: 4.0
+  output:
+    aca_required_contribution_percentage: 0.0850
+
+- name: aca_required_contribution_percentage 2026
+  period: 2026
+  absolute_error_margin: 0.00001
+  input:
+    aca_magi_fraction: 4.0
+  output:
+    aca_required_contribution_percentage: 0.0996

policyengine_us/tests/policy/baseline/gov/aca/ptc/integration.yaml

@@ -29,7 +29,7 @@
     is_aca_ptc_eligible: [true, true, true]
     slcsp: 15_550.90  #15,542 from 2025 kff calculator, they round more aggressively 
     aca_magi_fraction: 2.90
-    aca_ptc_phase_out_rate: 0.056
+    aca_required_contribution_percentage: 0.056
     aca_ptc: 11_350.90  #$11,327 from 2025 kff calculator
   #Final PTC:
 #    - KFF’s result:  $15,542 – $4,215 = $11,327 subsidy (annual).

policyengine_us/tests/policy/baseline/gov/aca/ptc/separate_esi.yaml

@@ -30,7 +30,7 @@
     slcsp_age_curve_amount_person: [0, 5_526, 3_188]
     slcsp: 8_715.192 
     aca_magi_fraction: 2.90
-    aca_ptc_phase_out_rate: 0.056
+    aca_required_contribution_percentage: 0.056
     aca_ptc: 4_515.19
 
 - name: 2025 VT  - one adult esi
@@ -61,5 +61,5 @@
     is_medicaid_eligible: [false, false, false]
     is_aca_ptc_eligible: [false, true, true]
     slcsp: 29_575.32  
-    aca_ptc_phase_out_rate: 0.0721
+    aca_required_contribution_percentage: 0.0721
     aca_ptc: 23_086.32

policyengine_us/tests/policy/baseline/gov/ed/pell_grant/pell_grant_simplified_formula_applies.yaml

@@ -135,7 +135,7 @@
       tanf: 0
       spm_unit_wic: 0
   output:
-    pell_grant_simplified_formula_applies: true
+    pell_grant_simplified_formula_applies: [false, true]  # main has no benefits, other has medicaid
 
 - name: Too much income
   period: 2023

policyengine_us/tests/policy/baseline/gov/hhs/medicare/costs/medicare_cost.yaml

@@ -0,0 +1,65 @@
+- name: unit test 1 - enrolled, premium-free Part A
+  period: 2025
+  input:
+    age: 65
+    is_medicare_eligible: true
+    medicare_enrolled: true
+    medicare_quarters_of_coverage: 40
+    adjusted_gross_income:
+      2023: 50_000  # IRMAA uses income from 2 years prior
+    tax_exempt_interest_income:
+      2023: 0
+  output:
+    medicare_cost: 12_280  # $14,500 spending - $2,220 Part B premium (2025)
+
+- name: unit test 2 - enrolled, pays full Part A premium
+  period: 2025
+  input:
+    age: 65
+    is_medicare_eligible: true
+    medicare_enrolled: true
+    medicare_quarters_of_coverage: 20
+    adjusted_gross_income:
+      2023: 50_000  # IRMAA uses income from 2 years prior
+    tax_exempt_interest_income:
+      2023: 0
+  output:
+    medicare_cost: 6_064  # $14,500 - $6,216 Part A - $2,220 Part B (2025)
+
+- name: unit test 3 - enrolled with IRMAA
+  period: 2025
+  input:
+    age: 65
+    is_medicare_eligible: true
+    medicare_enrolled: true
+    medicare_quarters_of_coverage: 40
+    adjusted_gross_income:
+      2023: 500_000  # IRMAA uses income from 2 years prior
+    tax_exempt_interest_income:
+      2023: 0
+    filing_status: SINGLE
+  output:
+    medicare_cost: 6_953.2  # $14,500 - $7,546.80 Part B with IRMAA (2025)
+
+- name: unit test 4 - eligible but not enrolled
+  period: 2025
+  input:
+    age: 65
+    is_medicare_eligible: true
+    medicare_enrolled: false
+  output:
+    medicare_cost: 0
+
+- name: unit test 5 - 2021 data, premium-free
+  period: 2021
+  input:
+    age: 70
+    is_medicare_eligible: true
+    medicare_enrolled: true
+    medicare_quarters_of_coverage: 40
+    adjusted_gross_income:
+      2019: 50_000  # IRMAA uses income from 2 years prior
+    tax_exempt_interest_income:
+      2019: 0
+  output:
+    medicare_cost: 9_298  # $11,080 - $1,782 Part B (2021: $148.50*12)