policyengine-us 1.353.0__py3-none-any.whl → 1.355.0__py3-none-any.whl

policyengine_us/reforms/reconciliation/reconciled_qbid.py

@@ -1,78 +0,0 @@
-from policyengine_us.model_api import *
-from policyengine_core.periods import period as period_
-from policyengine_core.periods import instant
-
-
-def create_reconciled_qbid() -> Reform:
-    class qbid_amount(Variable):
-        value_type = float
-        entity = Person
-        label = "Per‑cap qualified business income deduction amount for each person"
-        unit = USD
-        definition_period = YEAR
-        reference = (
-            "https://www.law.cornell.edu/uscode/text/26/199A#b_1"
-            "https://www.irs.gov/pub/irs-prior/p535--2018.pdf"
-        )
-
-        def formula(person, period, parameters):
-            p = parameters(period).gov.irs.deductions
-
-            # 1. Compute the new maximum QBID
-            qbi = person("qualified_business_income", period)
-            qbid_max = p.qbi.max.rate * qbi
-
-            # 2. Compute the wage/property cap (unchanged)
-            w2_wages = person("w2_wages_from_qualified_business", period)
-            b_property = person("unadjusted_basis_qualified_property", period)
-            wage_cap = w2_wages * p.qbi.max.w2_wages.rate
-            alt_cap = (
-                w2_wages * p.qbi.max.w2_wages.alt_rate
-                + b_property * p.qbi.max.business_property.rate
-            )
-            full_cap = max_(wage_cap, alt_cap)
-
-            # 3. Phase‑out logic: 75% of each dollar above the threshold
-            taxinc_less_qbid = person.tax_unit(
-                "taxable_income_less_qbid", period
-            )
-            filing_status = person.tax_unit("filing_status", period)
-            threshold = p.qbi.phase_out.start[filing_status]
-            p_ref = parameters(period).gov.contrib.reconciliation.qbid
-            phase_out_rate = p_ref.phase_out_rate
-            excess_income = max_(0, taxinc_less_qbid - threshold)
-            reduction_amount = phase_out_rate * excess_income
-            # 4. Apply phase‑out to the 22% deduction
-            phased_deduction = max_(0, qbid_max - reduction_amount)
-            # 5. Final QBID is the lesser of the phased deduction or the wage/property cap
-            return min_(phased_deduction, full_cap)
-
-    class reform(Reform):
-        def apply(self):
-            self.update_variable(qbid_amount)
-
-    return reform
-
-
-def create_reconciled_qbid_reform(parameters, period, bypass: bool = False):
-    if bypass:
-        return create_reconciled_qbid()
-
-    p = parameters.gov.contrib.reconciliation.qbid
-
-    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_reconciled_qbid()
-    else:
-        return None
-
-
-reconciled_qbid = create_reconciled_qbid_reform(None, None, bypass=True)

policyengine_us/reforms/reconciliation/reconciled_snap_abawd_work_requirement.py

