policyengine-us 1.426.0__py3-none-any.whl → 1.439.0__py3-none-any.whl

policyengine_us/tests/policy/contrib/congress/tlaib/economic_dignity_for_all_agenda/edaa_end_child_poverty_act.yaml

@@ -0,0 +1,198 @@
+# End Child Poverty Act tests
+
+- name: ECPA child benefit for eligible child
+  period: 2026
+  reforms: policyengine_us.reforms.congress.tlaib.economic_dignity_for_all_agenda.end_child_poverty_act
+  input:
+    people:
+      parent:
+        age: 30
+      child:
+        age: 5
+    tax_units:
+      tax_unit:
+        members: [parent, child]
+        filing_status: SINGLE
+        adjusted_gross_income: 20_000
+    households:
+      household:
+        members: [parent, child]
+  output:
+    ecpa_child_benefit: [0, 5_630]
+    ecpa_filer_credit: 700
+
+- name: ECPA adult dependent credit
+  period: 2026
+  reforms: policyengine_us.reforms.congress.tlaib.economic_dignity_for_all_agenda.end_child_poverty_act
+  input:
+    people:
+      parent:
+        age: 45
+      adult_dependent:
+        age: 20
+        is_tax_unit_dependent: true
+    tax_units:
+      tax_unit:
+        members: [parent, adult_dependent]
+        filing_status: SINGLE
+        adjusted_gross_income: 15_000
+  output:
+    ecpa_adult_dependent_credit: [0, 700]
+    ecpa_filer_credit: 700
+
+- name: ECPA filer credit with phase out
+  period: 2026
+  reforms: policyengine_us.reforms.congress.tlaib.economic_dignity_for_all_agenda.end_child_poverty_act
+  input:
+    people:
+      filer:
+        age: 40
+    tax_units:
+      tax_unit:
+        members: [filer]
+        filing_status: SINGLE
+        adjusted_gross_income: 24_000
+  output:
+    ecpa_filer_credit: 500  # 700 - (4,000 * 0.05)
+
+- name: ECPA household with children and adult dependent
+  period: 2026
+  reforms: policyengine_us.reforms.congress.tlaib.economic_dignity_for_all_agenda.end_child_poverty_act
+  input:
+    people:
+      parent:
+        age: 45
+      child1:
+        age: 5
+      child2:
+        age: 10
+      adult_dependent:
+        age: 20
+        is_tax_unit_dependent: true
+    tax_units:
+      tax_unit:
+        members: [parent, child1, child2, adult_dependent]
+        filing_status: SINGLE
+        adjusted_gross_income: 30_000
+  output:
+    ecpa_child_benefit: [0, 5_630, 5_630, 0]
+    ecpa_adult_dependent_credit: [0, 0, 0, 700]
+    ecpa_filer_credit: 200  # 700 - (10,000 * 0.05)
+
+- name: ECPA joint filers with children and adult dependent
+  period: 2026
+  reforms: policyengine_us.reforms.congress.tlaib.economic_dignity_for_all_agenda.end_child_poverty_act
+  input:
+    people:
+      parent1:
+        age: 40
+      parent2:
+        age: 38
+      child:
+        age: 8
+      adult_dependent:
+        age: 22
+        is_tax_unit_dependent: true
+    tax_units:
+      tax_unit:
+        members: [parent1, parent2, child, adult_dependent]
+        filing_status: JOINT
+        adjusted_gross_income: 45_000
+  output:
+    ecpa_child_benefit: [0, 0, 5_630, 0]
+    ecpa_adult_dependent_credit: [0, 0, 0, 700]
+    ecpa_filer_credit: 1_150  # 1,400 - (5,000 * 0.05)
+
+- name: Oklahoma family - state credits reference federal calculations
+  period: 2026
+  reforms: policyengine_us.reforms.congress.tlaib.economic_dignity_for_all_agenda.end_child_poverty_act
+  absolute_error_margin: 1
+  input:
+    people:
+      parent1:
+        age: 35
+        employment_income: 30_000
+      parent2:
+        age: 33
+        employment_income: 20_000
+      newborn:
+        age: 0
+        birth_year: 2026
+      child:
+        age: 8
+        birth_year: 2018
+      adult_dependent:
+        age: 19
+        birth_year: 2007
+        is_full_time_student: true
+    tax_units:
+      tax_unit:
+        members: [parent1, parent2, newborn, child, adult_dependent]
+        filing_status: JOINT
+    households:
+      household:
+        members: [parent1, parent2, newborn, child, adult_dependent]
+        state_code: OK
+  output:
+    # Federal CTC/EITC calculated for state reference
+    ctc: 4_900
+    eitc: 4_244
+
+    # Oklahoma credits (5% of federal)
+    ok_child_care_child_tax_credit:
+      2026: 245  # 5% of $4,900
+    ok_eitc:
+      2026: 72.07
+
+    # ECPA benefits
+    ecpa_child_benefit:
+      2026: [0, 0, 5_630, 5_630, 0]
+    ecpa_adult_dependent_credit:
+      2026: [0, 0, 0, 0, 700]
+    ecpa_filer_credit:
+      2026: 900  # $1,400 - ($50k - $40k) * 0.05
+
+    # Federal refundable credits exclude CTC/EITC
+    income_tax_refundable_credits:
+      2026: 1_600  # ECPA filer ($900) + adult dependent ($700)
+
+- name: Maine single parent - state EITC percentage of federal
+  period: 2026
+  reforms: policyengine_us.reforms.congress.tlaib.economic_dignity_for_all_agenda.end_child_poverty_act
+  absolute_error_margin: 1
+  input:
+    people:
+      parent:
+        age: 28
+        employment_income: 25_000
+      child1:
+        age: 3
+        birth_year: 2023
+      child2:
+        age: 10
+        birth_year: 2016
+    tax_units:
+      tax_unit:
+        members: [parent, child1, child2]
+        filing_status: HEAD_OF_HOUSEHOLD
+    households:
+      household:
+        members: [parent, child1, child2]
+        state_code: ME
+  output:
+    # Federal calculations
+    ctc: 4_400
+    eitc: 7_071
+
+    # Maine EITC is 25% of federal
+    me_eitc: 1_767
+
+    # ECPA benefits
+    ecpa_child_benefit:
+      2026: [0, 5_630, 5_630]
+    ecpa_filer_credit:
+      2026: 450  # $700 - ($25k - $20k) * 0.05
+
+    # Federal credits exclude EITC/CTC
+    income_tax_refundable_credits:
+      2026: 450

