policyengine-us 1.358.1__py3-none-any.whl → 1.360.0__py3-none-any.whl

policyengine_us/variables/gov/states/dc/dhs/tanf/eligibility/dc_tanf_basic_eligibility_requirements.py

@@ -0,0 +1,18 @@
+from policyengine_us.model_api import *
+
+
+class dc_tanf_basic_eligibility_requirements(Variable):
+    value_type = bool
+    entity = SPMUnit
+    label = "Basic eligibility requirements for DC Temporary Assistance for Needy Families (TANF)"
+    definition_period = MONTH
+    reference = "https://dhs.dc.gov/service/tanf-district-families"
+    defined_for = StateCode.DC
+
+    def formula(spm_unit, period, parameters):
+        demographic_eligible = (
+            add(spm_unit, period, ["dc_tanf_demographic_eligible_person"]) > 0
+        )
+        income_eligible = spm_unit("dc_tanf_income_eligible", period)
+        resources_eligible = spm_unit("dc_tanf_resources_eligible", period)
+        return demographic_eligible & income_eligible & resources_eligible

policyengine_us/variables/gov/states/dc/dhs/tanf/eligibility/dc_tanf_demographic_eligible_person.py

@@ -13,17 +13,15 @@ class dc_tanf_demographic_eligible_person(Variable):
     defined_for = StateCode.DC
 
     def formula(person, period, parameters):