@@ -1,125 +0,0 @@
-from policyengine_us.model_api import *
-from policyengine_core.periods import period as period_
-from policyengine_core.periods import instant
-
-
-def create_reconciled_snap_abawd_work_requirement() -> Reform:
-    class meets_snap_abawd_work_requirements(Variable):
-        value_type = bool
-        entity = Person
-        label = "Person is eligible for SNAP benefits via Able-Bodied Adult Without Dependents (ABAWD) work requirements"
-        definition_period = MONTH
-        reference = "https://agriculture.house.gov/uploadedfiles/ag-recon-combo_03_xml.pdf#page=4"
-
-        def formula(person, period, parameters):
-            p = parameters(period).gov.usda.snap.work_requirements.abawd
-            age = person("monthly_age", period)
-            weekly_hours_worked = person(
-                "weekly_hours_worked", period.this_year
-            )
-            # Work at least 20 hours a week
-            is_working = weekly_hours_worked >= p.weekly_hours_threshold
-            # Under 18 or 65 years of age or older are exempted (baseline is 18 or 65) (A)
-            worked_exempted_age = p.age_threshold.exempted.calc(age)
-            # Unable to work due to a physical or mental limitation (B)
-            is_disabled = person("is_disabled", period)
-            # Parent of a household member under 7 (baseline is 18) (C)
-            is_dependent = person("is_tax_unit_dependent", period)
-            is_qualifying_child = age < p.age_threshold.dependent
-            is_parent = person("is_parent", period)
-            has_child = person.spm_unit.any(is_dependent & is_qualifying_child)
-            exempted_parent = is_parent & has_child
-            # Exempted from the general work requirements (D)
-            meets_snap_general_work_requirements = person(
-                "meets_snap_general_work_requirements", period
-            )
-            # Pregnant (E)
-            is_pregnant = person("is_pregnant", period)
-            # Homeless (remove in 2030) (F)
-            is_homeless = person.household("is_homeless", period)
-            # A veteran (remove in 2030) (G)
-            is_veteran = person("is_veteran", period)
-            # Responsible for a child 7 or older, and is married to individual who is working (I)
-            is_child = person("is_child", period)
-            older_child_dependent = (
-                is_dependent & is_child & ~is_qualifying_child
-            )
-            is_married = person.family("is_married", period)
-            has_older_child_dependent = person.spm_unit.any(
-                older_child_dependent
-            )
-            is_head_or_spouse = person("is_tax_unit_head_or_spouse", period)
-            has_head_or_spouse_working = person.spm_unit.any(
-                is_head_or_spouse & is_working
-            )
-            exempted_married_person = where(
-                is_married & has_older_child_dependent,
-                has_head_or_spouse_working,
-                0,
-            )
-            # Sunset provision effects on 2030-10-01
-            p_reform = parameters(
-                period
-            ).gov.contrib.reconciliation.snap_abawd_work_requirement
-            base_conditions = (
-                is_working
-                | worked_exempted_age
-                | is_disabled
-                | exempted_parent
-                | meets_snap_general_work_requirements
-                | is_pregnant
-                | exempted_married_person
-            )
-            if p_reform.sunset_provision_in_effect:
-                return base_conditions
-            return base_conditions | is_homeless | is_veteran
-
-    def modify_parameters(parameters):
-        parameters.gov.usda.snap.work_requirements.abawd.age_threshold.dependent.update(
-            start=instant("2027-01-01"), stop=instant("2035-12-31"), value=7
-        )
-        parameters.gov.usda.snap.work_requirements.abawd.age_threshold.exempted[
-            2
-        ].threshold.update(
-            start=instant("2027-01-01"),
-            stop=instant("2035-12-31"),
-            value=65,
-        )
-        return parameters
-
-    class reform(Reform):
-        def apply(self):
-            self.update_variable(meets_snap_abawd_work_requirements)
-            self.modify_parameters(modify_parameters)
-
-    return reform
-
-
-def create_reconciled_snap_abawd_work_requirement_reform(
-    parameters, period, bypass: bool = False
-):
-    if bypass:
-        return create_reconciled_snap_abawd_work_requirement()
-
-    p = parameters.gov.contrib.reconciliation.snap_abawd_work_requirement
-
-    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_reconciled_snap_abawd_work_requirement()
-    else:
-        return None
-
-
-reconciled_snap_abawd_work_requirement = (
-    create_reconciled_snap_abawd_work_requirement_reform(
-        None, None, bypass=True
-    )
-)

policyengine_us/reforms/reconciliation/reconciled_tip_and_overtime_exempt.py

