policyengine-us 1.455.0__py3-none-any.whl → 1.503.1__py3-none-any.whl

policyengine_us/parameters/gov/states/wv/dhhr/works/payment_standard/amount.yaml

@@ -0,0 +1,42 @@
+description: West Virginia provides this amount as the payment standard under the West Virginia Works program.
+
+metadata:
+  unit: currency-USD
+  period: month
+  breakdown:
+    - range(1, 11)
+  label: West Virginia Works payment standard amount
+  reference:
+    - title: WV Income Maintenance Manual Appendix A Income Limit (2024)
+      href: https://bfa.wv.gov/media/2766/download?inline#page=404
+
+1:
+  2017-06-01: 262
+  2024-01-01: 417
+2:
+  2017-06-01: 301
+  2024-01-01: 480
+3:
+  2017-06-01: 317
+  2024-01-01: 542
+4:
+  2017-06-01: 384
+  2024-01-01: 612
+5:
+  2017-06-01: 420
+  2024-01-01: 670
+6:
+  2017-06-01: 460
+  2024-01-01: 734
+7:
+  2017-06-01: 497
+  2024-01-01: 793
+8:
+  2017-06-01: 508
+  2024-01-01: 811
+9:
+  2017-06-01: 508
+  2024-01-01: 811
+10:
+  2017-06-01: 508
+  2024-01-01: 811

policyengine_us/parameters/gov/states/wv/dhhr/works/resources/limit.yaml

@@ -0,0 +1,12 @@
+description: West Virginia limits resources to this amount under the West Virginia Works program.
+
+values:
+  2011-01-01: 2_000
+
+metadata:
+  unit: currency-USD
+  period: month
+  label: West Virginia Works resource limit
+  reference:
+    - title: WV Income Maintenance Manual Chapter 11.3
+      href: https://dhhr.wv.gov/bcf/Services/familyassistance/PolicyManual/Documents/Chapter%2011/ch11_3.pdf#page=1

policyengine_us/parameters/gov/usda/snap/income/deductions/excess_medical_expense/standard.yaml

@@ -205,6 +205,7 @@ WY:
   2021-10-01: 0
   2023-01-01: 138
 metadata:
+  label: SNAP standard medical deduction
   reference:
     - title: SNAP Screener Eligibility Parameters
       href: https://www.snapscreener.com/?p=table

policyengine_us/parameters/gov/usda/snap/income/deductions/utility/limited/main.yaml

@@ -85,10 +85,11 @@ IL:
   2023-10-01: 386
   2024-10-01: 445
 IN:
+  # Indiana does not follow the fiscal year; SUA is effective May 1.
   2010-01-01: 0
-  2021-10-01: 259
+  2021-05-01: 259
   2023-05-01: 276
-  2024-10-01: 274
+  2024-05-01: 274
 KS:
   2010-01-01: 0
   2021-10-01: 286
@@ -110,9 +111,14 @@ MA:
   2023-10-01: 520
   2024-10-01: 542
 MD:
-  2010-01-01: 0
-  2021-10-01: 238
-  2023-01-01: 337
+  # Maryland does not follow the fiscal year; LUA is effective January 1.
+  2010-01-01: 0
+  2020-01-01: 240
+  2021-01-01: 238
+  2022-01-01: 264
+  2023-01-01: 309
+  2024-01-01: 337
+  2025-01-01: 341
 ME:
   2010-01-01: 0
   2021-10-01: 285
@@ -266,6 +272,7 @@ WY:
 metadata:
   unit: currency-USD
   period: month
+  label: SNAP limited utility allowance
   reference:
   - name: USDA | Food and Nutrition Service | SNAP | Standard Utility Allowances
     href: https://www.fns.usda.gov/snap/eligibility/deduction/standard-utility-allowances

policyengine_us/parameters/gov/usda/snap/income/deductions/utility/standard/main.yaml