-        p = parameters(period).gov.states.dc.dhs.tanf.age_threshold
-        age = person("monthly_age", period)
-        dependent = person("is_tax_unit_dependent", period)
-        minor_child = age < p.minor_child
-        eligible_minor_child = minor_child & dependent
-
-        student_dependent = age < p.student_dependent
-        secondary_school_student = person("is_in_secondary_school", period)
-        eligible_student_dependent = (
-            secondary_school_student & student_dependent & dependent
+        pap_eligible_child = person("dc_pap_eligible_child", period)
+        related_to_head_or_spouse = person(
+            "is_related_to_head_or_spouse", period
         )
-
         pregnant = person("is_pregnant", period)
-        return eligible_minor_child | eligible_student_dependent | pregnant
+        immigration_status_eligible = person(
+            "dc_tanf_immigration_status_eligible_person", period
+        )
+
+        return (pap_eligible_child & related_to_head_or_spouse) | (
+            pregnant & immigration_status_eligible
+        )

policyengine_us/variables/gov/states/dc/dhs/tanf/eligibility/dc_tanf_eligible.py

@@ -10,22 +10,10 @@ class dc_tanf_eligible(Variable):
     defined_for = StateCode.DC
 
     def formula(spm_unit, period, parameters):
-        demographic_eligible = (
-            add(spm_unit, period, ["dc_tanf_demographic_eligible_person"]) > 0
+        meets_basic_eligibility_requirements = spm_unit(
+            "dc_tanf_basic_eligibility_requirements", period
         )
-        income_eligible = spm_unit("dc_tanf_income_eligible", period)
-        resources_eligible = spm_unit("dc_tanf_resources_eligible", period)
-        immigration_status_eligible = (
-            add(
-                spm_unit,
-                period,
-                ["dc_tanf_immigration_status_eligible_person"],
-            )
-            > 0
-        )
-        return (
-            demographic_eligible
-            & income_eligible
-            & resources_eligible
-            & immigration_status_eligible
+        meets_work_requirements = spm_unit(
+            "dc_tanf_meets_work_requirements", period
         )
+        return meets_basic_eligibility_requirements & meets_work_requirements

policyengine_us/variables/gov/states/dc/dhs/tanf/eligibility/dc_tanf_immigration_status_eligible_person.py

@@ -12,9 +12,14 @@ class dc_tanf_immigration_status_eligible_person(Variable):
     defined_for = StateCode.DC
 
     def formula(person, period, parameters):
-        qualified_noncitizen = person("is_ssi_qualified_noncitizen", period)
+        p = parameters(period).gov.states.dc.dhs
         immigration_status = person("immigration_status", period)
+        immigration_status_str = immigration_status.decode_to_str()
         is_citizen = (
             immigration_status == immigration_status.possible_values.CITIZEN
         )
+        qualified_noncitizen = np.isin(
+            immigration_status_str,
+            p.qualified_noncitizen_statuses,
+        )
         return qualified_noncitizen | is_citizen

policyengine_us/variables/gov/states/dc/dhs/tanf/income/dc_tanf_countable_income.py

@@ -20,5 +20,10 @@ class dc_tanf_countable_income(Variable):
                 "dc_tanf_countable_unearned_income",
             ],
         )
+        # Exclude income from GAC, this only applies when the child in household is unrelated to
+        # the head or spouse
+        gac_countable_income = spm_unit("dc_gac_countable_income", period)
         childcare_deduction = spm_unit("dc_tanf_childcare_deduction", period)
-        return max_(income_sources - childcare_deduction, 0)
+        return max_(
+            income_sources - gac_countable_income - childcare_deduction, 0
+        )

policyengine_us/variables/gov/states/dc/dhs/tanf/work_requirement/dc_tanf_is_working.py

@@ -0,0 +1,40 @@
+from policyengine_us.model_api import *
+
+
+class dc_tanf_is_working(Variable):
+    value_type = bool
+    entity = Person
+    label = "Person is working under the work requirement for DC Temporary Assistance for Needy Families (TANF)"
+    definition_period = MONTH
+    reference = (
+        "https://code.dccouncil.gov/us/dc/council/code/sections/4-205.19b"
+    )
+    defined_for = StateCode.DC
+
+    def formula(person, period, parameters):
+        p = parameters(
+            period
+        ).gov.states.dc.dhs.tanf.work_requirement.required_hours
+        weekly_hours_worked = person("weekly_hours_worked", period.this_year)
+        age = person("monthly_age", period)
+        # For single parent with a child under 6, work 20 hours pr week
+        # For single parent with a child at 6 or older, work 30 hours pr week
+        spm_unit = person.spm_unit
+        is_youngest_member = person.get_rank(spm_unit, age, spm_unit) == 0
+        youngest_age = spm_unit.sum(is_youngest_member * age)
+        single_parent_requirement = (
+            weekly_hours_worked >= p.single_parent.amount.calc(youngest_age)
+        )
+        # For 2-parent, work 35 hours pr week (combined)
+        # Or 55 hours per week if family receives federally-funded childcare and
+        # no adult has a disability (not modeled)
+        is_head_or_spouse = person("is_tax_unit_head_or_spouse", period)
+        parent_hours = where(is_head_or_spouse, weekly_hours_worked, 0)
+        combined_parent_hours = spm_unit.sum(parent_hours)
+        two_parent_requirement = combined_parent_hours >= p.two_parents.amount
+        is_two_parent_unit = spm_unit.sum(is_head_or_spouse) > 1
+        return where(
+            is_two_parent_unit,
+            two_parent_requirement,
+            single_parent_requirement,
+        )

policyengine_us/variables/gov/states/dc/dhs/tanf/work_requirement/dc_tanf_meets_work_requirements.py

@@ -0,0 +1,22 @@
+from policyengine_us.model_api import *
+
+
+class dc_tanf_meets_work_requirements(Variable):
+    value_type = bool
+    entity = SPMUnit
+    label = "Work requirement satisfied for DC Temporary Assistance for Needy Families (TANF)"
+    definition_period = MONTH
+    reference = (
+        "https://code.dccouncil.gov/us/dc/council/code/sections/4-205.19b",
+        "https://code.dccouncil.gov/us/dc/council/code/sections/4-205.19g",
+    )
+    defined_for = StateCode.DC
+
+    def formula(spm_unit, period, parameters):
+        person = spm_unit.members
+        is_working = person("dc_tanf_is_working", period)
+        work_requirement_exempt = person(
+            "dc_tanf_work_requirement_exempt", period
+        )
+        meets_work_requirements = is_working | work_requirement_exempt
+        return spm_unit.sum(~meets_work_requirements) == 0

policyengine_us/variables/gov/states/dc/dhs/tanf/work_requirement/dc_tanf_work_requirement_exempt.py

@@ -0,0 +1,39 @@
+from policyengine_us.model_api import *
+
+
+class dc_tanf_work_requirement_exempt(Variable):
+    value_type = bool
+    entity = Person
+    definition_period = MONTH
+    label = "Exempted from working requirement for DC Temporary Assistance for Needy Families (TANF)"
+    reference = (
+        "https://code.dccouncil.gov/us/dc/council/code/sections/4-205.19g"
+    )
+    defined_for = StateCode.DC
+
+    def formula(person, period, parameters):
+        p = parameters(
+            period
+        ).gov.states.dc.dhs.tanf.work_requirement.work_exempted
+        age = person("monthly_age", period)
+        # (1) Eligible child who are not the head of an assistance unit can exempt
+        eligible_child = person("dc_pap_eligible_child", period)
+        # (2) Single parent works more than 30 hours per week (modeled in work requirements)
+        # (3) Two-parent work more than 35 hours per week (modeled in work requirements)
+        # (4) Single parent can exempt with infant less than 1 years old can exempt
+        filing_status = person.tax_unit("filing_status", period)
+        joint = filing_status == filing_status.possible_values.JOINT
+        has_infant = person.spm_unit.any(age < p.infant_age_threshold)
+        is_head = person("is_tax_unit_head", period)
+        single_parent_exempt = ~joint & has_infant & is_head
+        # (5) Person older than 60 can exempt
+        elderly = age > p.elderly_age_threshold
+        # (6) Individuals who are enrolled in post-secondary educational institutions
+        is_college_student = person("is_full_time_college_student", period)
+
+        return (
+            eligible_child
+            | single_parent_exempt
+            | elderly
+            | is_college_student
+        )

policyengine_us/variables/gov/states/vt/tax/income/adjusted_gross_income/subtractions/retirement_income_exemption/vt_military_retirement_cap_based_exemption.py

@@ -0,0 +1,25 @@
+from policyengine_us.model_api import *
+
+
+class vt_military_retirement_cap_based_exemption(Variable):
+    value_type = float
+    entity = TaxUnit
+    definition_period = YEAR
+    label = "Vermont military retirement cap-based exemption"
+    reference = "https://tax.vermont.gov/sites/tax/files/documents/IN-112-Instr-2024.pdf#page=2"
+    unit = USD
+    defined_for = StateCode.VT
+    documentation = "Vermont military retirement benefits exempt from Vermont taxation up to cap amount (pre-2025)."
+
+    def formula(tax_unit, period, parameters):
+        p = parameters(
+            period
+        ).gov.states.vt.tax.income.agi.retirement_income_exemption.military_retirement
+
+        # Get retirement amount from military retirement system
+        tax_unit_military_retirement_pay = add(
+            tax_unit, period, ["military_retirement_pay"]
+        )
+
+        # Cap exemption at the specified amount
+        return min_(tax_unit_military_retirement_pay, p.amount)

policyengine_us/variables/gov/states/vt/tax/income/adjusted_gross_income/subtractions/retirement_income_exemption/vt_military_retirement_income_based_exemption.py

@@ -0,0 +1,79 @@
+from policyengine_us.model_api import *
+import numpy as np
+
+
+class vt_military_retirement_income_based_exemption(Variable):
+    value_type = float
+    entity = TaxUnit
+    definition_period = YEAR
+    label = "Vermont military retirement income-based exemption"
+    reference = "https://legislature.vermont.gov/Documents/2026/Docs/BILLS/S-0051/S-0051%20As%20Passed%20by%20Both%20House%20and%20Senate%20Official.pdf#page=10"
+    unit = USD
+    defined_for = StateCode.VT
+    documentation = "Vermont military retirement benefits exempt from Vermont taxation based on AGI thresholds (2025+)."
+
+    def formula(tax_unit, period, parameters):
+        p = parameters(
+            period
+        ).gov.states.vt.tax.income.agi.retirement_income_exemption.military_retirement
+
+        # Get retirement amount from military retirement system
+        tax_unit_military_retirement_pay = add(
+            tax_unit, period, ["military_retirement_pay"]
+        )
+
+        agi = tax_unit("adjusted_gross_income", period)
+
+        # Check if thresholds are finite (feature is active)
+        thresholds_are_finite = ~np.isinf(
+            p.full_exemption_threshold
+        ) & ~np.isinf(p.partial_exemption_threshold)
+
+        # Full exemption if below the threshold AND thresholds are finite
+        eligible_for_full_exemption = thresholds_are_finite & (
+            agi < p.full_exemption_threshold
+        )
+
+        # Partial exemption if between the thresholds AND thresholds are finite
+        eligible_for_partial_exemption = (
+            thresholds_are_finite
+            & (agi >= p.full_exemption_threshold)
+            & (agi <= p.partial_exemption_threshold)
+        )
+
+        # Calculate partial exemption amount (linear phaseout)
+        threshold_difference = (
+            p.partial_exemption_threshold - p.full_exemption_threshold
+        )
+        agi_below_threshold = max_(p.partial_exemption_threshold - agi, 0)
+
+        # Use mask to avoid division by zero
+        valid_threshold_difference = threshold_difference != 0
+        partial_exemption_amount = where(
+            valid_threshold_difference,
+            tax_unit_military_retirement_pay
+            * agi_below_threshold
+            / threshold_difference,
+            0,
+        )
+
+        # Calculate exemption amounts for each case
+        full_exemption_amount = tax_unit_military_retirement_pay
+        partial_exemption_amount_capped = max_(partial_exemption_amount, 0)
+        no_exemption_amount = 0
+
+        # First determine if partial or no exemption
+        partial_or_no_exemption = where(
+            eligible_for_partial_exemption,
+            partial_exemption_amount_capped,
+            no_exemption_amount,
+        )
+
+        # Then determine final exemption amount
+        exemption_amount = where(
+            eligible_for_full_exemption,
+            full_exemption_amount,
+            partial_or_no_exemption,
+        )
+
+        return exemption_amount

policyengine_us/variables/gov/states/vt/tax/income/adjusted_gross_income/subtractions/retirement_income_exemption/vt_military_retirement_pay_exclusion.py

@@ -17,7 +17,6 @@ class vt_military_retirement_pay_exclusion(Variable):
     )
 
     def formula(tax_unit, period, parameters):