@@ -1,177 +0,0 @@
-from policyengine_us.model_api import *
-from policyengine_core.periods import period as period_
-from policyengine_core.periods import instant
-
-
-def create_reconciled_tip_and_overtime_exempt() -> Reform:
-    class tip_income_deduction(Variable):
-        value_type = float
-        entity = TaxUnit
-        label = "Tip income deduction"
-        unit = USD
-        definition_period = YEAR
-
-        def formula(tax_unit, period, parameters):
-            p = parameters(period).gov.contrib.reconciliation.tip_income_exempt
-            if p.in_effect:
-                person = tax_unit.members
-                ssn_card_type = person("ssn_card_type", period)
-                ssn_card_types = ssn_card_type.possible_values
-                citizen = ssn_card_type == ssn_card_types.CITIZEN
-                non_citizen_valid_ead = (
-                    ssn_card_type == ssn_card_types.NON_CITIZEN_VALID_EAD
-                )
-                eligible_ssn_card_type = citizen | non_citizen_valid_ead
-                head = person("is_tax_unit_head", period)
-                spouse = person("is_tax_unit_spouse", period)
-                ineligible_head_exists = tax_unit.any(
-                    head & ~eligible_ssn_card_type
-                )
-                ineligible_spouse_exists = tax_unit.any(
-                    spouse & ~eligible_ssn_card_type
-                )
-                ineligible_cardholder_present = (
-                    ineligible_head_exists | ineligible_spouse_exists
-                )
-
-                tip_income = person("tip_income", period)
-                if p.phase_out.applies:
-                    agi = tax_unit("adjusted_gross_income", period)
-                    filing_status = tax_unit("filing_status", period)
-                    cap = p.cap[filing_status]
-                    start = p.phase_out.start[filing_status]
-                    agi_excess = max_(agi - start, 0)
-                    phase_out_amount = agi_excess * p.phase_out.rate
-                    total_tip_income = tax_unit.sum(tip_income)
-                    capped_overtime_income = min_(cap, total_tip_income)
-                    phased_out_overtime_income = max_(
-                        0, capped_overtime_income - phase_out_amount
-                    )
-                    return (
-                        phased_out_overtime_income
-                        * ~ineligible_cardholder_present
-                    )
-                eligible_ssn_card_holder = eligible_ssn_card_type & (
-                    head | spouse
-                )
-                return tax_unit.sum(tip_income * eligible_ssn_card_holder)
-            return 0
-
-    class overtime_income_deduction(Variable):
-        value_type = float
-        entity = TaxUnit
-        label = "Overtime income deduction"
-        unit = USD
-        definition_period = YEAR
-
-        def formula(tax_unit, period, parameters):
-            p = parameters(
-                period
-            ).gov.contrib.reconciliation.overtime_income_exempt
-            if p.in_effect:
-                person = tax_unit.members
-                ssn_card_type = person("ssn_card_type", period)
-                ssn_card_types = ssn_card_type.possible_values
-                citizen = ssn_card_type == ssn_card_types.CITIZEN
-                non_citizen_valid_ead = (
-                    ssn_card_type == ssn_card_types.NON_CITIZEN_VALID_EAD
-                )
-                eligible_ssn_card_type = citizen | non_citizen_valid_ead
-                head = person("is_tax_unit_head", period)
-                spouse = person("is_tax_unit_spouse", period)
-                ineligible_head_exists = tax_unit.any(
-                    head & ~eligible_ssn_card_type
-                )
-                ineligible_spouse_exists = tax_unit.any(
-                    spouse & ~eligible_ssn_card_type
-                )
-                ineligible_cardholder_present = (
-                    ineligible_head_exists | ineligible_spouse_exists
-                )
-
-                overtime_income = person("fsla_overtime_premium", period)
-                if p.phase_out.applies:
-                    agi = tax_unit("adjusted_gross_income", period)
-                    filing_status = tax_unit("filing_status", period)
-                    cap = p.cap[filing_status]
-                    start = p.phase_out.start[filing_status]
-                    agi_excess = max_(agi - start, 0)
-                    phase_out_amount = agi_excess * p.phase_out.rate
-                    total_overtime_income = tax_unit.sum(overtime_income)
-                    capped_overtime_income = min_(cap, total_overtime_income)
-                    phased_out_overtime_income = max_(
-                        0, capped_overtime_income - phase_out_amount
-                    )
-                    return (
-                        phased_out_overtime_income
-                        * ~ineligible_cardholder_present
-                    )
-                eligible_ssn_card_holder = eligible_ssn_card_type & (
-                    head | spouse
-                )
-                return tax_unit.sum(overtime_income * eligible_ssn_card_holder)
-            return 0
-
-    def modify_parameters(parameters):
-        parameters.gov.irs.deductions.deductions_if_itemizing.update(
-            start=instant("2026-01-01"),
-            stop=instant("2035-12-31"),
-            value=[
-                "tip_income_deduction",
-                "overtime_income_deduction",
-                "itemized_taxable_income_deductions",
-                "qualified_business_income_deduction",
-                "wagering_losses_deduction",
-            ],
-        )
-        parameters.gov.irs.deductions.deductions_if_not_itemizing.update(
-            start=instant("2026-01-01"),
-            stop=instant("2035-12-31"),
-            value=[
-                "tip_income_deduction",
-                "overtime_income_deduction",
-                "charitable_deduction_for_non_itemizers",
-                "standard_deduction",
-                "qualified_business_income_deduction",
-            ],
-        )
-        return parameters
-
-    class reform(Reform):
-        def apply(self):
-            self.update_variable(tip_income_deduction)
-            self.update_variable(overtime_income_deduction)
-            self.modify_parameters(modify_parameters)
-
-    return reform
-
-
-def create_reconciled_tip_and_overtime_exempt_reform(
-    parameters, period, bypass: bool = False
-):
-    if bypass:
-        return create_reconciled_tip_and_overtime_exempt()
-
-    p = parameters.gov.contrib.reconciliation
-
-    reform_active = False
-    current_period = period_(period)
-
-    for i in range(5):
-        if (
-            p(current_period).tip_income_exempt.in_effect
-            or p(current_period).overtime_income_exempt.in_effect
-        ):
-            reform_active = True
-            break
-        current_period = current_period.offset(1, "year")
-
-    if reform_active:
-        return create_reconciled_tip_and_overtime_exempt()
-    else:
-        return None
-
-
-reconciled_tip_and_overtime_exempt = (
-    create_reconciled_tip_and_overtime_exempt_reform(None, None, bypass=True)
-)