@@ -1,5 +1,4 @@
-description: A household is eligible for the Standard Utility Allowance if it has
-  separate heating and cooling costs.
+description: A household is eligible for the Standard Utility Allowance if it has separate heating and cooling costs.
 AK:
   2010-01-01: 0
   2021-10-01: 349
@@ -119,15 +118,18 @@ MA:
   2023-10-01: 852
   2024-10-01: 890
 MD:
+  # Maryland does not follow the fiscal year; SUA is effective January 1.
   2010-01-01: 0
-  2021-10-01: 388
-  2023-01-01: 551
+  2021-01-01: 388
+  2022-01-01: 431
+  2023-01-01: 505
   2024-01-01: 551
+  2025-01-01: 557
 ME:
   2010-01-01: 0
   2021-10-01: 844
-  2023-10-01: 1011
-  2024-10-01: 1047
+  2023-10-01: 1_011
+  2024-10-01: 1_047
 MI:
   2010-01-01: 0
   2021-10-01: 569
@@ -256,8 +258,8 @@ VI:
 VT:
   2010-01-01: 0
   2021-10-01: 875
-  2023-10-01: 1020
-  2024-10-01: 1067
+  2023-10-01: 1_020
+  2024-10-01: 1_067
 WA:
   2010-01-01: 0
   2021-10-01: 458

policyengine_us/parameters/gov/usda/snap/max_allotment.yaml

@@ -477,6 +477,7 @@ main:
       2025-10-01: 2_300
 additional:
   metadata:
+    label: SNAP additional maximum allotment
     breakdown:
     - snap_region
   CONTIGUOUS_US:

policyengine_us/parameters/openfisca/completed_programs/state.yaml

@@ -161,5 +161,6 @@ WY:
   2021-01-01:
     - SNAP
 metadata:
+  label: Fully implemented state programs
   breakdown:
   - state_code

policyengine_us/reforms/aca/__init__.py

