policyengine-us 1.397.1__py3-none-any.whl → 1.441.3__py3-none-any.whl

policyengine_us/variables/gov/states/tx/fpp/tx_fpp_income_limit.py

@@ -0,0 +1,24 @@
+from policyengine_us.model_api import *
+
+
+class tx_fpp_income_limit(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = "Texas Family Planning Program income limit"
+    unit = USD
+    definition_period = YEAR
+    reference = (
+        "https://www.healthytexaswomen.org/healthcare-programs/family-planning-program/fpp-who-can-apply",
+        "https://www.hhs.texas.gov/sites/default/files/documents/texas-womens-health-programs-report-2024.pdf",
+    )
+    defined_for = StateCode.TX
+
+    def formula(spm_unit, period, parameters):
+        # Get the Federal Poverty Guideline for this SPM unit
+        fpg = spm_unit("spm_unit_fpg", period)
+
+        # Get FPG percentage (250% = 2.5)
+        p = parameters(period).gov.states.tx.fpp
+
+        # Return annual income limit (FPG * percentage)
+        return fpg * p.fpg_percentage

policyengine_us/variables/gov/states/tx/tanf/assistance_unit/tx_tanf_age_eligible_child.py

@@ -0,0 +1,27 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_age_eligible_child(Variable):
+    value_type = bool
+    entity = Person
+    label = "Age-eligible child for Texas TANF based on demographics"
+    definition_period = MONTH
+    reference = (
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-220-tanf",
+        "https://www.law.cornell.edu/regulations/texas/1-TAC-372-307",
+    )
+    defined_for = StateCode.TX
+
+    def formula(person, period, parameters):
+        p = parameters(period).gov.states.tx.tanf.age_threshold
+        age = person("monthly_age", period)
+        is_dependent = person("is_tax_unit_dependent", period)
+        is_full_time_student = person("is_full_time_student", period)
+
+        age_eligible = where(
+            is_full_time_student,
+            age < p.student_dependent,
+            age < p.minor_child,
+        )
+
+        return age_eligible & is_dependent

policyengine_us/variables/gov/states/tx/tanf/assistance_unit/tx_tanf_assistance_unit_size.py

@@ -0,0 +1,18 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_assistance_unit_size(Variable):
+    value_type = int
+    entity = SPMUnit
+    label = "Texas TANF assistance unit size"
+    definition_period = MONTH
+    reference = (
+        "https://www.law.cornell.edu/regulations/texas/1-Tex-Admin-Code-SS-372-104",
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-220-tanf",
+    )
+    defined_for = StateCode.TX
+
+    adds = [
+        "tx_tanf_eligible_child",
+        "tx_tanf_eligible_parent",
+    ]

policyengine_us/variables/gov/states/tx/tanf/assistance_unit/tx_tanf_categorically_eligible_person.py

@@ -0,0 +1,19 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_categorically_eligible_person(Variable):
+    value_type = bool
+    entity = Person
+    definition_period = MONTH
+    label = "Categorically eligible person for Texas TANF"
+    reference = (
+        "https://www.law.cornell.edu/regulations/texas/1-Tex-Admin-Code-SS-372-201",
+        "https://www.law.cornell.edu/regulations/texas/1-Tex-Admin-Code-SS-372-104",
+    )
+    defined_for = StateCode.TX
+
+    def formula(person, period, parameters):
+        immigration_eligible = person("is_citizen_or_legal_immigrant", period)
+        ssi = person("ssi", period)
+
+        return immigration_eligible & (ssi == 0)

policyengine_us/variables/gov/states/tx/tanf/assistance_unit/tx_tanf_eligible_child.py

@@ -0,0 +1,24 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_eligible_child(Variable):
+    value_type = bool
+    entity = Person
+    definition_period = MONTH
+    label = "Eligible child for Texas TANF (included in certified group)"
+    reference = (
+        "https://www.law.cornell.edu/regulations/texas/1-Tex-Admin-Code-SS-372-104",
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-220-tanf",
+    )
+    defined_for = StateCode.TX
+
+    def formula(person, period, parameters):
+        # Child must meet age/demographic requirements
+        age_eligible = person("tx_tanf_age_eligible_child", period)
+
+        # And meet inclusion requirements (immigration eligible, not receiving SSI)
+        inclusion_requirements = person(
+            "tx_tanf_categorically_eligible_person", period
+        )
+
+        return age_eligible & inclusion_requirements

policyengine_us/variables/gov/states/tx/tanf/assistance_unit/tx_tanf_eligible_parent.py

@@ -0,0 +1,24 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_eligible_parent(Variable):
+    value_type = bool
+    entity = Person
+    definition_period = MONTH
+    label = "Eligible parent for Texas TANF (included in certified group)"
+    reference = (
+        "https://www.law.cornell.edu/regulations/texas/1-Tex-Admin-Code-SS-372-104",
+        "https://www.law.cornell.edu/regulations/texas/1-Tex-Admin-Code-SS-372-102",
+    )
+    defined_for = StateCode.TX
+
+    def formula(person, period, parameters):
+        # Per § 372.104, parents living in household must be included in certified group
+        is_parent = person("is_tax_unit_head_or_spouse", period)
+
+        # Must meet inclusion requirements
+        inclusion_requirements = person(
+            "tx_tanf_categorically_eligible_person", period
+        )
+
+        return is_parent & inclusion_requirements

policyengine_us/variables/gov/states/tx/tanf/eligibility/tx_tanf_budgetary_needs.py

@@ -0,0 +1,57 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_budgetary_needs(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = "Texas TANF budgetary needs amount"
+    unit = USD
+    definition_period = MONTH
+    reference = (
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/c-110-tanf",
+        "https://www.law.cornell.edu/regulations/texas/1-Tex-Admin-Code-SS-372-2",
+    )
+    defined_for = StateCode.TX
+
+    def formula(spm_unit, period, parameters):
+        # Budgetary needs varies by caretaker type and household size
+        size = spm_unit("tx_tanf_assistance_unit_size", period)
+        caretaker_type = spm_unit("tx_tanf_caretaker_type", period)
+        p = parameters(period).gov.states.tx.tanf.needs_standard
+
+        # Determine caretaker type
+        non_caretaker = (
+            caretaker_type == caretaker_type.possible_values.NON_CARETAKER
+        )
+        caretaker_without_second = (
+            caretaker_type
+            == caretaker_type.possible_values.CARETAKER_WITHOUT_SECOND_PARENT
+        )
+        caretaker_with_second = (
+            caretaker_type
+            == caretaker_type.possible_values.CARETAKER_WITH_SECOND_PARENT
+        )
+
+        # For sizes <= 15, use table; for sizes > 15, use size 15 + increment
+        size_capped = min_(size, 15)
+        additional_people = max_(size - 15, 0)
+        additional_amount = (
+            additional_people * p.budgetary_needs.additional_person
+        )
+
+        # Get base amount for size (capped at 15)
+        base_amount = select(
+            [non_caretaker, caretaker_without_second, caretaker_with_second],
+            [
+                p.budgetary_needs.non_caretaker.calc(size_capped),
+                p.budgetary_needs.caretaker_without_second_parent.calc(
+                    size_capped
+                ),
+                p.budgetary_needs.caretaker_with_second_parent.calc(
+                    size_capped
+                ),
+            ],
+            default=0,
+        )
+
+        return base_amount + additional_amount

policyengine_us/variables/gov/states/tx/tanf/eligibility/tx_tanf_budgetary_needs_test.py

@@ -0,0 +1,21 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_budgetary_needs_test(Variable):
+    value_type = bool
+    entity = SPMUnit
+    label = "Meets Texas TANF budgetary needs test"
+    definition_period = MONTH
+    reference = "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-1340-income-limits"
+    defined_for = StateCode.TX
+
+    def formula(spm_unit, period, parameters):
+        # Budgetary needs test applies to applicants (not receiving TANF in last 4 months)
+        # Household passes if budgetary needs > income
+
+        budgetary_needs = spm_unit("tx_tanf_budgetary_needs", period)
+        income_for_test = spm_unit(
+            "tx_tanf_income_for_budgetary_needs_test", period
+        )
+
+        return budgetary_needs > income_for_test

policyengine_us/variables/gov/states/tx/tanf/eligibility/tx_tanf_caretaker_type.py

@@ -0,0 +1,50 @@
+from policyengine_us.model_api import *
+
+
+class TxTanfCaretakerType(Enum):
+    NON_CARETAKER = "Non-caretaker"
+    CARETAKER_WITHOUT_SECOND_PARENT = "Caretaker without second parent"
+    CARETAKER_WITH_SECOND_PARENT = "Caretaker with second parent"
+
+
+class tx_tanf_caretaker_type(Variable):
+    value_type = Enum
+    possible_values = TxTanfCaretakerType
+    default_value = TxTanfCaretakerType.NON_CARETAKER
+    entity = SPMUnit
+    label = "Texas TANF caretaker type"
+    definition_period = MONTH
+    reference = (
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/c-110-tanf"
+    )
+    defined_for = StateCode.TX
+
+    def formula(spm_unit, period, parameters):
+        # Caretaker type determines payment standard amount
+        # Based on number of parents included in certified group
+
+        person = spm_unit.members
+        eligible_parent = person("tx_tanf_eligible_parent", period)
+        eligible_child = person("tx_tanf_eligible_child", period)
+
+        # Count payment-eligible parents and children
+        parent_count = spm_unit.sum(eligible_parent)
+        has_eligible_child = spm_unit.any(eligible_child)
+
+        # Determine caretaker type
+        # Non-caretaker: No parents in certified group (child-only cases)
+        # Caretaker without second: One parent in certified group
+        # Caretaker with second: Two or more parents in certified group
+        non_caretaker = has_eligible_child & (parent_count == 0)
+        caretaker_without_second = has_eligible_child & (parent_count == 1)
+        caretaker_with_second = has_eligible_child & (parent_count >= 2)
+
+        return select(
+            [non_caretaker, caretaker_without_second, caretaker_with_second],
+            [
+                TxTanfCaretakerType.NON_CARETAKER,
+                TxTanfCaretakerType.CARETAKER_WITHOUT_SECOND_PARENT,
+                TxTanfCaretakerType.CARETAKER_WITH_SECOND_PARENT,
+            ],
+            default=TxTanfCaretakerType.NON_CARETAKER,
+        )

policyengine_us/variables/gov/states/tx/tanf/eligibility/tx_tanf_eligible.py

@@ -0,0 +1,29 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_eligible(Variable):
+    value_type = bool
+    entity = SPMUnit
+    label = "Eligible for Texas Temporary Assistance for Needy Families (TANF)"
+    definition_period = MONTH
+    reference = (
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-220-tanf",
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-2420-eligibility-requirements",
+        "https://www.law.cornell.edu/regulations/texas/title-1/part-15/chapter-372/subchapter-B",
+    )
+    defined_for = StateCode.TX
+
+    def formula(spm_unit, period, parameters):
+        person = spm_unit.members
+
+        # Must have at least one eligible child in certified group
+        # (eligible child already includes immigration and SSI checks)
+        has_eligible_child = spm_unit.any(
+            person("tx_tanf_eligible_child", period)
+        )
+
+        # Financial eligibility
+        income_eligible = spm_unit("tx_tanf_income_eligible", period)
+        resources_eligible = spm_unit("tx_tanf_resources_eligible", period)
+
+        return has_eligible_child & income_eligible & resources_eligible

policyengine_us/variables/gov/states/tx/tanf/eligibility/tx_tanf_income_eligible.py

@@ -0,0 +1,40 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_income_eligible(Variable):
+    value_type = bool
+    entity = SPMUnit
+    label = "Meets Texas TANF income test"
+    definition_period = MONTH
+    reference = "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-1340-income-limits"
+    defined_for = StateCode.TX
+
+    def formula(spm_unit, period, parameters):
+        # Texas TANF has two income eligibility tests per § 372.408:
+        #
+        # Budgetary needs test (§ 372.408 (a)(1)):
+        #   - Uses income WITHOUT earned income disregards (1/3 or 90%)
+        #   - Income < budgetary needs amount (100% of needs)
+        #   - Applies to: NEW applicants only
+        #
+        # Recognizable needs test (§ 372.408 (a)(2)):
+        #   - Uses income WITH earned income disregards (1/3 or 90%)
+        #   - Income < recognizable needs amount (25% of budgetary needs)
+        #   - Applies to: EVERYONE (applicants AND continuing recipients)
+        #
+        # Test requirements by enrollment status:
+        # - New applicants: Must pass budgetary test AND recognizable test
+        # - Continuing recipients: Must pass recognizable test only
+
+        is_enrolled = spm_unit("is_tanf_enrolled", period)
+        passes_budgetary = spm_unit("tx_tanf_budgetary_needs_test", period)
+        passes_recognizable = spm_unit(
+            "tx_tanf_recognizable_needs_test", period
+        )
+
+        # Apply the appropriate test(s) based on enrollment status
+        return where(
+            is_enrolled,
+            passes_recognizable,  # Continuing: recognizable test only
+            passes_budgetary & passes_recognizable,  # Applicants: BOTH tests
+        )

policyengine_us/variables/gov/states/tx/tanf/eligibility/tx_tanf_recognizable_needs_test.py

@@ -0,0 +1,23 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_recognizable_needs_test(Variable):
+    value_type = bool
+    entity = SPMUnit
+    label = "Meets Texas TANF recognizable needs test"
+    definition_period = MONTH
+    reference = "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-1340-income-limits"
+    defined_for = StateCode.TX
+
+    def formula(spm_unit, period, parameters):
+        # Recognizable needs test applies to continuing recipients
+        # Household passes if recognizable needs > countable income
+
+        budgetary_needs = spm_unit("tx_tanf_budgetary_needs", period)
+        countable_income = spm_unit("tx_tanf_countable_income", period)
+        p = parameters(period).gov.states.tx.tanf.needs_standard
+
+        # Recognizable needs is 25% of budgetary needs
+        recognizable_needs = budgetary_needs * p.recognizable_needs.rate
+
+        return countable_income < recognizable_needs

policyengine_us/variables/gov/states/tx/tanf/eligibility/tx_tanf_resources_eligible.py

@@ -0,0 +1,19 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_resources_eligible(Variable):
+    value_type = bool
+    entity = SPMUnit
+    label = "Meets Texas TANF resource test"
+    definition_period = MONTH
+    reference = (
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-1220-limits",
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-2420-eligibility-requirements",
+    )
+    defined_for = StateCode.TX
+
+    def formula(spm_unit, period, parameters):
+        countable_resources = spm_unit("tx_tanf_countable_resources", period)
+        p = parameters(period).gov.states.tx.tanf.resources
+
+        return countable_resources <= p.resource_limit

policyengine_us/variables/gov/states/tx/tanf/income/deductions/tx_tanf_child_support_deduction.py

@@ -0,0 +1,21 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_child_support_deduction(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = "Texas TANF child support deduction"
+    unit = USD
+    definition_period = MONTH
+    reference = (
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-1420-types-deductions#a-1422-75-disregard-deduction",
+        "https://www.law.cornell.edu/regulations/texas/1-Tex-Admin-Code-SS-372-404",
+    )
+    defined_for = StateCode.TX
+
+    def formula(spm_unit, period, parameters):
+        # Up to $75/month in child support can be deducted per household
+        p = parameters(period).gov.states.tx.tanf.income
+        child_support = spm_unit("child_support_received", period)
+
+        return min_(child_support, p.deductions.child_support)

policyengine_us/variables/gov/states/tx/tanf/income/deductions/tx_tanf_dependent_care_deduction.py

@@ -0,0 +1,39 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_dependent_care_deduction(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = "Texas TANF dependent care deduction"
+    unit = USD
+    definition_period = MONTH
+    reference = (
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-1420-types-deductions",
+        "https://www.law.cornell.edu/regulations/texas/1-Tex-Admin-Code-SS-372-409",
+    )
+    defined_for = StateCode.TX
+
+    def formula(spm_unit, period, parameters):
+        # Actual cost of dependent child care, capped at maximum by age
+        # Per § 372.409 (a)(3): up to $200/month for children under 2, $175/month for children 2+
+
+        # Get actual childcare expenses
+        childcare_expenses = spm_unit("childcare_expenses", period)
+
+        # Calculate maximum deduction for dependents (children or incapacitated adults)
+        person = spm_unit.members
+        is_dependent = person("is_tax_unit_dependent", period)
+        is_incapacitated = person("is_incapable_of_self_care", period)
+        age = person("monthly_age", period)
+
+        # Eligible for deduction: dependent child OR incapacitated adult
+        eligible_for_deduction = is_dependent | is_incapacitated
+
+        p = parameters(period).gov.states.tx.tanf.income
+        max_per_person = where(
+            eligible_for_deduction, p.deductions.dependent_care.calc(age), 0
+        )
+        total_max_deduction = spm_unit.sum(max_per_person)
+
+        # Deduction is the lesser of actual expenses or maximum
+        return min_(childcare_expenses, total_max_deduction)

policyengine_us/variables/gov/states/tx/tanf/income/earned/tx_tanf_countable_earned_income.py

@@ -0,0 +1,28 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_countable_earned_income(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = "Texas TANF countable earned income"
+    unit = USD
+    definition_period = MONTH
+    reference = (
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-1340-income-limits",
+        "https://www.law.cornell.edu/regulations/texas/1-TAC-372-605",
+    )
+    defined_for = StateCode.TX
+
+    def formula(spm_unit, period, parameters):
+        # Sum person-level earned income after work expense and disregards
+        earned_after_disregards = spm_unit(
+            "tx_tanf_earned_income_after_disregard_person", period
+        )
+
+        # Apply dependent care deduction (per § 372.409 (a)(3))
+        dependent_care_deduction = spm_unit(
+            "tx_tanf_dependent_care_deduction", period
+        )
+
+        # Countable earned income after all deductions
+        return max_(earned_after_disregards - dependent_care_deduction, 0)

policyengine_us/variables/gov/states/tx/tanf/income/earned/tx_tanf_earned_income_after_disregard_person.py

@@ -0,0 +1,52 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_earned_income_after_disregard_person(Variable):
+    value_type = float
+    entity = Person
+    label = "Texas TANF earned income after disregards (person)"
+    unit = USD
+    definition_period = MONTH
+    reference = (
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-1420-types-deductions",
+        "https://www.law.cornell.edu/regulations/texas/1-Tex-Admin-Code-SS-372-409",
+    )
+    defined_for = StateCode.TX
+
+    def formula(person, period, parameters):
+        # Get gross earned income
+        gross_earned = person("tx_tanf_gross_earned_income", period)
+        p = parameters(period).gov.states.tx.tanf.income
+
+        # Step 1: Subtract work expense deduction ($120, not to exceed earnings)
+        work_expense = min_(p.deductions.work_expense, gross_earned)
+        after_work_expense = max_(gross_earned - work_expense, 0)
+
+        # Step 2: Apply appropriate earned income disregard
+        # Check if household is enrolled in TANF
+        spm_unit = person.spm_unit
+        is_enrolled = spm_unit("is_tanf_enrolled", period)
+
+        # For applicants (not enrolled): 1/3 disregard
+        applicant_disregard = (
+            after_work_expense * p.disregards.applicant_fraction
+        )
+
+        # For continuing recipients (enrolled): 90% disregard (capped at $1,400)
+        # Note: This disregard is limited to 4 months per 12-month period (not yet implemented)
+        potential_recipient_disregard = (
+            after_work_expense * p.disregards.continuing_recipient_rate
+        )
+        actual_recipient_disregard = min_(
+            potential_recipient_disregard,
+            p.disregards.continuing_recipient_cap,
+        )
+
+        # Return appropriate value based on enrollment status
+        disregard = where(
+            is_enrolled,
+            actual_recipient_disregard,
+            applicant_disregard,
+        )
+
+        return max_(after_work_expense - disregard, 0)

policyengine_us/variables/gov/states/tx/tanf/income/earned/tx_tanf_gross_earned_income.py

@@ -0,0 +1,16 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_gross_earned_income(Variable):
+    value_type = float
+    entity = Person
+    label = "Texas TANF gross earned income"
+    unit = USD
+    definition_period = MONTH
+    reference = (
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-1340-income-limits",
+        "https://www.law.cornell.edu/regulations/texas/1-TAC-372-601",
+    )
+    defined_for = StateCode.TX
+
+    adds = "gov.states.tx.tanf.income.sources.earned"

policyengine_us/variables/gov/states/tx/tanf/income/tx_tanf_countable_income.py

@@ -0,0 +1,19 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_countable_income(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = "Texas TANF countable income"
+    unit = USD
+    definition_period = MONTH
+    reference = (
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-1340-income-limits",
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-1350-calculating-household-income",
+    )
+    defined_for = StateCode.TX
+
+    adds = [
+        "tx_tanf_countable_earned_income",
+        "tx_tanf_countable_unearned_income",
+    ]

policyengine_us/variables/gov/states/tx/tanf/income/tx_tanf_income_for_budgetary_needs_test.py

@@ -0,0 +1,47 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_income_for_budgetary_needs_test(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = "Texas TANF income for budgetary needs test"
+    unit = USD
+    definition_period = MONTH
+    reference = (
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-1340-income-limits",
+        "https://www.law.cornell.edu/regulations/texas/1-Tex-Admin-Code-SS-372-408",
+    )
+    defined_for = StateCode.TX
+
+    def formula(spm_unit, period, parameters):
+        # Budgetary needs test uses income WITHOUT earned income disregards (1/3 or 90%)
+        # Deductions applied:
+        # 1. Work expense ($120)
+        # 2. Dependent care costs
+        # 3. Child support deduction (from unearned income)
+
+        person = spm_unit.members
+        p = parameters(period).gov.states.tx.tanf.income
+
+        # Earned income after work expense only (no 1/3 or 90% disregard)
+        gross_earned = person("tx_tanf_gross_earned_income", period)
+        work_expense = min_(p.deductions.work_expense, gross_earned)
+        earned_after_work_expense = max_(gross_earned - work_expense, 0)
+
+        # Sum across household members
+        total_earned_after_work_expense = spm_unit.sum(
+            earned_after_work_expense
+        )
+
+        # Apply dependent care deduction
+        dependent_care_deduction = spm_unit(
+            "tx_tanf_dependent_care_deduction", period
+        )
+        earned_after_deductions = max_(
+            total_earned_after_work_expense - dependent_care_deduction, 0
+        )
+
+        # Add unearned income (already has child support deduction applied)
+        unearned_income = spm_unit("tx_tanf_countable_unearned_income", period)
+
+        return earned_after_deductions + unearned_income

policyengine_us/variables/gov/states/tx/tanf/income/unearned/tx_tanf_countable_unearned_income.py

@@ -0,0 +1,27 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_countable_unearned_income(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = "Texas TANF countable unearned income"
+    unit = USD
+    definition_period = MONTH
+    reference = (
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-1340-income-limits",
+        "https://www.law.cornell.edu/regulations/texas/1-TAC-372-605",
+    )
+    defined_for = StateCode.TX
+
+    def formula(spm_unit, period, parameters):
+        # Sum person-level gross unearned income
+        gross_unearned = add(
+            spm_unit, period, ["tx_tanf_gross_unearned_income"]
+        )
+
+        # Apply household-level child support deduction (up to $75/month per household)
+        child_support_deduction = spm_unit(
+            "tx_tanf_child_support_deduction", period
+        )
+
+        return max_(gross_unearned - child_support_deduction, 0)

policyengine_us/variables/gov/states/tx/tanf/income/unearned/tx_tanf_gross_unearned_income.py

@@ -0,0 +1,16 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_gross_unearned_income(Variable):
+    value_type = float
+    entity = Person
+    label = "Texas TANF gross unearned income"
+    unit = USD
+    definition_period = MONTH
+    reference = (
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-1340-income-limits",
+        "https://www.law.cornell.edu/regulations/texas/1-TAC-372-601",
+    )
+    defined_for = StateCode.TX
+
+    adds = "gov.states.tx.tanf.income.sources.unearned"