-        person = tax_unit.members
         p = parameters(
             period
         ).gov.states.vt.tax.income.agi.retirement_income_exemption
@@ -25,7 +24,23 @@ class vt_military_retirement_pay_exclusion(Variable):
         tax_unit_military_retirement_pay = add(
             tax_unit, period, ["military_retirement_pay"]
         )
-        # Retirement income from systems other than social security have maximum amount.
-        return min_(
-            tax_unit_military_retirement_pay, p.military_retirement.amount
+
+        # S.51 (2025): Income-based military pension exemption
+        is_income_based_system = (
+            p.military_retirement.income_based_structure.in_effect
+        )
+        agi = tax_unit("adjusted_gross_income", period)
+
+        # Calculate exemption based on system type
+        income_based_exemption = tax_unit(
+            "vt_military_retirement_income_based_exemption", period
+        )
+        cap_based_exemption = tax_unit(
+            "vt_military_retirement_cap_based_exemption", period
+        )
+
+        return where(
+            is_income_based_system,
+            income_based_exemption,
+            cap_based_exemption,
         )

policyengine_us/variables/gov/states/vt/tax/income/credits/vt_veteran_tax_credit.py

@@ -0,0 +1,58 @@
+from policyengine_us.model_api import *
+
+
+class vt_veteran_tax_credit(Variable):
+    value_type = float
+    entity = TaxUnit
+    label = "Vermont veteran tax credit"
+    definition_period = YEAR
+    unit = USD
+    reference = [
+        "https://vtdigger.org/2025/06/25/gov-phil-scott-signs-13-5-million-tax-credit-package-benefiting-low-income-workers-families-retirees-and-veterans/"
+    ]
+    defined_for = StateCode.VT
+    documentation = "Vermont veteran tax credit providing $250 refundable credit for low-income veterans as part of S.51 (2025) tax relief package."
+
+    def formula(tax_unit, period, parameters):
+        # Check if anyone in tax unit is a veteran
+        person = tax_unit.members
+        is_veteran = person("is_veteran", period)
+        veteran_present = tax_unit.any(is_veteran)
+
+        # Get parameters for veteran credit
+        p = parameters(period).gov.states.vt.tax.income.credits.veteran
+
+        # Get adjusted gross income for phaseout
+        agi = tax_unit("adjusted_gross_income", period)
+
+        # Full credit for households under $25k AGI
+        # Partial credit for households under $30k AGI
+
+        # Calculate credit amount based on veteran status and income
+        eligible_for_full_credit = veteran_present & (
+            agi < p.full_credit_threshold
+        )
+        eligible_for_partial_credit = (
+            veteran_present
+            & (agi >= p.full_credit_threshold)
+            & (agi < p.partial_credit_threshold)
+        )
+
+        # Calculate partial credit amount based on parameterized reduction structure
+        excess_income = agi - p.full_credit_threshold
+        # Number of income increments (rounded up)
+        income_increments = np.ceil(excess_income / p.income_increment)
+        # Reduction per increment
+        reduction_amount = income_increments * p.reduction_per_increment
+        # Calculate partial credit (minimum of 0)
+        partial_credit_amount = max_(p.amount - reduction_amount, 0)
+
+        return where(
+            eligible_for_full_credit,
+            p.amount,
+            where(
+                eligible_for_partial_credit,
+                partial_credit_amount,
+                0,
+            ),
+        )

policyengine_us/variables/gov/states/vt/tax/income/vt_eitc.py

@@ -12,5 +12,13 @@ class vt_eitc(Variable):
 
     def formula(tax_unit, period, parameters):
         federal_eitc = tax_unit("eitc", period)
-        rate = parameters(period).gov.states.vt.tax.income.credits.eitc.match
+        p = parameters(period).gov.states.vt.tax.income.credits.eitc
+        child_dependents = tax_unit("tax_unit_child_dependents", period)
+
+        rate = where(
+            p.enhanced_structure.in_effect,
+            p.enhanced_structure.rate.calc(child_dependents),
+            p.match,
+        )
+
         return federal_eitc * rate

policyengine_us/variables/household/demographic/person/is_related_to_head_or_spouse.py

@@ -0,0 +1,9 @@
+from policyengine_us.model_api import *
+
+
+class is_related_to_head_or_spouse(Variable):
+    value_type = bool
+    entity = Person
+    label = "Person is related to head or spouse"
+    definition_period = YEAR
+    default_value = True

{policyengine_us-1.358.1.dist-info → policyengine_us-1.360.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: policyengine-us
-Version: 1.358.1
+Version: 1.360.0
 Summary: Add your description here.
 Author-email: PolicyEngine <hello@policyengine.org>
 License-File: LICENSE