@@ -4,3 +4,6 @@ from policyengine_us.reforms.aca.aca_ptc_additional_bracket import (
 from policyengine_us.reforms.aca.aca_ptc_simplified_bracket import (
     create_aca_ptc_simplified_bracket_reform,
 )
+from policyengine_us.reforms.aca.aca_ptc_700_fpl_cliff import (
+    create_aca_ptc_700_fpl_cliff_reform,
+)

policyengine_us/reforms/aca/aca_ptc_700_fpl_cliff.py

@@ -0,0 +1,125 @@
+from policyengine_us.model_api import *
+from policyengine_core.periods import period as period_
+
+
+def create_aca_ptc_700_fpl_cliff() -> Reform:
+    class aca_required_contribution_percentage(Variable):
+        """
+        ACA required contribution percentage with amended rate schedule extended to 700% FPL.
+
+        This reform extends ACA premium subsidies to 700% FPL with the following
+        amended contribution schedule:
+
+        Under this reform:
+        - 0-150% FPL: 0% contribution
+        - 150-200% FPL: 0-2% contribution
+        - 200-250% FPL: 2-4% contribution
+        - 250-300% FPL: 4-6% contribution
+        - 300-400% FPL: 6-8.5% contribution
+        - 400-600% FPL: 8.5% contribution (flat)
+        - 600-700% FPL: 8.5-9.25% contribution
+        - Above 700% FPL: No subsidy eligibility
+        """
+
+        value_type = float
+        entity = TaxUnit
+        label = "ACA required contribution percentage with 700% FPL cliff (i.e., IRS Form 8962 'applicable figure')"
+        unit = "/1"
+        definition_period = YEAR
+        reference = [
+            "26 U.S. Code § 36B(b)(3)(A) - Refundable credit for coverage under a qualified health plan",
+            "https://www.law.cornell.edu/uscode/text/26/36B#b_3_A",
+        ]
+
+        def formula(tax_unit, period, parameters):
+            magi_frac = tax_unit("aca_magi_fraction", period)
+            p = parameters(period).gov.contrib.aca.ptc_700_fpl_cliff.brackets
+            return np.interp(magi_frac, p.thresholds, p.amounts)
+
+    class is_aca_ptc_eligible(Variable):
+        """
+        Extended ACA PTC eligibility up to 700% FPL.
+        """
+
+        value_type = bool
+        entity = Person
+        label = "Person is eligible for ACA premium tax credit and pays ACA premium"
+        definition_period = YEAR
+
+        def formula(person, period, parameters):
+            # determine status eligibility for ACA PTC
+            fstatus = person.tax_unit("filing_status", period)
+            separate = fstatus == fstatus.possible_values.SEPARATE
+            immigration_eligible = person(
+                "is_aca_ptc_immigration_status_eligible", period
+            )
+            taxpayer_has_itin = person.tax_unit("taxpayer_has_itin", period)
+            is_status_eligible = (
+                taxpayer_has_itin & ~separate & immigration_eligible
+            )
+
+            # determine coverage eligibility for ACA plan
+            INELIGIBLE_COVERAGE = [
+                "is_medicaid_eligible",
+                "is_chip_eligible",
+                "is_aca_eshi_eligible",
+                "is_medicare_eligible",
+            ]
+            is_coverage_eligible = (
+                add(person, period, INELIGIBLE_COVERAGE) == 0
+            )
+
+            # determine income eligibility for ACA PTC (using reform parameter)
+            p = parameters(period).gov.contrib.aca.ptc_700_fpl_cliff
+            magi_frac = person.tax_unit("aca_magi_fraction", period)
+            is_income_eligible = p.income_eligibility.calc(magi_frac)
+
+            # determine which people pay an age-based ACA plan premium
+            p_aca = parameters(period).gov.aca
+            is_aca_adult = person("age", period) > p_aca.slcsp.max_child_age
+            child_pays = (
+                person("aca_child_index", period) <= p_aca.max_child_count
+            )
+            pays_aca_premium = is_aca_adult | child_pays
+
+            return (
+                is_status_eligible
+                & is_coverage_eligible
+                & is_income_eligible
+                & pays_aca_premium
+            )
+
+    class reform(Reform):
+        def apply(self):
+            self.update_variable(aca_required_contribution_percentage)
+            self.update_variable(is_aca_ptc_eligible)
+
+    return reform
+
+
+def create_aca_ptc_700_fpl_cliff_reform(
+    parameters, period, bypass: bool = False
+):
+    if bypass:
+        return create_aca_ptc_700_fpl_cliff()
+
+    p = parameters.gov.contrib.aca.ptc_700_fpl_cliff
+    current_period = period_(period)
+
+    # Check if reform is active within a 5-year lookahead window
+    reform_active = False
+    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_aca_ptc_700_fpl_cliff()
+    else:
+        return None
+
+
+aca_ptc_700_fpl_cliff = create_aca_ptc_700_fpl_cliff_reform(
+    None, None, bypass=True
+)

policyengine_us/reforms/cdcc/__init__.py

@@ -0,0 +1,3 @@
+from policyengine_us.reforms.cdcc.cdcc_single_parent_work_requirement import (
+    create_cdcc_single_parent_work_requirement_reform,
+)

policyengine_us/reforms/cdcc/cdcc_single_parent_work_requirement.py

@@ -0,0 +1,81 @@
+from policyengine_us.model_api import *
+from policyengine_core.periods import period as period_
+
+
+def create_cdcc_single_parent_work_requirement() -> Reform:
+    """
+    Reform that changes CDCTC eligibility to require at least one parent to work
+    instead of both parents.
+
+    Current law: For married couples, childcare expenses are capped at the
+    minimum of the two spouses' earnings, effectively requiring both to work.
+
+    This reform: Changes the cap to the maximum of the two spouses' earnings,
+    allowing families to qualify if at least one parent works.
+
+    Note: We override cdcc_relevant_expenses directly (rather than
+    min_head_spouse_earned) to avoid affecting state programs that also
+    use min_head_spouse_earned.
+    """
+
+    class cdcc_relevant_expenses(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "CDCC-relevant care expenses"
+        unit = USD
+        definition_period = YEAR
+        reference = (
+            "https://www.law.cornell.edu/uscode/text/26/21#c",
+            "https://www.law.cornell.edu/uscode/text/26/21#d_1",
+        )
+
+        def formula(tax_unit, period, parameters):
+            expenses = tax_unit("tax_unit_childcare_expenses", period)
+            cdcc_limit = tax_unit("cdcc_limit", period)
+            eligible_capped_expenses = min_(expenses, cdcc_limit)
+
+            # Reform: Use max of head/spouse earnings instead of min
+            # This allows eligibility if at least one parent works
+            is_joint = tax_unit("tax_unit_is_joint", period)
+            head_earnings = tax_unit("head_earned", period)
+            spouse_earnings = tax_unit("spouse_earned", period)
+            earnings_cap = where(
+                is_joint, max_(head_earnings, spouse_earnings), head_earnings
+            )
+
+            return min_(eligible_capped_expenses, earnings_cap)
+
+    class reform(Reform):
+        def apply(self):
+            self.update_variable(cdcc_relevant_expenses)
+
+    return reform
+
+
+def create_cdcc_single_parent_work_requirement_reform(
+    parameters, period, bypass: bool = False
+):
+    if bypass:
+        return create_cdcc_single_parent_work_requirement()
+
+    p = parameters.gov.contrib.cdcc.single_parent_work_requirement
+
+    # Check if reform is active in current period or next 5 years
+    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_cdcc_single_parent_work_requirement()
+    else:
+        return None
+
+
+cdcc_single_parent_work_requirement = (
+    create_cdcc_single_parent_work_requirement_reform(None, None, bypass=True)
+)

policyengine_us/reforms/crfb/non_refundable_ss_credit.py

@@ -17,7 +17,17 @@ def non_refundable_ss_credit_reform() -> Reform:
             ss_tax = taxable_social_security * highest_tax_rate
             p = parameters(period).gov.contrib.crfb.ss_credit
             filing_status = person.tax_unit("filing_status", period)
-            return min_(ss_tax, p.amount[filing_status])
+            base_amount = min_(ss_tax, p.amount[filing_status])
+            phase_out_applies = p.phase_out.applies
+            joint = filing_status == filing_status.possible_values.JOINT
+            agi = person.tax_unit("adjusted_gross_income", period)
+            phase_out_rate = where(
+                joint,
+                p.phase_out.rate.joint.calc(agi),
+                p.phase_out.rate.other.calc(agi),
+            )
+            phase_out = phase_out_applies * phase_out_rate
+            return max_(0, base_amount - phase_out)
 
     class highest_tax_rate(Variable):
         value_type = float

policyengine_us/reforms/reforms.py

@@ -121,9 +121,19 @@ from .states.ri.ctc.ri_ctc_reform import create_ri_ctc_reform
 from .states.ri.exemption.ri_exemption_reform import (
     create_ri_exemption_reform_fn,
 )
+from .states.de.dependent_credit.de_dependent_credit_reform import (
+    create_de_dependent_credit_reform_fn,
+)
+from .states.va.dependent_exemption.va_dependent_exemption_reform import (
+    create_va_dependent_exemption_reform_fn,
+)
 from .aca import (
     create_aca_ptc_additional_bracket_reform,
     create_aca_ptc_simplified_bracket_reform,
+    create_aca_ptc_700_fpl_cliff_reform,
+)
+from .cdcc import (
+    create_cdcc_single_parent_work_requirement_reform,
 )
 
 
@@ -276,12 +286,24 @@ def create_structural_reforms_from_parameters(parameters, period):
     )
     ri_ctc = create_ri_ctc_reform(parameters, period)
     ri_exemption = create_ri_exemption_reform_fn(parameters, period)
+    de_dependent_credit = create_de_dependent_credit_reform_fn(
+        parameters, period
+    )
+    va_dependent_exemption = create_va_dependent_exemption_reform_fn(
+        parameters, period
+    )
     aca_ptc_additional_bracket = create_aca_ptc_additional_bracket_reform(
         parameters, period
     )
     aca_ptc_simplified_bracket = create_aca_ptc_simplified_bracket_reform(
         parameters, period
     )
+    aca_ptc_700_fpl_cliff = create_aca_ptc_700_fpl_cliff_reform(
+        parameters, period
+    )
+    cdcc_single_parent_work_requirement = (
+        create_cdcc_single_parent_work_requirement_reform(parameters, period)
+    )
 
     reforms = [
         afa_reform,
@@ -337,8 +359,12 @@ def create_structural_reforms_from_parameters(parameters, period):
         ctc_minimum_refundable_amount,
         ri_ctc,
         ri_exemption,
+        de_dependent_credit,
+        va_dependent_exemption,
         aca_ptc_additional_bracket,
         aca_ptc_simplified_bracket,
+        aca_ptc_700_fpl_cliff,
+        cdcc_single_parent_work_requirement,
     ]
     reforms = tuple(filter(lambda x: x is not None, reforms))
 

policyengine_us/reforms/state_dependent_exemptions/repeal_state_dependent_exemptions.py

@@ -420,7 +420,7 @@ def create_repeal_state_dependent_exemptions() -> Reform:
             income = tax_unit("ky_modified_agi", period)
             fpg = parameters(period).gov.hhs.fpg
             # This will be CONTIGUOUS_US for Kentucky.
-            state_group = tax_unit.household("state_group", period)
+            state_group = tax_unit.household("state_group_str", period)
             p1 = fpg.first_person[state_group]
             padd = fpg.additional_person[state_group]
             family_size = tax_unit("head_spouse_count", period)

policyengine_us/reforms/states/de/__init__.py

@@ -0,0 +1,3 @@
+from .dependent_credit.de_dependent_credit_reform import (
+    create_de_dependent_credit_reform_fn,
+)

policyengine_us/reforms/states/de/dependent_credit/de_dependent_credit_reform.py

@@ -0,0 +1,165 @@
+from policyengine_us.model_api import *
+from policyengine_core.periods import period as period_
+from policyengine_core.periods import instant
+
+
+def create_de_dependent_credit_reform() -> Reform:
+    class de_eligible_dependents_count(Variable):
+        value_type = int
+        entity = TaxUnit
+        label = "Delaware eligible dependents count"
+        definition_period = YEAR
+        defined_for = StateCode.DE
+
+        def formula(tax_unit, period, parameters):
+            p = parameters(period).gov.contrib.states.de.dependent_credit
+
+            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 de_dependent_credit_maximum(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Delaware dependent credit maximum before phaseout"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.DE
+
+        def formula(tax_unit, period, parameters):
+            p = parameters(period).gov.contrib.states.de.dependent_credit
+
+            dependents_count = tax_unit("de_eligible_dependents_count", period)
+            return dependents_count * p.amount
+
+    class de_dependent_credit_phaseout(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Delaware dependent credit phaseout amount"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.DE
+
+        def formula(tax_unit, period, parameters):
+            p = parameters(period).gov.contrib.states.de.dependent_credit
+
+            filing_status = tax_unit("filing_status", period)
+            files_separately = tax_unit("de_files_separately", period)
+            agi_indiv = add(tax_unit, period, ["de_agi_indiv"])
+            agi_joint = add(tax_unit, period, ["de_agi_joint"])
+            agi = where(files_separately, agi_indiv, agi_joint)
+
+            threshold = p.phaseout.threshold[filing_status]
+            excess_income = max_(agi - threshold, 0)
+            return excess_income * p.phaseout.rate
+
+    class de_dependent_credit(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Delaware dependent credit"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.DE
+
+        def formula(tax_unit, period, parameters):
+
+            maximum = tax_unit("de_dependent_credit_maximum", period)
+            phaseout = tax_unit("de_dependent_credit_phaseout", period)
+
+            return max_(maximum - phaseout, 0)
+
+    class de_older_dependents_count(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Delaware older dependents count"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.DE
+
+        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_credit = tax_unit(
+                "de_eligible_dependents_count", period
+            )
+            return max_(0, total_dependents - eligible_dependent_credit)
+
+    class de_personal_credit(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Delaware personal credit"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.DE
+
+        def formula(tax_unit, period, parameters):
+            p_base = parameters(
+                period
+            ).gov.states.de.tax.income.credits.personal_credits
+
+            # Calculate personal credit base amount (head + spouse + older dependents)
+            filing_status = tax_unit("filing_status", period)
+            older_dependents = tax_unit("de_older_dependents_count", period)
+            personal_count = (
+                where(
+                    filing_status == filing_status.possible_values.JOINT,
+                    2,
+                    1,
+                )
+                + older_dependents
+            )
+            personal_credit_amount = personal_count * p_base.personal
+
+            # Add dependent credit (has its own phase-out logic)
+            dependent_credit_amount = tax_unit("de_dependent_credit", period)
+
+            return personal_credit_amount + dependent_credit_amount
+
+    class reform(Reform):
+        def apply(self):
+            self.update_variable(de_eligible_dependents_count)
+            self.update_variable(de_dependent_credit_maximum)
+            self.update_variable(de_dependent_credit_phaseout)
+            self.update_variable(de_dependent_credit)
+            self.update_variable(de_older_dependents_count)
+            self.update_variable(de_personal_credit)
+
+    return reform
+
+
+def create_de_dependent_credit_reform_fn(
+    parameters, period, bypass: bool = False
+):
+    if bypass:
+        return create_de_dependent_credit_reform()
+
+    p = parameters.gov.contrib.states.de.dependent_credit
+
+    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_de_dependent_credit_reform()
+    else:
+        return None
+
+
+de_dependent_credit_reform = create_de_dependent_credit_reform_fn(
+    None, None, bypass=True
+)

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

@@ -82,9 +82,30 @@ def create_ri_ctc() -> Reform:
             filing_status = tax_unit("filing_status", period)
             agi = tax_unit("ri_agi", period)
 
-            threshold = p.phaseout.threshold[filing_status]
+            # Range-based phaseout: when end > start, calculate rate dynamically
+            phaseout_start = p.phaseout.start
+            phaseout_end = p.phaseout.end
+            range_based_active = phaseout_end > phaseout_start
+
+            # Threshold: use start for range-based, filing-status threshold for rate-based
+            threshold = where(
+                range_based_active,
+                phaseout_start,
+                p.phaseout.threshold[filing_status],
+            )
             excess_income = max_(agi - threshold, 0)
-            return excess_income * p.phaseout.rate
+
+            # Rate: calculate from range for range-based, use explicit rate otherwise
+            maximum = tax_unit("ri_ctc_maximum", period)
+            range_width = phaseout_end - phaseout_start
+            range_based_rate = where(
+                range_based_active, maximum / range_width, 0
+            )
+            effective_rate = where(
+                range_based_active, range_based_rate, p.phaseout.rate
+            )
+
+            return excess_income * effective_rate
 
     class ri_total_ctc(Variable):
         value_type = float

policyengine_us/reforms/states/va/__init__.py

@@ -0,0 +1,3 @@
+from .dependent_exemption.va_dependent_exemption_reform import (
+    create_va_dependent_exemption_reform_fn,
+)