policyengine_us/reforms/reconciliation/reconciliation_cdcc.py

@@ -1,78 +0,0 @@
-from policyengine_us.model_api import *
-from policyengine_core.periods import period as period_
-from policyengine_core.periods import instant
-
-
-def create_reconciliation_cdcc() -> Reform:
-    class cdcc_rate(Variable):
-        value_type = float
-        entity = TaxUnit
-        label = "CDCC credit rate"
-        unit = USD
-        definition_period = YEAR
-        reference = "https://www.law.cornell.edu/uscode/text/26/21#a_2"
-
-        def formula(tax_unit, period, parameters):
-            p = parameters(period).gov.irs.credits.cdcc
-            agi = tax_unit("adjusted_gross_income", period)
-
-            # First phase-out
-            excess_agi = max_(0, agi - p.phase_out.start)
-            increments = np.ceil(excess_agi / p.phase_out.increment)
-            percentage_reduction = increments * p.phase_out.rate
-            phased_out_rate = max_(
-                p.phase_out.min, p.phase_out.max - percentage_reduction
-            )
-
-            # Second phase-out
-            p_ref = parameters(period).gov.contrib.reconciliation.cdcc
-            filing_status = tax_unit("filing_status", period)
-            second_phase_out_start = p_ref.phase_out.second_start[
-                filing_status
-            ]
-            second_excess_agi = max_(0, agi - second_phase_out_start)
-            second_phase_out_increment = p_ref.phase_out.second_increment[
-                filing_status
-            ]
-            second_increments = np.ceil(
-                second_excess_agi / second_phase_out_increment
-            )
-            second_percentage_reduction = second_increments * p.phase_out.rate
-            return max_(
-                p_ref.phase_out.second_min,
-                phased_out_rate - second_percentage_reduction,
-            )
-
-    class reform(Reform):
-        def apply(self):
-            self.update_variable(cdcc_rate)
-
-    return reform
-
-
-def create_reconciliation_cdcc_reform(
-    parameters, period, bypass: bool = False
-):
-    if bypass:
-        return create_reconciliation_cdcc()
-
-    p = parameters.gov.contrib.reconciliation.cdcc
-
-    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_reconciliation_cdcc()
-    else:
-        return None
-
-
-reconciliation_cdcc = create_reconciliation_cdcc_reform(
-    None, None, bypass=True
-)