policyengine_us/tests/policy/contrib/states/ri/ctc_reform_test.yaml

@@ -175,3 +175,147 @@
     ri_non_refundable_ctc: 0
     ri_refundable_credits: 1_583.28  # 1_000 (CTC refundable) + 583.28 (EITC)
     ri_non_refundable_credits: 0
+
+- name: RI CTC - young child boost applies to children under age 6
+  absolute_error_margin: 0.1
+  period: 2025
+  reforms: policyengine_us.reforms.states.ri.ctc.ri_ctc_reform.ri_ctc
+  input:
+    gov.contrib.states.ri.ctc.in_effect: true
+    gov.contrib.states.ri.ctc.amount: 1_000
+    gov.contrib.states.ri.ctc.age_limit: 18
+    gov.contrib.states.ri.ctc.young_child_boost.amount: 500
+    gov.contrib.states.ri.ctc.young_child_boost.age_limit: 6
+    gov.contrib.states.ri.ctc.refundability.cap: 999_999
+    gov.contrib.states.ri.ctc.phaseout.threshold.SINGLE: 100_000
+    gov.contrib.states.ri.ctc.phaseout.rate: 0.05
+    people:
+      parent:
+        age: 35
+        employment_income: 50_000
+      child1:
+        age: 3
+        is_tax_unit_dependent: true
+      child2:
+        age: 10
+        is_tax_unit_dependent: true
+    tax_units:
+      tax_unit:
+        members: [parent, child1, child2]
+        filing_status: SINGLE
+    households:
+      household:
+        members: [parent, child1, child2]
+        state_name: RI
+  output:
+    ri_ctc_eligible_children: 2
+    ri_ctc_young_child_boost: 500  # 1 child under 6 × $500 = $500
+    ri_ctc_maximum: 2_500  # Base: 2 × $1_000 = $2_000; Boost: $500; Total = $2_500
+    ri_total_ctc: 2_500
+    ri_refundable_ctc: 2_500
+    ri_non_refundable_ctc: 0
+
+- name: RI CTC - young child boost boundary at age 6
+  absolute_error_margin: 0.1
+  period: 2025
+  reforms: policyengine_us.reforms.states.ri.ctc.ri_ctc_reform.ri_ctc
+  input:
+    gov.contrib.states.ri.ctc.in_effect: true
+    gov.contrib.states.ri.ctc.amount: 1_000
+    gov.contrib.states.ri.ctc.age_limit: 18
+    gov.contrib.states.ri.ctc.young_child_boost.amount: 500
+    gov.contrib.states.ri.ctc.young_child_boost.age_limit: 6
+    gov.contrib.states.ri.ctc.refundability.cap: 999_999
+    people:
+      parent:
+        age: 35
+        employment_income: 40_000
+      child1:
+        age: 5
+        is_tax_unit_dependent: true
+      child2:
+        age: 6
+        is_tax_unit_dependent: true
+    tax_units:
+      tax_unit:
+        members: [parent, child1, child2]
+        filing_status: SINGLE
+    households:
+      household:
+        members: [parent, child1, child2]
+        state_name: RI
+  output:
+    ri_ctc_eligible_children: 2
+    ri_ctc_young_child_boost: 500  # Only child age 5 qualifies (age 6 does not)
+    ri_ctc_maximum: 2_500  # Base: 2 × $1_000 = $2_000; Boost: $500 (only age 5 child); Total = $2_500
+    ri_total_ctc: 2_500
+
+- name: RI CTC - young child boost with multiple young children
+  absolute_error_margin: 0.1
+  period: 2025
+  reforms: policyengine_us.reforms.states.ri.ctc.ri_ctc_reform.ri_ctc
+  input:
+    gov.contrib.states.ri.ctc.in_effect: true
+    gov.contrib.states.ri.ctc.amount: 1_000
+    gov.contrib.states.ri.ctc.age_limit: 18
+    gov.contrib.states.ri.ctc.young_child_boost.amount: 500
+    gov.contrib.states.ri.ctc.young_child_boost.age_limit: 6
+    gov.contrib.states.ri.ctc.refundability.cap: 999_999
+    people:
+      parent:
+        age: 35
+        employment_income: 50_000
+      child1:
+        age: 2
+        is_tax_unit_dependent: true
+      child2:
+        age: 4
+        is_tax_unit_dependent: true
+      child3:
+        age: 10
+        is_tax_unit_dependent: true
+    tax_units:
+      tax_unit:
+        members: [parent, child1, child2, child3]
+        filing_status: SINGLE
+    households:
+      household:
+        members: [parent, child1, child2, child3]
+        state_name: RI
+  output:
+    ri_ctc_eligible_children: 3
+    ri_ctc_young_child_boost: 1_000  # 2 children under 6 × $500 = $1_000
+    ri_ctc_maximum: 4_000  # Base: 3 × $1_000 = $3_000; Boost: $1_000; Total = $4_000
+    ri_total_ctc: 4_000
+
+- name: RI CTC - young child boost with no boost amount (zero)
+  absolute_error_margin: 0.1
+  period: 2025
+  reforms: policyengine_us.reforms.states.ri.ctc.ri_ctc_reform.ri_ctc
+  input:
+    gov.contrib.states.ri.ctc.in_effect: true
+    gov.contrib.states.ri.ctc.amount: 1_000
+    gov.contrib.states.ri.ctc.age_limit: 18
+    gov.contrib.states.ri.ctc.young_child_boost.amount: 0  # No boost
+    gov.contrib.states.ri.ctc.young_child_boost.age_limit: 6
+    gov.contrib.states.ri.ctc.refundability.cap: 999_999
+    people:
+      parent:
+        age: 35
+        employment_income: 50_000
+      child1:
+        age: 3
+        is_tax_unit_dependent: true
+    tax_units:
+      tax_unit:
+        members: [parent, child1]
+        filing_status: SINGLE
+    households:
+      household:
+        members: [parent, child1]
+        state_name: RI
+  output:
+    ri_ctc_eligible_children: 1
+    ri_ctc_young_child_boost: 0  # 1 child under 6 × $0 = $0
+    ri_ctc_maximum: 1_000  # Base: 1 × $1_000 = $1_000; Boost: $0; Total = $1_000
+    ri_total_ctc: 1_000

