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

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"

policyengine_us/variables/gov/states/tx/tanf/ottanf/tx_ottanf.py

@@ -0,0 +1,17 @@
+from policyengine_us.model_api import *
+
+
+class tx_ottanf(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = "Texas One-Time TANF (OTTANF) payment"
+    unit = USD
+    definition_period = MONTH
+    reference = "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-2410-general-policy"
+    defined_for = "tx_ottanf_eligible"
+
+    def formula(spm_unit, period, parameters):
+        p = parameters(period).gov.states.tx.tanf.ottanf
+
+        # One-time payment of $1,000 divided by 12 for monthly equivalent
+        return p.payment_amount / MONTHS_IN_YEAR

policyengine_us/variables/gov/states/tx/tanf/ottanf/tx_ottanf_crisis_criteria.py

@@ -0,0 +1,21 @@
+from policyengine_us.model_api import *
+
+
+class tx_ottanf_crisis_criteria(Variable):
+    value_type = bool
+    entity = SPMUnit
+    definition_period = MONTH
+    label = "Meets Texas OTTANF crisis criteria"
+    reference = (
+        "https://www.law.cornell.edu/regulations/texas/1-Tex-Admin-Code-SS-372-802",
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-2420-eligibility-requirements",
+    )
+    defined_for = StateCode.TX
+
+    # Crisis criteria per § 372.802 (b):
+    # 1. Lost employment in past 2 months (not voluntary quit)
+    # 2. Single parent: child lost financial support in last 12 months + parent has recent employment
+    # 3. Recent graduate: unemployed/underemployed, not in school, has degree, previously received TANF
+    # 4. Currently employed facing crisis: potential loss of transportation/shelter or medical emergency
+    #
+    # This variable has no formula - user must input whether household meets crisis criteria

policyengine_us/variables/gov/states/tx/tanf/ottanf/tx_ottanf_eligible.py

@@ -0,0 +1,36 @@
+from policyengine_us.model_api import *
+
+
+class tx_ottanf_eligible(Variable):
+    value_type = bool
+    entity = SPMUnit
+    label = "Eligible for Texas One-Time TANF (OTTANF)"
+    definition_period = MONTH
+    reference = (
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-2421-eligibility-criteria",
+        "https://www.law.cornell.edu/regulations/texas/1-Tex-Admin-Code-SS-372-801",
+    )
+    defined_for = StateCode.TX
+
+    def formula(spm_unit, period, parameters):
+        # OTTANF eligibility per A-2421:
+        # 1. Must meet all regular TANF eligibility requirements
+        #    (child, income, resources, immigration)
+        # 2. Must be eligible for TANF grant of $10 or more
+        # 3. Must meet one of four crisis criteria
+
+        # Regular TANF eligibility (child, income, resources, immigration)
+        regular_tanf_eligible = spm_unit("tx_tanf_eligible", period)
+
+        # Must be eligible for at least $10 grant
+        payment_standard = spm_unit("tx_tanf_payment_standard", period)
+        countable_income = spm_unit("tx_tanf_countable_income", period)
+        potential_grant = payment_standard - countable_income
+
+        p = parameters(period).gov.states.tx.tanf
+        eligible_for_min_grant = potential_grant >= p.minimum_grant
+
+        # Crisis criteria (user input)
+        crisis = spm_unit("tx_ottanf_crisis_criteria", period)
+
+        return regular_tanf_eligible & eligible_for_min_grant & crisis

policyengine_us/variables/gov/states/tx/tanf/resources/tx_tanf_countable_resources.py

@@ -0,0 +1,31 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_countable_resources(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = "Texas TANF countable resources"
+    unit = USD
+    definition_period = MONTH
+    reference = (
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-1210-general-policy",
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-1220-limits",
+    )
+    defined_for = StateCode.TX
+
+    def formula(spm_unit, period, parameters):
+        # Countable resources = liquid resources + excess vehicle value
+        # Household must have countable resources ≤ $1,000 to be eligible
+
+        # Liquid resources (cash, checking, savings) - stocks use period.this_year
+        cash_assets = spm_unit("spm_unit_cash_assets", period.this_year)
+
+        # Vehicle resources (apply vehicle exemption: one automobile up to $4,650)
+        vehicle_value = spm_unit.household(
+            "household_vehicles_value", period.this_year
+        )
+        p = parameters(period).gov.states.tx.tanf.resources
+        countable_vehicle_value = max_(vehicle_value - p.vehicle_exemption, 0)
+
+        # Total countable resources (no period conversion - resources are stocks)
+        return cash_assets + countable_vehicle_value

policyengine_us/variables/gov/states/tx/tanf/tx_regular_tanf.py

@@ -0,0 +1,27 @@
+from policyengine_us.model_api import *
+
+
+class tx_regular_tanf(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = (
+        "Texas Temporary Assistance for Needy Families (TANF) regular benefit"
+    )
+    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/c-110-tanf",
+    )
+    defined_for = "tx_tanf_eligible"
+
+    def formula(spm_unit, period, parameters):
+        payment_standard = spm_unit("tx_tanf_payment_standard", period)
+        countable_income = spm_unit("tx_tanf_countable_income", period)
+        p = parameters(period).gov.states.tx.tanf
+
+        # Calculate benefit as payment standard minus countable income
+        calculated_benefit = max_(payment_standard - countable_income, 0)
+
+        # Apply minimum grant rule
+        return max_(calculated_benefit, p.minimum_grant)

policyengine_us/variables/gov/states/tx/tanf/tx_tanf.py

@@ -0,0 +1,25 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = "Texas Temporary Assistance for Needy Families (TANF)"
+    unit = USD
+    definition_period = MONTH
+    reference = (
+        "https://www.hhs.texas.gov/handbooks/texas-works-handbook/a-2410-general-policy",
+    )
+    defined_for = StateCode.TX
+
+    def formula(spm_unit, period, parameters):
+        # Compare monthly TANF benefit with monthly equivalent of OTTANF
+        # Return whichever is higher for the household
+
+        # Regular TANF: monthly benefit
+        regular_tanf = spm_unit("tx_regular_tanf", period)
+
+        # OTTANF: one-time payment divided by 12 for monthly equivalent
+        ottanf = spm_unit("tx_ottanf", period)
+
+        return max_(regular_tanf, ottanf)

policyengine_us/variables/gov/states/tx/tanf/tx_tanf_payment_standard.py

@@ -0,0 +1,51 @@
+from policyengine_us.model_api import *
+
+
+class tx_tanf_payment_standard(Variable):
+    value_type = float
+    entity = SPMUnit
+    label = "Texas TANF payment standard"
+    unit = USD
+    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):
+        # Payment standard (maximum benefit amount) varies by household size and caretaker type
+
+        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.payment_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.additional_person
+
+        # Get base amount for size (capped at 15)
+        base_amount = select(
+            [non_caretaker, caretaker_without_second, caretaker_with_second],
+            [
+                p.non_caretaker.calc(size_capped),
+                p.caretaker_without_second_parent.calc(size_capped),
+                p.caretaker_with_second_parent.calc(size_capped),
+            ],
+            default=0,
+        )
+
+        return base_amount + additional_amount

policyengine_us/variables/gov/states/tx/twc/ccs/copay/tx_ccs_copay.py

@@ -0,0 +1,40 @@
+from policyengine_us.model_api import *
+
+
+class tx_ccs_copay(Variable):
+    value_type = float
+    entity = SPMUnit
+    unit = USD
+    label = "Texas Child Care Services (CCS) copayment"
+    definition_period = MONTH
+    reference = "https://wspanhandle.com/child-care/for-parents/"
+    defined_for = "tx_ccs_eligible"
+
+    def formula(spm_unit, period, parameters):
+        p = parameters(period).gov.states.tx.twc.ccs.copay
+
+        # Get household income and SMI ratio
+        income = spm_unit("tx_ccs_countable_income", period)
+        smi = spm_unit("hhs_smi", period)
+        income_to_smi_ratio = income / smi
+
+        # Count eligible children in care
+        eligible_children = spm_unit.sum(
+            spm_unit.members("tx_ccs_eligible_child", period)
+        )
+
+        # Calculate copayment rates based on income bracket
+        # Use Panhandle Region's values
+        first_child_rate = p.rate.first_child.calc(income_to_smi_ratio)
+        additional_child_rate = p.rate.additional_child
+
+        # Calculate copayments as percentage of income
+        first_child_copay = first_child_rate * income
+        additional_children = max_(eligible_children - 1, 0)
+        additional_copay = additional_child_rate * income * additional_children
+
+        # Total copayment, capped at maximum rate
+        total_copay = first_child_copay + additional_copay
+        max_copay = p.rate.maximum * income
+
+        return min_(total_copay, max_copay)

policyengine_us/variables/gov/states/tx/twc/ccs/eligibility/tx_ccs_asset_eligible.py

@@ -0,0 +1,16 @@
+from policyengine_us.model_api import *
+
+
+class tx_ccs_asset_eligible(Variable):
+    value_type = bool
+    entity = SPMUnit
+    label = "Texas CCS asset eligible"
+    definition_period = MONTH
+    reference = "https://www.law.cornell.edu/regulations/texas/40-Tex-Admin-Code-SS-809-41"
+    defined_for = StateCode.TX
+
+    def formula(spm_unit, period, parameters):
+        p = parameters(period).gov.states.tx.twc.ccs
+        assets = spm_unit("spm_unit_assets", period.this_year)
+        asset_limit = p.assets.limit
+        return assets <= asset_limit

policyengine_us/variables/gov/states/tx/twc/ccs/eligibility/tx_ccs_eligible.py

@@ -0,0 +1,28 @@
+from policyengine_us.model_api import *
+
+
+class tx_ccs_eligible(Variable):
+    value_type = bool
+    entity = SPMUnit
+    label = "Texas CCS eligible"
+    definition_period = MONTH
+    reference = "https://www.law.cornell.edu/regulations/texas/40-Tex-Admin-Code-SS-809-41"
+    defined_for = StateCode.TX
+
+    def formula(spm_unit, period, parameters):
+        # Check all eligibility criteria
+        income_eligible = spm_unit("tx_ccs_income_eligible", period)
+        asset_eligible = spm_unit("tx_ccs_asset_eligible", period)
+        work_eligible = spm_unit("tx_ccs_work_requirement_eligible", period)
+
+        # Check if at least one child is age-eligible
+        person = spm_unit.members
+        age_eligible = person("tx_ccs_eligible_child", period)
+        has_eligible_child = spm_unit.any(age_eligible)
+
+        return (
+            income_eligible
+            & asset_eligible
+            & work_eligible
+            & has_eligible_child
+        )