policyengine_us/reforms/reconciliation/reconciliation_charitable_deduction.py

@@ -1,78 +0,0 @@
-from policyengine_us.model_api import *
-from policyengine_core.periods import period as period_
-from policyengine_core.periods import instant
-import numpy as np
-
-
-def create_reconciled_charitable_deduction() -> Reform:
-    class charitable_deduction(Variable):
-        value_type = float
-        entity = TaxUnit
-        label = "Charitable deduction"
-        unit = USD
-        documentation = (
-            "Deduction from taxable income for charitable donations."
-        )
-        definition_period = YEAR
-        reference = "https://www.law.cornell.edu/uscode/text/26/170"
-
-        def formula(tax_unit, period, parameters):
-            cash_donations = add(
-                tax_unit, period, ["charitable_cash_donations"]
-            )
-            non_cash_donations = add(
-                tax_unit, period, ["charitable_non_cash_donations"]
-            )
-            positive_agi = tax_unit("positive_agi", period)
-            p = parameters(period).gov.irs.deductions.itemized.charity.ceiling
-            p_ref = parameters(
-                period
-            ).gov.contrib.reconciliation.charitable_donations
-            deduction_floor = p_ref.floor * positive_agi
-            reduced_non_cash_donations = max_(
-                non_cash_donations - deduction_floor, 0
-            )
-            capped_non_cash_donations = min_(
-                reduced_non_cash_donations, p.non_cash * positive_agi
-            )
-
-            total_cap = p.all * positive_agi
-            remaining_floor = max_(deduction_floor - non_cash_donations, 0)
-            reduced_cash_donations = max_(cash_donations - remaining_floor, 0)
-            return min_(
-                capped_non_cash_donations + reduced_cash_donations, total_cap
-            )
-
-    class reform(Reform):
-        def apply(self):
-            self.update_variable(charitable_deduction)
-
-    return reform
-
-
-def create_reconciled_charitable_deduction_reform(
-    parameters, period, bypass: bool = False
-):
-    if bypass:
-        return create_reconciled_charitable_deduction()
-
-    p = parameters.gov.contrib.reconciliation.charitable_donations
-
-    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_reconciled_charitable_deduction()
-    else:
-        return None
-
-
-reconciliation_charitable_deduction = (
-    create_reconciled_charitable_deduction_reform(None, None, bypass=True)
-)

policyengine_us/reforms/reconciliation/reconciliation_qbid_with_floor.py