policyengine_us/tests/policy/contrib/states/ri/exemption_reform_test.yaml

@@ -25,7 +25,7 @@
         members: [parent, child1, child2]
         state_name: RI
   output:
-    ri_exemptions: 10_150  # 1 personal (5_050) + 1 dependent (5_100)
+    ri_exemptions: 15_200  # 1 personal (5_050) + 1 dependent (5_100) + 1 older dependent (5_050)
 
 - name: RI exemption reform - restrict to children under 13
   period: 2025
@@ -54,7 +54,7 @@
         members: [parent, child1, child2]
         state_name: RI
   output:
-    ri_exemptions: 10_150  # 1 personal (5_050) + 1 dependent (5_100)
+    ri_exemptions: 15_200  # 1 personal (5_050) + 1 dependent (5_100) + 1 older dependent (5_050)
 
 - name: RI exemption reform - AGI phaseout
   period: 2025

policyengine_us/variables/gov/ed/pell_grant/efc/pell_grant_simplified_formula_applies.py

@@ -12,6 +12,5 @@ class pell_grant_simplified_formula_applies(Variable):
         head_income = tax_unit("pell_grant_primary_income", period)
         p = parameters(period).gov.ed.pell_grant.efc.simplified
         income_eligible = head_income < p.income_limit
