diff --git a/changelog_entry.yaml b/changelog_entry.yaml index e69de29bb2d..d3170193321 100644 --- a/changelog_entry.yaml +++ b/changelog_entry.yaml @@ -0,0 +1,4 @@ +- bump: minor + changes: + added: + - Adds Utah Temporary Assistance for Needy Families (TANF) program. diff --git a/policyengine_us/parameters/gov/states/ut/dwf/fep/income/deductions/earned_income_disregard/rate.yaml b/policyengine_us/parameters/gov/states/ut/dwf/fep/income/deductions/earned_income_disregard/rate.yaml new file mode 100644 index 00000000000..030267cda36 --- /dev/null +++ b/policyengine_us/parameters/gov/states/ut/dwf/fep/income/deductions/earned_income_disregard/rate.yaml @@ -0,0 +1,12 @@ +description: Utah disregards this share of remaining earned income after the work expense allowance under the Family Employment Program. + +metadata: + unit: /1 + period: month + label: Utah FEP earned income disregard rate + reference: + - title: Utah Admin. Code R986-200-239(2)(b) + href: https://www.law.cornell.edu/regulations/utah/Utah-Admin-Code-R986-200-239 + +values: + 2022-10-01: 0.5 diff --git a/policyengine_us/parameters/gov/states/ut/dwf/fep/income/deductions/work_expense_allowance/amount.yaml b/policyengine_us/parameters/gov/states/ut/dwf/fep/income/deductions/work_expense_allowance/amount.yaml new file mode 100644 index 00000000000..867458ae12e --- /dev/null +++ b/policyengine_us/parameters/gov/states/ut/dwf/fep/income/deductions/work_expense_allowance/amount.yaml @@ -0,0 +1,12 @@ +description: Utah deducts this work expense allowance per employed person from earned income under the Family Employment Program. + +metadata: + unit: currency-USD + period: month + label: Utah FEP work expense allowance amount + reference: + - title: Utah Admin. Code R986-200-239(2)(a) + href: https://www.law.cornell.edu/regulations/utah/Utah-Admin-Code-R986-200-239 + +values: + 2022-10-01: 100 diff --git a/policyengine_us/parameters/gov/states/ut/dwf/fep/income/gross_income_limit/rate.yaml b/policyengine_us/parameters/gov/states/ut/dwf/fep/income/gross_income_limit/rate.yaml new file mode 100644 index 00000000000..30d82e55018 --- /dev/null +++ b/policyengine_us/parameters/gov/states/ut/dwf/fep/income/gross_income_limit/rate.yaml @@ -0,0 +1,12 @@ +description: Utah limits gross income to this share of the Standard Needs Budget under the Family Employment Program. + +metadata: + unit: /1 + period: month + label: Utah FEP gross income limit rate + reference: + - title: Utah Admin. Code R986-200-239(1) + href: https://www.law.cornell.edu/regulations/utah/Utah-Admin-Code-R986-200-239 + +values: + 2022-10-01: 1.85 diff --git a/policyengine_us/parameters/gov/states/ut/dwf/fep/payment_standard/amount.yaml b/policyengine_us/parameters/gov/states/ut/dwf/fep/payment_standard/amount.yaml new file mode 100644 index 00000000000..5620880b9e3 --- /dev/null +++ b/policyengine_us/parameters/gov/states/ut/dwf/fep/payment_standard/amount.yaml @@ -0,0 +1,52 @@ +description: Utah provides up to this maximum benefit amount under the Family Employment Program, based on household size. + +metadata: + unit: currency-USD + period: month + breakdown: + - range(1, 20) + label: Utah FEP maximum benefit amount + reference: + - title: Utah Admin. Code R986-200-239 + href: https://www.law.cornell.edu/regulations/utah/Utah-Admin-Code-R986-200-239 + - title: Utah DWS Table 1 - Financial Monthly Income Limits and Assistance Amounts + href: https://jobs.utah.gov/Infosource/eligibilitymanual/Tables,_Appendicies,_and_Charts/Tables,_Appendicies,_and_Charts/Table_1_-_Financial_Monthly_Income_Limits_and_Assistance_Amounts.htm + +1: + 2022-10-01: 383 +2: + 2022-10-01: 531 +3: + 2022-10-01: 662 +4: + 2022-10-01: 775 +5: + 2022-10-01: 882 +6: + 2022-10-01: 972 +7: + 2022-10-01: 1_017 +8: + 2022-10-01: 1_065 +9: + 2022-10-01: 1_116 +10: + 2022-10-01: 1_162 +11: + 2022-10-01: 1_210 +12: + 2022-10-01: 1_258 +13: + 2022-10-01: 1_306 +14: + 2022-10-01: 1_354 +15: + 2022-10-01: 1_403 +16: + 2022-10-01: 1_450 +17: + 2022-10-01: 1_498 +18: + 2022-10-01: 1_546 +19: + 2022-10-01: 1_594 diff --git a/policyengine_us/parameters/gov/states/ut/dwf/fep/payment_standard/max_unit_size.yaml b/policyengine_us/parameters/gov/states/ut/dwf/fep/payment_standard/max_unit_size.yaml new file mode 100644 index 00000000000..301903ecb4a --- /dev/null +++ b/policyengine_us/parameters/gov/states/ut/dwf/fep/payment_standard/max_unit_size.yaml @@ -0,0 +1,12 @@ +description: Utah defines the Family Employment Program payment schedule up to this maximum household size. + +metadata: + unit: person + period: month + label: Utah FEP maximum unit size for payment schedule + reference: + - title: Utah DWS Table 1 - Financial Monthly Income Limits and Assistance Amounts + href: https://jobs.utah.gov/Infosource/eligibilitymanual/Tables,_Appendicies,_and_Charts/Tables,_Appendicies,_and_Charts/Table_1_-_Financial_Monthly_Income_Limits_and_Assistance_Amounts.htm + +values: + 2022-10-01: 19 diff --git a/policyengine_us/parameters/gov/states/ut/dwf/fep/resources/limit/amount.yaml b/policyengine_us/parameters/gov/states/ut/dwf/fep/resources/limit/amount.yaml new file mode 100644 index 00000000000..e4bc343296c --- /dev/null +++ b/policyengine_us/parameters/gov/states/ut/dwf/fep/resources/limit/amount.yaml @@ -0,0 +1,12 @@ +description: Utah limits the Family Employment Program to households with countable resources at or below this amount. + +metadata: + unit: currency-USD + period: month + label: Utah FEP resource limit amount + reference: + - title: Utah Admin. Code R986-200-230(5) + href: https://www.law.cornell.edu/regulations/utah/Utah-Admin-Code-R986-200-230 + +values: + 2022-10-01: 2_000 diff --git a/policyengine_us/parameters/gov/states/ut/dwf/fep/standard_needs_budget/amount.yaml b/policyengine_us/parameters/gov/states/ut/dwf/fep/standard_needs_budget/amount.yaml new file mode 100644 index 00000000000..714446e8f13 --- /dev/null +++ b/policyengine_us/parameters/gov/states/ut/dwf/fep/standard_needs_budget/amount.yaml @@ -0,0 +1,52 @@ +description: Utah Standard Needs Budget (SNB) for the Family Employment Program, based on household size. The SNB is determined by the Department based on a survey of basic living expenses per R986-200-239(1). + +metadata: + unit: currency-USD + period: month + breakdown: + - range(1, 20) + label: Utah FEP Standard Needs Budget (SNB) + reference: + - title: Utah Admin. Code R986-200-239(1) + href: https://www.law.cornell.edu/regulations/utah/Utah-Admin-Code-R986-200-239 + - title: Utah DWS Table 1 - Financial Monthly Income Limits and Assistance Amounts + href: https://jobs.utah.gov/Infosource/eligibilitymanual/Tables,_Appendicies,_and_Charts/Tables,_Appendicies,_and_Charts/Table_1_-_Financial_Monthly_Income_Limits_and_Assistance_Amounts.htm + +1: + 2022-10-01: 329 +2: + 2022-10-01: 456 +3: + 2022-10-01: 568 +4: + 2022-10-01: 665 +5: + 2022-10-01: 757 +6: + 2022-10-01: 834 +7: + 2022-10-01: 873 +8: + 2022-10-01: 914 +9: + 2022-10-01: 957 +10: + 2022-10-01: 997 +11: + 2022-10-01: 1_038 +12: + 2022-10-01: 1_079 +13: + 2022-10-01: 1_120 +14: + 2022-10-01: 1_161 +15: + 2022-10-01: 1_203 +16: + 2022-10-01: 1_244 +17: + 2022-10-01: 1_285 +18: + 2022-10-01: 1_326 +19: + 2022-10-01: 1_367 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/benefit/ut_fep_payment_standard.yaml b/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/benefit/ut_fep_payment_standard.yaml new file mode 100644 index 00000000000..b514ad54bd8 --- /dev/null +++ b/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/benefit/ut_fep_payment_standard.yaml @@ -0,0 +1,73 @@ +# Unit tests for ut_fep_payment_standard (maximum benefit by family size) +# Payment standard is 87.5% of Standard Needs Budget (SNB) +# Reference: Utah Admin. Code R986-200-239 +# Source: https://jobs.utah.gov/Infosource/eligibilitymanual/Tables +# +# 2022 Payment Standards (87.5% SNB): +# Size 1: $383, Size 2: $531, Size 3: $662 +# Size 4: $775, Size 5: $882, Size 6: $972 +# Size 7: $1,017, Size 8: $1,065 + +- name: Family size 1 - payment standard $383. + period: 2024-01 + input: + state_code: UT + spm_unit_size: 1 + output: + ut_fep_payment_standard: 383 + +- name: Family size 2 - payment standard $531. + period: 2024-01 + input: + state_code: UT + spm_unit_size: 2 + output: + ut_fep_payment_standard: 531 + +- name: Family size 3 - payment standard $662. + period: 2024-01 + input: + state_code: UT + spm_unit_size: 3 + output: + ut_fep_payment_standard: 662 + +- name: Family size 4 - payment standard $775. + period: 2024-01 + input: + state_code: UT + spm_unit_size: 4 + output: + ut_fep_payment_standard: 775 + +- name: Family size 5 - payment standard $882. + period: 2024-01 + input: + state_code: UT + spm_unit_size: 5 + output: + ut_fep_payment_standard: 882 + +- name: Family size 6 - payment standard $972. + period: 2024-01 + input: + state_code: UT + spm_unit_size: 6 + output: + ut_fep_payment_standard: 972 + +- name: Family size 7 - payment standard $1,017. + period: 2024-01 + input: + state_code: UT + spm_unit_size: 7 + output: + ut_fep_payment_standard: 1_017 + +- name: Family size 8 - payment standard $1,065. + period: 2024-01 + input: + state_code: UT + spm_unit_size: 8 + output: + ut_fep_payment_standard: 1_065 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/eligibility/ut_fep_eligible.yaml b/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/eligibility/ut_fep_eligible.yaml new file mode 100644 index 00000000000..87aaab0efe4 --- /dev/null +++ b/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/eligibility/ut_fep_eligible.yaml @@ -0,0 +1,56 @@ +# Unit tests for ut_fep_eligible (final eligibility determination) +# Utah TANF eligibility requires: +# - Demographic eligibility (uses federal baseline) +# - Income eligibility (gross and net tests) +# - Resource eligibility +# Reference: Utah Admin. Code R986-200 + +- name: All eligibility criteria met - eligible. + period: 2024-01 + input: + state_code: UT + is_demographic_tanf_eligible: true + ut_fep_income_eligible: true + ut_fep_resources_eligible: true + output: + ut_fep_eligible: true + +- name: Demographic ineligible - not eligible. + period: 2024-01 + input: + state_code: UT + is_demographic_tanf_eligible: false + ut_fep_income_eligible: true + ut_fep_resources_eligible: true + output: + ut_fep_eligible: false + +- name: Income ineligible - not eligible. + period: 2024-01 + input: + state_code: UT + is_demographic_tanf_eligible: true + ut_fep_income_eligible: false + ut_fep_resources_eligible: true + output: + ut_fep_eligible: false + +- name: Resource ineligible - not eligible. + period: 2024-01 + input: + state_code: UT + is_demographic_tanf_eligible: true + ut_fep_income_eligible: true + ut_fep_resources_eligible: false + output: + ut_fep_eligible: false + +- name: All criteria not met - not eligible. + period: 2024-01 + input: + state_code: UT + is_demographic_tanf_eligible: false + ut_fep_income_eligible: false + ut_fep_resources_eligible: false + output: + ut_fep_eligible: false diff --git a/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/eligibility/ut_fep_gross_income_eligible.yaml b/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/eligibility/ut_fep_gross_income_eligible.yaml new file mode 100644 index 00000000000..312c5c7de6c --- /dev/null +++ b/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/eligibility/ut_fep_gross_income_eligible.yaml @@ -0,0 +1,91 @@ +# Unit tests for ut_fep_gross_income_eligible (185% SNB gross income test) +# Gross income must be <= 185% of Standard Needs Budget +# Reference: Utah Admin. Code R986-200-239 +# +# 2022 Gross Income Limits (185% SNB): +# Size 1: $608, Size 2: $843, Size 3: $1,050 +# Size 4: $1,230, Size 5: $1,400, Size 6: $1,542 + +- name: Gross income zero - eligible (family size 3). + period: 2024-01 + input: + state_code: UT + spm_unit_size: 3 + tanf_gross_earned_income: 0 + tanf_gross_unearned_income: 0 + output: + # Gross limit for size 3 = $1,050 + # Gross income = 0 <= 1,050 - eligible + ut_fep_gross_income_eligible: true + +- name: Gross income below limit - eligible (family size 3). + period: 2024-01 + input: + state_code: UT + spm_unit_size: 3 + tanf_gross_earned_income: 500 + tanf_gross_unearned_income: 200 + output: + # Gross limit for size 3 = $1,050 + # Gross income = 500 + 200 = 700 <= 1,050 - eligible + ut_fep_gross_income_eligible: true + +- name: Gross income at limit - eligible (family size 3). + period: 2024-01 + input: + state_code: UT + spm_unit_size: 3 + tanf_gross_earned_income: 800 + tanf_gross_unearned_income: 250 + output: + # Gross limit for size 3 = $1,050 + # Gross income = 800 + 250 = 1,050 <= 1,050 - eligible + ut_fep_gross_income_eligible: true + +- name: Gross income above limit - ineligible (family size 3). + period: 2024-01 + input: + state_code: UT + spm_unit_size: 3 + tanf_gross_earned_income: 900 + tanf_gross_unearned_income: 200 + output: + # Gross limit for size 3 = $1,050 + # Gross income = 900 + 200 = 1,100 > 1,050 - ineligible + ut_fep_gross_income_eligible: false + +- name: Gross income at limit for family size 1. + period: 2024-01 + input: + state_code: UT + spm_unit_size: 1 + tanf_gross_earned_income: 608 + tanf_gross_unearned_income: 0 + output: + # Gross limit for size 1 = $608 + # Gross income = 608 <= 608 - eligible + ut_fep_gross_income_eligible: true + +- name: Gross income above limit for family size 1. + period: 2024-01 + input: + state_code: UT + spm_unit_size: 1 + tanf_gross_earned_income: 609 + tanf_gross_unearned_income: 0 + output: + # Gross limit for size 1 = $608 + # Gross income = 609 > 608 - ineligible + ut_fep_gross_income_eligible: false + +- name: Larger family size 5 with income at limit. + period: 2024-01 + input: + state_code: UT + spm_unit_size: 5 + tanf_gross_earned_income: 1_000 + tanf_gross_unearned_income: 400 + output: + # Gross limit for size 5 = $1,400 + # Gross income = 1,000 + 400 = 1,400 <= 1,400 - eligible + ut_fep_gross_income_eligible: true diff --git a/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/eligibility/ut_fep_income_eligible.yaml b/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/eligibility/ut_fep_income_eligible.yaml new file mode 100644 index 00000000000..fbdaa459dbd --- /dev/null +++ b/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/eligibility/ut_fep_income_eligible.yaml @@ -0,0 +1,41 @@ +# Unit tests for ut_fep_income_eligible (combined income eligibility) +# Utah uses a two-step income test: +# 1. Gross income must be <= 185% of SNB +# 2. Net income must be < 100% of SNB +# Reference: Utah Admin. Code R986-200-239 + +- name: Both gross and net income eligible - income eligible. + period: 2024-01 + input: + state_code: UT + ut_fep_gross_income_eligible: true + ut_fep_net_income_eligible: true + output: + ut_fep_income_eligible: true + +- name: Gross income eligible but net income ineligible - not eligible. + period: 2024-01 + input: + state_code: UT + ut_fep_gross_income_eligible: true + ut_fep_net_income_eligible: false + output: + ut_fep_income_eligible: false + +- name: Net income eligible but gross income ineligible - not eligible. + period: 2024-01 + input: + state_code: UT + ut_fep_gross_income_eligible: false + ut_fep_net_income_eligible: true + output: + ut_fep_income_eligible: false + +- name: Both gross and net income ineligible - not eligible. + period: 2024-01 + input: + state_code: UT + ut_fep_gross_income_eligible: false + ut_fep_net_income_eligible: false + output: + ut_fep_income_eligible: false diff --git a/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/eligibility/ut_fep_net_income_eligible.yaml b/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/eligibility/ut_fep_net_income_eligible.yaml new file mode 100644 index 00000000000..e7ea6ac50fc --- /dev/null +++ b/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/eligibility/ut_fep_net_income_eligible.yaml @@ -0,0 +1,84 @@ +# Unit tests for ut_fep_net_income_eligible (100% SNB net income test) +# Net income must be < 100% of Standard Needs Budget (strict less than) +# Reference: Utah Admin. Code R986-200-239 +# +# 2022 Net Income Limits (100% SNB): +# Size 1: $329, Size 2: $456, Size 3: $568 +# Size 4: $665, Size 5: $757, Size 6: $834 + +- name: Net income zero - eligible (family size 3). + period: 2024-01 + input: + state_code: UT + spm_unit_size: 3 + ut_fep_countable_income: 0 + output: + # Net limit for size 3 = $568 + # Net income = 0 < 568 - eligible + ut_fep_net_income_eligible: true + +- name: Net income below limit - eligible (family size 3). + period: 2024-01 + input: + state_code: UT + spm_unit_size: 3 + ut_fep_countable_income: 400 + output: + # Net limit for size 3 = $568 + # Net income = 400 < 568 - eligible + ut_fep_net_income_eligible: true + +- name: Net income at limit - ineligible (family size 3). + period: 2024-01 + input: + state_code: UT + spm_unit_size: 3 + ut_fep_countable_income: 568 + output: + # Net limit for size 3 = $568 + # Net income = 568 NOT < 568 - ineligible (strict less than) + ut_fep_net_income_eligible: false + +- name: Net income above limit - ineligible (family size 3). + period: 2024-01 + input: + state_code: UT + spm_unit_size: 3 + ut_fep_countable_income: 600 + output: + # Net limit for size 3 = $568 + # Net income = 600 > 568 - ineligible + ut_fep_net_income_eligible: false + +- name: Net income just below limit - eligible (family size 3). + period: 2024-01 + input: + state_code: UT + spm_unit_size: 3 + ut_fep_countable_income: 567 + output: + # Net limit for size 3 = $568 + # Net income = 567 < 568 - eligible + ut_fep_net_income_eligible: true + +- name: Net income at limit for family size 1. + period: 2024-01 + input: + state_code: UT + spm_unit_size: 1 + ut_fep_countable_income: 329 + output: + # Net limit for size 1 = $329 + # Net income = 329 NOT < 329 - ineligible (strict less than) + ut_fep_net_income_eligible: false + +- name: Net income below limit for family size 5. + period: 2024-01 + input: + state_code: UT + spm_unit_size: 5 + ut_fep_countable_income: 500 + output: + # Net limit for size 5 = $757 + # Net income = 500 < 757 - eligible + ut_fep_net_income_eligible: true diff --git a/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/eligibility/ut_fep_resources_eligible.yaml b/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/eligibility/ut_fep_resources_eligible.yaml new file mode 100644 index 00000000000..8b3585d907a --- /dev/null +++ b/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/eligibility/ut_fep_resources_eligible.yaml @@ -0,0 +1,47 @@ +# Unit tests for ut_fep_resources_eligible (resource/asset test) +# Countable resources must not exceed $2,000 +# Reference: Utah Admin. Code R986-200-230 + +- name: No resources - eligible. + period: 2024-01 + input: + state_code: UT + spm_unit_assets: 0 + output: + ut_fep_resources_eligible: true + +- name: Resources below limit - eligible. + period: 2024-01 + input: + state_code: UT + spm_unit_assets: 1_500 + output: + # Resources = 1,500 <= 2,000 - eligible + ut_fep_resources_eligible: true + +- name: Resources at limit - eligible. + period: 2024-01 + input: + state_code: UT + spm_unit_assets: 2_000 + output: + # Resources = 2,000 <= 2,000 - eligible + ut_fep_resources_eligible: true + +- name: Resources above limit - ineligible. + period: 2024-01 + input: + state_code: UT + spm_unit_assets: 2_001 + output: + # Resources = 2,001 > 2,000 - ineligible + ut_fep_resources_eligible: false + +- name: Resources significantly above limit - ineligible. + period: 2024-01 + input: + state_code: UT + spm_unit_assets: 5_000 + output: + # Resources = 5,000 > 2,000 - ineligible + ut_fep_resources_eligible: false diff --git a/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/income/ut_fep_countable_earned_income.yaml b/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/income/ut_fep_countable_earned_income.yaml new file mode 100644 index 00000000000..300a9aeece9 --- /dev/null +++ b/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/income/ut_fep_countable_earned_income.yaml @@ -0,0 +1,127 @@ +# Unit tests for ut_fep_countable_earned_income +# Utah applies earned income deductions then counts the remainder: +# 1. Work expense allowance: $100 per employed person +# 2. 50% earned income disregard on remaining earned income +# Formula: sum(max(person_earned - 100, 0)) * 0.5 +# Reference: Utah Admin. Code R986-200-239(2)(a) and R986-200-239(2)(b) + +- name: No earned income - zero countable. + period: 2024-01 + input: + people: + person1: + tanf_gross_earned_income: 0 + person2: + tanf_gross_earned_income: 0 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: UT + output: + # No earnings = no countable earned income + ut_fep_countable_earned_income: 0 + +- name: Single employed person with $500 earnings. + period: 2024-01 + input: + people: + person1: + tanf_gross_earned_income: 500 + person2: + tanf_gross_earned_income: 0 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: UT + output: + # After work expense = max(500 - 100, 0) = 400 + # Countable = 400 * 0.50 = 200 + ut_fep_countable_earned_income: 200 + +- name: Single employed person with $1,000 earnings. + period: 2024-01 + input: + people: + person1: + tanf_gross_earned_income: 1_000 + person2: + tanf_gross_earned_income: 0 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: UT + output: + # After work expense = max(1000 - 100, 0) = 900 + # Countable = 900 * 0.50 = 450 + ut_fep_countable_earned_income: 450 + +- name: Two employed persons with earnings. + period: 2024-01 + input: + people: + person1: + tanf_gross_earned_income: 600 + person2: + tanf_gross_earned_income: 400 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: UT + output: + # Person1 after work expense = max(600 - 100, 0) = 500 + # Person2 after work expense = max(400 - 100, 0) = 300 + # Total after work expense = 800 + # Countable = 800 * 0.50 = 400 + ut_fep_countable_earned_income: 400 + +- name: Earnings less than work expense deduction. + period: 2024-01 + input: + people: + person1: + tanf_gross_earned_income: 80 + person2: + tanf_gross_earned_income: 0 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: UT + output: + # After work expense = max(80 - 100, 0) = 0 + # Countable = 0 * 0.50 = 0 + ut_fep_countable_earned_income: 0 + +- name: Earnings exactly equal to work expense. + period: 2024-01 + input: + people: + person1: + tanf_gross_earned_income: 100 + person2: + tanf_gross_earned_income: 0 + spm_units: + spm_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: UT + output: + # After work expense = max(100 - 100, 0) = 0 + # Countable = 0 * 0.50 = 0 + ut_fep_countable_earned_income: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/income/ut_fep_earned_income_after_work_expense.yaml b/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/income/ut_fep_earned_income_after_work_expense.yaml new file mode 100644 index 00000000000..c81ce3e4aec --- /dev/null +++ b/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/income/ut_fep_earned_income_after_work_expense.yaml @@ -0,0 +1,59 @@ +# Unit tests for ut_fep_earned_income_after_work_expense (Person-level) +# Earned income after $100 work expense deduction per person +# Formula: max(earned_income - 100, 0) +# Reference: Utah Admin. Code R986-200-239(2)(a) + +- name: No earned income. + period: 2024-01 + input: + people: + person1: + tanf_gross_earned_income: 0 + households: + household: + members: [person1] + state_code: UT + output: + ut_fep_earned_income_after_work_expense: 0 + +- name: Earned income $500. + period: 2024-01 + input: + people: + person1: + tanf_gross_earned_income: 500 + households: + household: + members: [person1] + state_code: UT + output: + # max(500 - 100, 0) = 400 + ut_fep_earned_income_after_work_expense: 400 + +- name: Earned income less than $100. + period: 2024-01 + input: + people: + person1: + tanf_gross_earned_income: 80 + households: + household: + members: [person1] + state_code: UT + output: + # max(80 - 100, 0) = 0 + ut_fep_earned_income_after_work_expense: 0 + +- name: Earned income exactly $100. + period: 2024-01 + input: + people: + person1: + tanf_gross_earned_income: 100 + households: + household: + members: [person1] + state_code: UT + output: + # max(100 - 100, 0) = 0 + ut_fep_earned_income_after_work_expense: 0 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/integration.yaml b/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/integration.yaml new file mode 100644 index 00000000000..d79a711b1c3 --- /dev/null +++ b/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/integration.yaml @@ -0,0 +1,304 @@ +# Integration tests for Utah TANF (Family Employment Program) +# Tests the complete benefit calculation pipeline from inputs to final benefit +# Reference: Utah Admin. Code R986-200 +# +# Key Program Parameters (October 2022): +# - Gross income limit: 185% of Standard Needs Budget (SNB) +# - Net income limit: 100% of SNB (strict less than) +# - Payment standard: 87.5% of SNB +# - Work expense deduction: $100 per employed person +# - Earned income disregard: 50% of remaining earned income +# - Resource limit: $2,000 + +- name: Case 1 - Single parent with one child, no income, receives maximum benefit. + period: 2024-01 + input: + people: + person1: + age: 30 + tanf_gross_earned_income: 0 + tanf_gross_unearned_income: 0 + person2: + age: 5 + is_tax_unit_dependent: true + spm_units: + spm_unit: + members: [person1, person2] + spm_unit_assets: 500 + tax_units: + tax_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: UT + output: + # Family size = 2 + # Gross income = 0, Gross limit = $843 -> PASS + # No earnings, so no deductions + # Countable income = 0, Net limit = $456 -> PASS + # Resources = $500 <= $2,000 -> PASS + # Eligible = true + # Benefit = Payment standard ($531) - Countable income (0) = $531 + ut_fep_payment_standard: 531 + ut_fep_gross_income_eligible: true + ut_fep_countable_income: 0 + ut_fep_net_income_eligible: true + ut_fep_resources_eligible: true + ut_fep_income_eligible: true + ut_fep_eligible: true + ut_fep: 531 + +- name: Case 2 - Single parent with two children, moderate earnings, partial benefit. + period: 2024-01 + input: + people: + person1: + age: 28 + tanf_gross_earned_income: 600 + tanf_gross_unearned_income: 0 + person2: + age: 8 + is_tax_unit_dependent: true + person3: + age: 4 + is_tax_unit_dependent: true + spm_units: + spm_unit: + members: [person1, person2, person3] + spm_unit_assets: 1_000 + tax_units: + tax_unit: + members: [person1, person2, person3] + households: + household: + members: [person1, person2, person3] + state_code: UT + output: + # Family size = 3 + # Gross income = $600, Gross limit = $1,050 -> PASS + # After work expense = max(600 - 100, 0) = 500 + # Countable earned = 500 * 0.50 = 250 + # Countable income = 250 + 0 (unearned) = 250 + # Net limit = $568 (100% SNB), $250 < $568 -> PASS + # Resources = $1,000 <= $2,000 -> PASS + # Eligible = true + # Benefit = Payment standard ($662) - Countable income ($250) = $412 + ut_fep_payment_standard: 662 + ut_fep_countable_earned_income: 250 + ut_fep_gross_income_eligible: true + ut_fep_countable_income: 250 + ut_fep_net_income_eligible: true + ut_fep_resources_eligible: true + ut_fep_income_eligible: true + ut_fep_eligible: true + ut_fep: 412 + +- name: Case 3 - Two-parent family with three children, both employed. + period: 2024-01 + input: + people: + person1: + age: 35 + tanf_gross_earned_income: 400 + tanf_gross_unearned_income: 0 + person2: + age: 33 + tanf_gross_earned_income: 300 + tanf_gross_unearned_income: 0 + person3: + age: 10 + is_tax_unit_dependent: true + person4: + age: 7 + is_tax_unit_dependent: true + person5: + age: 3 + is_tax_unit_dependent: true + spm_units: + spm_unit: + members: [person1, person2, person3, person4, person5] + spm_unit_assets: 1_500 + tax_units: + tax_unit: + members: [person1, person2, person3, person4, person5] + households: + household: + members: [person1, person2, person3, person4, person5] + state_code: UT + output: + # Family size = 5 + # Gross income = $400 + $300 = $700, Gross limit = $1,400 -> PASS + # After work expense = max(400-100,0) + max(300-100,0) = 300 + 200 = 500 + # Countable earned = 500 * 0.50 = 250 + # Countable income = 250 + 0 (unearned) = 250 + # Net limit = $757 (100% SNB), $250 < $757 -> PASS + # Resources = $1,500 <= $2,000 -> PASS + # Eligible = true + # Benefit = Payment standard ($882) - Countable income ($250) = $632 + ut_fep_payment_standard: 882 + ut_fep_countable_earned_income: 250 + ut_fep_gross_income_eligible: true + ut_fep_countable_income: 250 + ut_fep_net_income_eligible: true + ut_fep_resources_eligible: true + ut_fep_income_eligible: true + ut_fep_eligible: true + ut_fep: 632 + +- name: Case 4 - Ineligible due to gross income exceeding 185% SNB. + period: 2024-01 + input: + people: + person1: + age: 32 + tanf_gross_earned_income: 1_200 + tanf_gross_unearned_income: 0 + person2: + age: 6 + is_tax_unit_dependent: true + spm_units: + spm_unit: + members: [person1, person2] + spm_unit_assets: 500 + tax_units: + tax_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: UT + output: + # Family size = 2 + # Gross income = $1,200, Gross limit = $843 (185% SNB) + # $1,200 > $843 -> FAIL gross income test + # Ineligible, benefit = $0 + ut_fep_payment_standard: 531 + ut_fep_gross_income_eligible: false + ut_fep_income_eligible: false + ut_fep_eligible: false + ut_fep: 0 + +- name: Case 5 - Ineligible due to gross income with mixed income sources. + period: 2024-01 + input: + people: + person1: + age: 29 + tanf_gross_earned_income: 800 + tanf_gross_unearned_income: 200 + person2: + age: 3 + is_tax_unit_dependent: true + spm_units: + spm_unit: + members: [person1, person2] + spm_unit_assets: 800 + tax_units: + tax_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: UT + output: + # Family size = 2 + # Gross income = $800 + $200 = $1,000 + # Gross limit = $843 (185% SNB for size 2) + # $1,000 > $843 -> FAIL gross income test + ut_fep_payment_standard: 531 + ut_fep_gross_income_eligible: false + ut_fep_income_eligible: false + ut_fep_eligible: false + ut_fep: 0 + +- name: Case 6 - Ineligible due to excess resources. + period: 2024-01 + input: + people: + person1: + age: 27 + tanf_gross_earned_income: 400 + tanf_gross_unearned_income: 0 + person2: + age: 2 + is_tax_unit_dependent: true + spm_units: + spm_unit: + members: [person1, person2] + spm_unit_assets: 3_000 + tax_units: + tax_unit: + members: [person1, person2] + households: + household: + members: [person1, person2] + state_code: UT + output: + # Family size = 2 + # Gross income = $400, Gross limit = $843 -> PASS + # After work expense = max(400 - 100, 0) = 300 + # Countable earned = 300 * 0.50 = 150 + # Countable income = 150 + 0 (unearned) = 150 + # Net limit = $456, $150 < $456 -> PASS + # Resources = $3,000 > $2,000 -> FAIL + # Ineligible due to excess resources + ut_fep_payment_standard: 531 + ut_fep_countable_earned_income: 150 + ut_fep_gross_income_eligible: true + ut_fep_countable_income: 150 + ut_fep_net_income_eligible: true + ut_fep_resources_eligible: false + ut_fep_income_eligible: true + ut_fep_eligible: false + ut_fep: 0 + +- name: Case 7 - Large family with unearned income only. + period: 2024-01 + input: + people: + person1: + age: 40 + tanf_gross_earned_income: 0 + tanf_gross_unearned_income: 400 + person2: + age: 15 + is_tax_unit_dependent: true + person3: + age: 12 + is_tax_unit_dependent: true + person4: + age: 8 + is_tax_unit_dependent: true + person5: + age: 5 + is_tax_unit_dependent: true + spm_units: + spm_unit: + members: [person1, person2, person3, person4, person5] + spm_unit_assets: 1_200 + tax_units: + tax_unit: + members: [person1, person2, person3, person4, person5] + households: + household: + members: [person1, person2, person3, person4, person5] + state_code: UT + output: + # Family size = 5 + # Gross income = $400 (unearned only), Gross limit = $1,400 -> PASS + # No earned income, so no deductions apply + # Countable income = $400 (unearned passes through) + # Net limit = $757, $400 < $757 -> PASS + # Resources = $1,200 <= $2,000 -> PASS + # Eligible = true + # Benefit = Payment standard ($882) - Countable income ($400) = $482 + ut_fep_payment_standard: 882 + ut_fep_countable_earned_income: 0 + ut_fep_gross_income_eligible: true + ut_fep_countable_income: 400 + ut_fep_net_income_eligible: true + ut_fep_resources_eligible: true + ut_fep_income_eligible: true + ut_fep_eligible: true + ut_fep: 482 diff --git a/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/ut_fep.yaml b/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/ut_fep.yaml new file mode 100644 index 00000000000..6dd2be032bb --- /dev/null +++ b/policyengine_us/tests/policy/baseline/gov/states/ut/dwf/fep/ut_fep.yaml @@ -0,0 +1,93 @@ +# Unit test for Utah Family Employment Program (TANF) +# Based on October 2022 payment standards +# +# Test case: Family of 3, single parent, $1,000/month earned income +# Gross income = $1,000/month (earned) +# Gross limit for 3 = $1,050 -> PASS gross test +# After work expense = max(1000 - 100, 0) = 900 +# Countable earned = 900 * 0.50 = 450 +# Countable income = 450 + 0 (unearned) = 450 +# Net limit for 3 = $568 -> PASS net test (450 < 568) +# Payment standard for 3 = $662/month +# Benefit = $662 - $450 = $212/month +# Annual values = monthly * 12 + +- name: Utah TANF - eligible family of 3 + period: 2023 + input: + people: + parent: + age: 30 + employment_income_before_lsr: 12_000 # $1,000/month + child1: + age: 8 + child2: + age: 5 + spm_units: + spm_unit: + members: [parent, child1, child2] + spm_unit_assets: 1_000 + households: + household: + members: [parent, child1, child2] + state_code: UT + output: + ut_fep_countable_earned_income: 450 * 12 # $450/month * 12 + ut_fep_countable_income: 450 * 12 # $450/month * 12 + ut_fep_income_eligible: true + ut_fep_resources_eligible: true + ut_fep_eligible: true + ut_fep_payment_standard: 662 * 12 # $662/month * 12 + ut_fep: 212 * 12 # $212/month * 12 + +# Test case: Family over gross income limit +# Gross income = $1,200/month (earned) +# Gross limit for 3 = $1,050/month -> FAIL gross test + +- name: Utah TANF - ineligible due to gross income + period: 2023 + input: + people: + parent: + age: 30 + employment_income_before_lsr: 14_400 # $1,200/month + child1: + age: 8 + child2: + age: 5 + spm_units: + spm_unit: + members: [parent, child1, child2] + spm_unit_assets: 500 + households: + household: + members: [parent, child1, child2] + state_code: UT + output: + ut_fep_income_eligible: false + ut_fep_eligible: false + ut_fep: 0 + +# Test case: Family over resource limit + +- name: Utah TANF - ineligible due to resources + period: 2023 + input: + people: + parent: + age: 30 + employment_income_before_lsr: 6_000 # $500/month + child1: + age: 8 + spm_units: + spm_unit: + members: [parent, child1] + spm_unit_assets: 2_500 # Over $2,000 limit + households: + household: + members: [parent, child1] + state_code: UT + output: + ut_fep_resources_eligible: false + ut_fep_eligible: false + ut_fep: 0 diff --git a/policyengine_us/variables/gov/states/ut/dwf/fep/eligibility/ut_fep_eligible.py b/policyengine_us/variables/gov/states/ut/dwf/fep/eligibility/ut_fep_eligible.py new file mode 100644 index 00000000000..f2aba83ce90 --- /dev/null +++ b/policyengine_us/variables/gov/states/ut/dwf/fep/eligibility/ut_fep_eligible.py @@ -0,0 +1,17 @@ +from policyengine_us.model_api import * + + +class ut_fep_eligible(Variable): + value_type = bool + entity = SPMUnit + label = "Eligible for Utah Family Employment Program" + definition_period = MONTH + reference = "https://www.law.cornell.edu/regulations/utah/Utah-Admin-Code-R986-200-202" + defined_for = StateCode.UT + + def formula(spm_unit, period, parameters): + # Per R986-200: Must meet demographic, income, and resource tests + demographic_eligible = spm_unit("is_demographic_tanf_eligible", period) + income_eligible = spm_unit("ut_fep_income_eligible", period) + resource_eligible = spm_unit("ut_fep_resources_eligible", period) + return demographic_eligible & income_eligible & resource_eligible diff --git a/policyengine_us/variables/gov/states/ut/dwf/fep/eligibility/ut_fep_gross_income_eligible.py b/policyengine_us/variables/gov/states/ut/dwf/fep/eligibility/ut_fep_gross_income_eligible.py new file mode 100644 index 00000000000..eaada2f06c0 --- /dev/null +++ b/policyengine_us/variables/gov/states/ut/dwf/fep/eligibility/ut_fep_gross_income_eligible.py @@ -0,0 +1,26 @@ +from policyengine_us.model_api import * + + +class ut_fep_gross_income_eligible(Variable): + value_type = bool + entity = SPMUnit + label = "Eligible for Utah TANF under gross income test" + definition_period = MONTH + reference = "https://www.law.cornell.edu/regulations/utah/Utah-Admin-Code-R986-200-239" + defined_for = StateCode.UT + + def formula(spm_unit, period, parameters): + # Utah gross income test: gross income <= 185% of SNB (Standard Needs Budget) + # Per R986-200-239(1), gross income must be <= 185% of SNB + # The net income limit equals the SNB + p = parameters(period).gov.states.ut.dwf.fep + + size = spm_unit("spm_unit_size", period) + size_capped = min_(size, p.payment_standard.max_unit_size) + + # Standard Needs Budget (SNB) = net income limit + snb = p.standard_needs_budget.amount[size_capped] + gross_income_limit = snb * p.income.gross_income_limit.rate + + gross_income = spm_unit("ut_fep_gross_income", period) + return gross_income <= gross_income_limit diff --git a/policyengine_us/variables/gov/states/ut/dwf/fep/eligibility/ut_fep_income_eligible.py b/policyengine_us/variables/gov/states/ut/dwf/fep/eligibility/ut_fep_income_eligible.py new file mode 100644 index 00000000000..959f076315a --- /dev/null +++ b/policyengine_us/variables/gov/states/ut/dwf/fep/eligibility/ut_fep_income_eligible.py @@ -0,0 +1,16 @@ +from policyengine_us.model_api import * + + +class ut_fep_income_eligible(Variable): + value_type = bool + entity = SPMUnit + label = "Eligible for Utah Family Employment Program due to income" + definition_period = MONTH + reference = "https://www.law.cornell.edu/regulations/utah/Utah-Admin-Code-R986-200-239" + defined_for = StateCode.UT + + def formula(spm_unit, period, parameters): + # Utah uses two-tier income test per R986-200-238 + gross_test = spm_unit("ut_fep_gross_income_eligible", period) + net_test = spm_unit("ut_fep_net_income_eligible", period) + return gross_test & net_test diff --git a/policyengine_us/variables/gov/states/ut/dwf/fep/eligibility/ut_fep_net_income_eligible.py b/policyengine_us/variables/gov/states/ut/dwf/fep/eligibility/ut_fep_net_income_eligible.py new file mode 100644 index 00000000000..303c125ebfe --- /dev/null +++ b/policyengine_us/variables/gov/states/ut/dwf/fep/eligibility/ut_fep_net_income_eligible.py @@ -0,0 +1,20 @@ +from policyengine_us.model_api import * + + +class ut_fep_net_income_eligible(Variable): + value_type = bool + entity = SPMUnit + label = "Eligible for Utah TANF under net income test" + definition_period = MONTH + reference = "https://www.law.cornell.edu/regulations/utah/Utah-Admin-Code-R986-200-239" + defined_for = StateCode.UT + + def formula(spm_unit, period, parameters): + # Utah net income test: countable income < 100% of SNB (strict less than) + p = parameters(period).gov.states.ut.dwf.fep + + size = spm_unit("spm_unit_size", period) + size_capped = min_(size, p.payment_standard.max_unit_size) + + countable_income = spm_unit("ut_fep_countable_income", period) + return countable_income < p.standard_needs_budget.amount[size_capped] diff --git a/policyengine_us/variables/gov/states/ut/dwf/fep/eligibility/ut_fep_resources_eligible.py b/policyengine_us/variables/gov/states/ut/dwf/fep/eligibility/ut_fep_resources_eligible.py new file mode 100644 index 00000000000..3b09ded7e1d --- /dev/null +++ b/policyengine_us/variables/gov/states/ut/dwf/fep/eligibility/ut_fep_resources_eligible.py @@ -0,0 +1,16 @@ +from policyengine_us.model_api import * + + +class ut_fep_resources_eligible(Variable): + value_type = bool + entity = SPMUnit + label = "Eligible for Utah Family Employment Program due to resources" + definition_period = MONTH + reference = "https://www.law.cornell.edu/regulations/utah/Utah-Admin-Code-R986-200-230" + defined_for = StateCode.UT + + def formula(spm_unit, period, parameters): + p = parameters(period).gov.states.ut.dwf.fep.resources.limit + # Use federal spm_unit_assets variable directly + assets = spm_unit("spm_unit_assets", period.this_year) + return assets <= p.amount diff --git a/policyengine_us/variables/gov/states/ut/dwf/fep/income/ut_fep_countable_earned_income.py b/policyengine_us/variables/gov/states/ut/dwf/fep/income/ut_fep_countable_earned_income.py new file mode 100644 index 00000000000..617d415f460 --- /dev/null +++ b/policyengine_us/variables/gov/states/ut/dwf/fep/income/ut_fep_countable_earned_income.py @@ -0,0 +1,22 @@ +from policyengine_us.model_api import * + + +class ut_fep_countable_earned_income(Variable): + value_type = float + entity = SPMUnit + label = "Utah TANF countable earned income" + unit = USD + definition_period = MONTH + reference = "https://www.law.cornell.edu/regulations/utah/Utah-Admin-Code-R986-200-239" + defined_for = StateCode.UT + + def formula(spm_unit, period, parameters): + # Utah earned income after deductions per R986-200-239: + # 1. Work expense allowance: $100 per employed person + # 2. 50% earned income disregard on remaining earned income + p = parameters(period).gov.states.ut.dwf.fep.income.deductions + after_work_expense = add( + spm_unit, period, ["ut_fep_earned_income_after_work_expense"] + ) + # Countable = remainder * (1 - disregard_rate) = remainder * 0.5 + return after_work_expense * (1 - p.earned_income_disregard.rate) diff --git a/policyengine_us/variables/gov/states/ut/dwf/fep/income/ut_fep_countable_income.py b/policyengine_us/variables/gov/states/ut/dwf/fep/income/ut_fep_countable_income.py new file mode 100644 index 00000000000..7336c0aa8ba --- /dev/null +++ b/policyengine_us/variables/gov/states/ut/dwf/fep/income/ut_fep_countable_income.py @@ -0,0 +1,16 @@ +from policyengine_us.model_api import * + + +class ut_fep_countable_income(Variable): + value_type = float + entity = SPMUnit + label = "Utah Family Employment Program countable income" + unit = USD + definition_period = MONTH + reference = "https://www.law.cornell.edu/regulations/utah/Utah-Admin-Code-R986-200-239" + defined_for = StateCode.UT + + adds = [ + "ut_fep_countable_earned_income", + "tanf_gross_unearned_income", + ] diff --git a/policyengine_us/variables/gov/states/ut/dwf/fep/income/ut_fep_earned_income_after_work_expense.py b/policyengine_us/variables/gov/states/ut/dwf/fep/income/ut_fep_earned_income_after_work_expense.py new file mode 100644 index 00000000000..8eb89ae20e5 --- /dev/null +++ b/policyengine_us/variables/gov/states/ut/dwf/fep/income/ut_fep_earned_income_after_work_expense.py @@ -0,0 +1,17 @@ +from policyengine_us.model_api import * + + +class ut_fep_earned_income_after_work_expense(Variable): + value_type = float + entity = Person + label = "Utah TANF earned income after work expense deduction" + unit = USD + definition_period = MONTH + reference = "https://www.law.cornell.edu/regulations/utah/Utah-Admin-Code-R986-200-239" + defined_for = StateCode.UT + + def formula(person, period, parameters): + # $100 work expense deduction per employed person + p = parameters(period).gov.states.ut.dwf.fep.income.deductions + earned_income = person("tanf_gross_earned_income", period) + return max_(earned_income - p.work_expense_allowance.amount, 0) diff --git a/policyengine_us/variables/gov/states/ut/dwf/fep/income/ut_fep_gross_income.py b/policyengine_us/variables/gov/states/ut/dwf/fep/income/ut_fep_gross_income.py new file mode 100644 index 00000000000..e2c28ce89b2 --- /dev/null +++ b/policyengine_us/variables/gov/states/ut/dwf/fep/income/ut_fep_gross_income.py @@ -0,0 +1,16 @@ +from policyengine_us.model_api import * + + +class ut_fep_gross_income(Variable): + value_type = float + entity = SPMUnit + label = "Utah Family Employment Program gross income" + unit = USD + definition_period = MONTH + reference = "https://www.law.cornell.edu/regulations/utah/Utah-Admin-Code-R986-200-239" + defined_for = StateCode.UT + + adds = [ + "tanf_gross_earned_income", + "tanf_gross_unearned_income", + ] diff --git a/policyengine_us/variables/gov/states/ut/dwf/fep/ut_fep.py b/policyengine_us/variables/gov/states/ut/dwf/fep/ut_fep.py new file mode 100644 index 00000000000..71a1761c2a5 --- /dev/null +++ b/policyengine_us/variables/gov/states/ut/dwf/fep/ut_fep.py @@ -0,0 +1,17 @@ +from policyengine_us.model_api import * + + +class ut_fep(Variable): + value_type = float + entity = SPMUnit + label = "Utah Family Employment Program benefit" + unit = USD + definition_period = MONTH + reference = "https://www.law.cornell.edu/regulations/utah/Utah-Admin-Code-R986-200-239" + defined_for = "ut_fep_eligible" + + def formula(spm_unit, period, parameters): + # Per R986-200-246: Benefit = payment standard - countable income + payment_standard = spm_unit("ut_fep_payment_standard", period) + countable_income = spm_unit("ut_fep_countable_income", period) + return max_(payment_standard - countable_income, 0) diff --git a/policyengine_us/variables/gov/states/ut/dwf/fep/ut_fep_payment_standard.py b/policyengine_us/variables/gov/states/ut/dwf/fep/ut_fep_payment_standard.py new file mode 100644 index 00000000000..9d66d20d7c2 --- /dev/null +++ b/policyengine_us/variables/gov/states/ut/dwf/fep/ut_fep_payment_standard.py @@ -0,0 +1,17 @@ +from policyengine_us.model_api import * + + +class ut_fep_payment_standard(Variable): + value_type = float + entity = SPMUnit + label = "Utah Family Employment Program payment standard" + unit = USD + definition_period = MONTH + reference = "https://www.law.cornell.edu/regulations/utah/Utah-Admin-Code-R986-200-239" + defined_for = StateCode.UT + + def formula(spm_unit, period, parameters): + p = parameters(period).gov.states.ut.dwf.fep.payment_standard + size = spm_unit("spm_unit_size", period) + size_capped = min_(size, p.max_unit_size) + return p.amount[size_capped]