@@ -1,72 +0,0 @@
-from policyengine_us.model_api import *
-from policyengine_core.periods import period as period_
-from policyengine_core.periods import instant
-
-
-def create_reconciliation_qbid_with_floor() -> Reform:
-    class qualified_business_income_deduction(Variable):
-        value_type = float
-        entity = TaxUnit
-        label = "Qualified business income deduction for tax unit"
-        unit = USD
-        definition_period = YEAR
-        reference = (
-            "https://www.law.cornell.edu/uscode/text/26/199A#b_1"
-            "https://www.irs.gov/pub/irs-prior/p535--2018.pdf"
-        )
-
-        def formula(tax_unit, period, parameters):
-            # compute sum of QBID amounts for each person in TaxUnit following
-            # logic in 2018 IRS Publication 535, Worksheet 12-A, line 16
-            person = tax_unit.members
-            qbid_amt = person("qbid_amount", period)
-            uncapped_qbid = tax_unit.sum(qbid_amt)
-            # apply taxinc cap at the TaxUnit level following logic
-            # in 2018 IRS Publication 535, Worksheet 12-A, lines 32-37
-            taxinc_less_qbid = tax_unit("taxable_income_less_qbid", period)
-            netcg_qdiv = tax_unit("adjusted_net_capital_gain", period)
-            p = parameters(period).gov.irs.deductions.qbi.max
-            taxinc_cap = p.rate * max_(0, taxinc_less_qbid - netcg_qdiv)
-            pre_floor_qbid = min_(uncapped_qbid, taxinc_cap)
-            p_ref = parameters(
-                period
-            ).gov.contrib.reconciliation.qbid.deduction_floor
-            qualified_business_income = tax_unit(
-                "qualified_business_income", period
-            )
-            floor = p_ref.amount.calc(qualified_business_income)
-            return max_(pre_floor_qbid, floor)
-
-    class reform(Reform):
-        def apply(self):
-            self.update_variable(qualified_business_income_deduction)
-
-    return reform
-
-
-def create_reconciliation_qbid_with_floor_reform(
-    parameters, period, bypass: bool = False
-):
-    if bypass:
-        return create_reconciliation_qbid_with_floor()
-
-    p = parameters.gov.contrib.reconciliation.qbid.deduction_floor
-
-    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_reconciliation_qbid_with_floor()
-    else:
-        return None
-
-
-reconciliation_qbid_with_floor = create_reconciliation_qbid_with_floor_reform(
-    None, None, bypass=True
-)

policyengine_us/reforms/salt_phase_out/__init__.py

@@ -1,3 +0,0 @@
-from .salt_phase_out_reform import (
-    create_salt_phase_out_reform,
-)

policyengine_us/reforms/salt_phase_out/salt_phase_out_reform.py

@@ -1,59 +0,0 @@
-from policyengine_us.model_api import *
-from policyengine_core.periods import period as period_
-
-
-def create_salt_phase_out() -> Reform:
-
-    class salt_cap(Variable):
-        value_type = float
-        entity = TaxUnit
-        label = "SALT cap"
-        unit = USD
-        definition_period = YEAR
-        reference = "https://www.law.cornell.edu/uscode/text/26/164"
-
-        def formula(tax_unit, period, parameters):
-            filing_status = tax_unit("filing_status", period)
-            p = parameters(
-                period
-            ).gov.irs.deductions.itemized.salt_and_real_estate
-            max_cap = p.cap[filing_status]
-            p_ref = parameters(period).gov.contrib.salt_phase_out
-            agi = tax_unit("adjusted_gross_income", period)
-            agi_excess = max_(0, agi - p_ref.threshold[filing_status])
-            phase_out = p_ref.rate * agi_excess
-            phased_out_cap = max_(0, max_cap - phase_out)
-            if p_ref.floor.applies:
-                floor = p_ref.floor.amount[filing_status]
-                return max_(phased_out_cap, floor)
-            return phased_out_cap
-
-    class reform(Reform):
-        def apply(self):
-            self.update_variable(salt_cap)
-
-    return reform
-
-
-def create_salt_phase_out_reform(parameters, period, bypass: bool = False):
-    if bypass:
-        return create_salt_phase_out()
-
-    p = parameters.gov.contrib.salt_phase_out
-
-    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_salt_phase_out()
-    else:
-        return None
-
-
-salt_phase_out_reform = create_salt_phase_out_reform(None, None, bypass=True)