-        total_benefits = add(tax_unit, period, p.benefits)
-        has_benefits = np.any(total_benefits > 0)
+        has_benefits = add(tax_unit, period, p.benefits) > 0
         return income_eligible & has_benefits & p.applies

policyengine_us/variables/gov/fcc/lifeline/is_lifeline_eligible.py

@@ -21,8 +21,8 @@ class is_lifeline_eligible(Variable):
         )
         categorically_eligible = np.where(
             is_on_tribal_land,
-            np.any(tribal_lifeline_programs),
-            np.any(non_tribal_lifeline_programs),
+            tribal_lifeline_programs > 0,
+            non_tribal_lifeline_programs > 0,
         )
         # Use the new unified income eligibility variable
         income_eligible = spm_unit("is_lifeline_income_eligible", period)

policyengine_us/variables/gov/hhs/head_start/early_head_start.py

@@ -4,7 +4,8 @@ from policyengine_us.model_api import *
 class early_head_start(Variable):
     value_type = float
     entity = Person
-    label = "Amount of Early Head Start benefit"
+    label = "Early Head Start"
+    unit = USD
     definition_period = YEAR
     defined_for = "is_early_head_start_eligible"
     reference = "https://headstart.gov/program-data/article/head-start-program-facts-fiscal-year-2022"

policyengine_us/variables/gov/hhs/head_start/head_start.py

@@ -4,7 +4,8 @@ from policyengine_us.model_api import *
 class head_start(Variable):
     value_type = float
     entity = Person
-    label = "Amount of Head Start benefit"
+    label = "Head Start"
+    unit = USD
     definition_period = YEAR
     defined_for = "is_head_start_eligible"
     reference = "https://headstart.gov/program-data/article/head-start-program-facts-fiscal-year-2022"

policyengine_us/variables/gov/hhs/head_start/is_head_start_categorically_eligible.py

@@ -12,7 +12,5 @@ class is_head_start_categorically_eligible(Variable):
     )
 
     def formula(person, period, parameters):
-        tax_unit = person.tax_unit
         p = parameters(period).gov.hhs.head_start
-        programs = add(tax_unit, period, p.categorical_eligibility)
-        return np.any(programs)
+        return add(person.tax_unit, period, p.categorical_eligibility) > 0

policyengine_us/variables/gov/hhs/tanf/cash/income/tanf_gross_earned_income.py

@@ -0,0 +1,13 @@
+from policyengine_us.model_api import *
+
+
+class tanf_gross_earned_income(Variable):
+    value_type = float
+    entity = Person
+    label = (
+        "Temporary Assistance for Needy Families (TANF) gross earned income"
+    )
+    unit = USD
+    definition_period = MONTH
+
+    adds = "gov.hhs.tanf.cash.income.sources.earned"

policyengine_us/variables/gov/hhs/tanf/cash/income/tanf_gross_unearned_income.py

@@ -0,0 +1,13 @@
+from policyengine_us.model_api import *
+
+
+class tanf_gross_unearned_income(Variable):
+    value_type = float
+    entity = Person
+    label = (
+        "Temporary Assistance for Needy Families (TANF) gross unearned income"
+    )
+    unit = USD
+    definition_period = MONTH
+
+    adds = "gov.hhs.tanf.cash.income.sources.unearned"

policyengine_us/variables/gov/hhs/tanf/tanf_fpg.py

@@ -0,0 +1,28 @@
+from policyengine_us.model_api import *
+
+
+class tanf_fpg(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = "TANF federal poverty guideline"
+    unit = USD
+    documentation = (
+        "The federal poverty guideline used to determine TANF eligibility."
+    )
+    definition_period = MONTH
+    reference = "https://www.law.cornell.edu/uscode/text/42/9902"
+
+    def formula(spm_unit, period, parameters):
+        # We can use tanf_unit_size for more accurate model in the future
+        n = spm_unit("spm_unit_size", period.this_year)
+        state_group = spm_unit.household("state_group_str", period.this_year)
+        year = period.start.year
+        month = period.start.month
+        if month >= 10:
+            instant_str = f"{year}-10-01"
+        else:
+            instant_str = f"{year - 1}-10-01"
+        p_fpg = parameters(instant_str).gov.hhs.fpg
+        p1 = p_fpg.first_person[state_group] / MONTHS_IN_YEAR
+        pn = p_fpg.additional_person[state_group] / MONTHS_IN_YEAR
+        return p1 + pn * (n - 1)

policyengine_us/variables/gov/simulation/labor_supply_response/income_elasticity.py

@@ -7,30 +7,4 @@ class income_elasticity(Variable):
     label = "income elasticity of labor supply"
     unit = "/1"
     definition_period = YEAR
-    reference = [
-        "https://www.cbo.gov/publication/43675",
-        "https://www.cbo.gov/publication/43676",
-        "https://academic.oup.com/restud/article-abstract/72/2/395/1558553",
-    ]
-
-    def formula(person, period, parameters):
-        p = parameters(
-            period
-        ).gov.simulation.labor_supply_responses.elasticities.income
-
-        # Check if global override is set
-        if p.all != 0:
-            return p.all
-
-        # Get base income elasticity
-        base_elasticity = p.base
-
-        # Apply age multiplier for individuals at or above age threshold
-        age = person("age", period.this_year)
-        age_multiplier = where(
-            age >= p.age_threshold,
-            p.age_multiplier_over_threshold,
-            1.0,  # No multiplier for under threshold
-        )
-
-        return base_elasticity * age_multiplier
+    adds = ["gov.simulation.labor_supply_responses.elasticities.income"]

policyengine_us/variables/gov/simulation/labor_supply_response/substitution_elasticity.py

@@ -7,18 +7,12 @@ class substitution_elasticity(Variable):
     label = "substitution elasticity of labor supply"
     unit = "/1"
     definition_period = YEAR
-    reference = [
-        "https://www.cbo.gov/publication/43675",
-        "https://www.cbo.gov/publication/43676",
-        "https://academic.oup.com/restud/article-abstract/72/2/395/1558553",
-    ]
 
     def formula(person, period, parameters):
         p = parameters(
             period
         ).gov.simulation.labor_supply_responses.elasticities.substitution
 
-        # Check for global override
         if p.all != 0:
             return p.all
 
@@ -36,7 +30,6 @@ class substitution_elasticity(Variable):
             1_726e3,
         ]
 
-        # Calculate earnings
         raw_earnings = add(
             person,
             period,
@@ -45,59 +38,41 @@ class substitution_elasticity(Variable):
                 "self_employment_income_before_lsr",
             ],
         )
-        # Use max_ to prevent negative earnings from causing issues
         earnings = max_(raw_earnings, 0)
-        # Use searchsorted with side='right' to bin earnings into deciles
-        # This gives decile numbers 1-10 directly without needing to add 1
-        earnings_decile = np.searchsorted(
-            EARNINGS_DECILE_MARKERS, earnings, side="right"
+        earnings_decile = (
+            np.searchsorted(EARNINGS_DECILE_MARKERS, earnings) + 1
         )
 
-        # Determine if primary earner (highest earner in tax unit)
         tax_unit = person.tax_unit
+        # Primary earner == highest earner in tax unit
         max_earnings_in_unit = tax_unit.max(earnings)
         is_primary_earner = earnings == max_earnings_in_unit
 
-        # Get base elasticity from position and decile
-        base_elasticity = np.zeros_like(earnings, dtype=float)
+        elasticities = np.zeros_like(earnings)
 
         # Handle zero earnings first
         zero_earnings = earnings == 0
-        base_elasticity[zero_earnings] = 0
+        elasticities[zero_earnings] = 0
 
-        # For non-zero earnings, assign base elasticities
+        # For non-zero earnings, assign elasticities
         non_zero_earnings = earnings > 0
 
         if np.any(non_zero_earnings):
-            # Primary earners by decile
-            for i in range(10):  # Iterate through deciles 1-10
-                decile_num = i + 1  # Decile numbers are 1-10
+            # First assign primary earner elasticities by decile
+            decile_elasticities = [
+                p.by_position_and_decile.primary._children[str(i + 1)]
+                for i in range(10)
+            ]
+            for i in range(10):
                 mask = (
                     non_zero_earnings
-                    & (earnings_decile == decile_num)
+                    & (earnings_decile == i + 1)
                     & is_primary_earner
                 )
-                if np.any(mask):
-                    # Access parameter using getattr to handle both normal and test scenarios
-                    decile_param = getattr(
-                        p.by_position_and_decile.primary, str(decile_num)
-                    )
-                    # Handle both Parameter objects and raw values (when overridden in tests)
-                    param_value = (
-                        decile_param(period)
-                        if callable(decile_param)
-                        else decile_param
-                    )
-                    base_elasticity[mask] = param_value
+                elasticities[mask] = decile_elasticities[i]
 
-            # Secondary earners get zero elasticity (only primary earners have non-zero values)
+            # Then assign secondary earner elasticity where applicable
+            secondary_mask = non_zero_earnings & ~is_primary_earner
+            elasticities[secondary_mask] = p.by_position_and_decile.secondary
 
-        # Apply age multiplier for individuals at or above age threshold
-        age = person("age", period.this_year)
-        age_multiplier = where(
-            age >= p.age_threshold,
-            p.age_multiplier_over_threshold,
-            1.0,  # No multiplier for under threshold
-        )
-
-        return base_elasticity * age_multiplier
+        return elasticities

policyengine_us/variables/gov/ssa/ssi/eligibility/income/deemed/from_ineligible_spouse/is_ssi_spousal_deeming_applies.py

@@ -0,0 +1,41 @@
+from policyengine_us.model_api import *
+
+
+class is_ssi_spousal_deeming_applies(Variable):
+    value_type = bool
+    entity = Person
+    label = "SSI spousal deeming applies"
+    definition_period = YEAR
+    reference = "https://www.law.cornell.edu/cfr/text/20/416.1163"
+    defined_for = "is_ssi_eligible_individual"
+    documentation = """
+    Returns True when spousal deeming applies according to 20 CFR §416.1163.
+
+    Spousal deeming applies when:
+    1. Person is an eligible individual (not part of an eligible couple)
+    2. Spouse is ineligible (not aged/blind/disabled)
+    3. Spouse's leftover income (after child allocations) exceeds the difference
+       between couple FBR and individual FBR
+
+    When deeming applies, the benefit calculation uses the couple FBR instead
+    of the individual FBR, recognizing that two people have higher expenses.
+    """
+
+    def formula(person, period, parameters):
+        # Get spouse's deemed income (after child allocations)
+        spouse_deemed_income = add(
+            person,
+            period,
+            [
+                "ssi_earned_income_deemed_from_ineligible_spouse",
+                "ssi_unearned_income_deemed_from_ineligible_spouse",
+            ],
+        )
+
+        # Compare to FBR differential (couple rate - individual rate)
+        p = parameters(period).gov.ssa.ssi.amount
+        diff = (p.couple - p.individual) * MONTHS_IN_YEAR
+
+        # Deeming applies when spouse's deemed income exceeds the differential
+        # Note: regulation says "not more than" means ≤, so we use > for deeming
+        return spouse_deemed_income > diff