policyengine-us 1.306.0__py3-none-any.whl → 1.455.0__py3-none-any.whl

policyengine_us/tools/taxsim/generate_taxsim_tests.py

@@ -5,7 +5,6 @@ import pandas as pd
 import subprocess
 import stat
 from io import StringIO
-from policyengine_us_data import CPS_2024
 from policyengine_core.data import Dataset
 from policyengine_core.taxbenefitsystems import TaxBenefitSystem
 from policyengine_us import Microsimulation
@@ -284,6 +283,9 @@ class TaxSim35:
         return test_str
 
 
+DEFAULT_DATASET = "hf://policyengine/policyengine-us-data/enhanced_cps_2024.h5"
+
+
 if __name__ == "__main__":
     parser = ArgumentParser(description="Generate tests from TAXSIM35")
     parser.add_argument(
@@ -299,6 +301,6 @@ if __name__ == "__main__":
     taxsim = TaxSim35()
     taxsim.OUTPUT_VARIABLES = args.outputs
     result = taxsim.generate_from_microsimulation(
-        CPS_2024, args.year, number=args.num
+        DEFAULT_DATASET, args.year, number=args.num
     )
     print(result)

policyengine_us/variables/contrib/ubi_center/flat_tax.py

@@ -10,11 +10,14 @@ class flat_tax(Variable):
     definition_period = YEAR
 
     def formula(tax_unit, period, parameters):
-        p = parameters(period).gov.contrib.ubi_center.flat_tax.rate
+        p = parameters(period).gov.contrib.ubi_center.flat_tax
         # Gross income flat tax.
         gross_income = add(tax_unit, period, ["positive_gross_income"])
-        gross_income_flat_tax = gross_income * p.gross_income
+        gross_income_flat_tax = gross_income * p.rate.gross_income
         # AGI flat tax.
+        filing_status = tax_unit("filing_status", period)
+        exemption = p.exemption.agi[filing_status]
         agi = tax_unit("positive_agi", period)
-        agi_flat_tax = agi * p.agi
+        excess_agi = max_(agi - exemption, 0)
+        agi_flat_tax = excess_agi * p.rate.agi
         return gross_income_flat_tax + agi_flat_tax

policyengine_us/variables/gov/aca/aca_take_up_seed.py

@@ -0,0 +1,8 @@
+from policyengine_us.model_api import *
+
+
+class aca_take_up_seed(Variable):
+    value_type = float
+    entity = TaxUnit
+    label = "Randomly assigned seed for ACA take-up"
+    definition_period = YEAR

policyengine_us/variables/gov/aca/ptc/aca_ptc.py

@@ -13,5 +13,11 @@ class aca_ptc(Variable):
     def formula(tax_unit, period, parameters):
         plan_cost = tax_unit("slcsp", period)
         income = tax_unit("aca_magi", period)
-        applicable_figure = tax_unit("aca_ptc_phase_out_rate", period)
-        return max_(0, plan_cost - income * applicable_figure)
+        applicable_figure = tax_unit(
+            "aca_required_contribution_percentage", period
+        )
+        takes_up_aca_if_eligible = tax_unit("takes_up_aca_if_eligible", period)
+        return (
+            max_(0, plan_cost - income * applicable_figure)
+            * takes_up_aca_if_eligible
+        )

policyengine_us/variables/gov/aca/ptc/aca_required_contribution_percentage.py

@@ -0,0 +1,15 @@
+from policyengine_us.model_api import *
+
+
+class aca_required_contribution_percentage(Variable):
+    value_type = float
+    entity = TaxUnit
+    label = "ACA PTC phase-out rate (i.e., IRS Form 8962 'applicable figure')"
+    unit = "/1"
+    definition_period = YEAR
+    reference = "https://www.law.cornell.edu/uscode/text/26/36B#b_3_A"
+
+    def formula(tax_unit, period, parameters):
+        magi_frac = tax_unit("aca_magi_fraction", period)
+        p = parameters(period).gov.aca.required_contribution_percentage
+        return np.interp(magi_frac, p.thresholds, p.amounts)

policyengine_us/variables/gov/aca/slspc/slcsp_age_0.py

@@ -10,9 +10,6 @@ class slcsp_age_0(Variable):
     definition_period = MONTH
 
     def formula(household, period, parameters):
-        simulation: Simulation = household.simulation
-        if simulation.is_over_dataset:
-            return 0
         # Get state code and rating area
         state_code = household("state_code", period)
         rating_area = household("slcsp_rating_area", period)

policyengine_us/variables/gov/aca/slspc/slcsp_rating_area_la_county.py

@@ -13,4 +13,8 @@ class slcsp_rating_area_la_county(Variable):
     def formula(household, period, parameters):
         zip3 = household("three_digit_zip_code", period)
         p = parameters(period).gov.aca
-        return p.la_county_rating_area[zip3]
+        is_in_la = household("in_la", period)
+        result = np.empty(zip3.shape, dtype=int)
+        result[is_in_la] = p.la_county_rating_area[zip3[is_in_la]]
+        result[~is_in_la] = 0
+        return result

policyengine_us/variables/gov/aca/takes_up_aca_if_eligible.py

@@ -0,0 +1,13 @@
+from policyengine_us.model_api import *
+
+
+class takes_up_aca_if_eligible(Variable):
+    value_type = bool
+    entity = TaxUnit
+    label = "Whether a random eligible SPM unit does not claim ACA Premium Tax Credit"
+    definition_period = YEAR
+
+    def formula(tax_unit, period, parameters):
+        seed = tax_unit("aca_take_up_seed", period)
+        takeup_rate = parameters(period).gov.aca.takeup_rate
+        return seed < takeup_rate

policyengine_us/variables/gov/ed/is_federal_work_study_participant.py

@@ -0,0 +1,9 @@
+from policyengine_us.model_api import *
+
+
+class is_federal_work_study_participant(Variable):
+    value_type = bool
+    entity = Person
+    definition_period = YEAR
+    label = "Participating in Federal Work Study"
+    reference = "https://www.law.cornell.edu/cfr/text/34/part-675"

policyengine_us/variables/gov/ed/pell_grant/efc/pell_grant_simplified_formula_applies.py

@@ -12,6 +12,5 @@ class pell_grant_simplified_formula_applies(Variable):
         head_income = tax_unit("pell_grant_primary_income", period)
         p = parameters(period).gov.ed.pell_grant.efc.simplified
         income_eligible = head_income < p.income_limit
-        total_benefits = add(tax_unit, period, p.benefits)
-        has_benefits = np.any(total_benefits > 0)
+        has_benefits = add(tax_unit, period, p.benefits) > 0
         return income_eligible & has_benefits & p.applies

policyengine_us/variables/gov/fcc/acp/acp.py

@@ -8,15 +8,14 @@ class acp(Variable):
     documentation = "Affordable Connectivity Program amount"
     definition_period = YEAR
     unit = USD
+    defined_for = "is_acp_eligible"
     reference = "https://uscode.house.gov/view.xhtml?req=granuleid:USC-prelim-title47-section1752&edition=prelim"
 
     def formula(spm_unit, period, parameters):
-        eligible = spm_unit("is_acp_eligible", period)
         broadband_cost = spm_unit("broadband_cost_after_lifeline", period)
         tribal = spm_unit.household("is_on_tribal_land", period)
-        amounts = parameters(period).gov.fcc.acp.amount
+        p = parameters(period).gov.fcc.acp
         max_amount = (
-            where(tribal, amounts.tribal, amounts.standard) * MONTHS_IN_YEAR
+            where(tribal, p.amount.tribal, p.amount.standard) * MONTHS_IN_YEAR
         )
-        amount_if_eligible = min_(max_amount, broadband_cost)
-        return where(eligible, amount_if_eligible, 0)
+        return min_(max_amount, broadband_cost)

policyengine_us/variables/gov/fcc/ebb/ebb.py

@@ -8,14 +8,13 @@ class ebb(Variable):
     documentation = "Emergency Broadband Benefit amount"
     definition_period = YEAR
     unit = USD
+    defined_for = "is_ebb_eligible"
 
     def formula(spm_unit, period, parameters):
-        eligible = spm_unit("is_ebb_eligible", period)
         broadband_cost = spm_unit("broadband_cost_after_lifeline", period)
         tribal = spm_unit.household("is_on_tribal_land", period)
-        amounts = parameters(period).gov.fcc.ebb.amount
+        p = parameters(period).gov.fcc.ebb
         max_amount = (
-            where(tribal, amounts.tribal, amounts.standard) * MONTHS_IN_YEAR
+            where(tribal, p.amount.tribal, p.amount.standard) * MONTHS_IN_YEAR
         )
-        amount_if_eligible = min_(max_amount, broadband_cost)
-        return where(eligible, amount_if_eligible, 0)
+        return min_(max_amount, broadband_cost)

policyengine_us/variables/gov/fcc/lifeline/is_lifeline_eligible.py

@@ -21,10 +21,9 @@ class is_lifeline_eligible(Variable):
         )
         categorically_eligible = np.where(
             is_on_tribal_land,
-            np.any(tribal_lifeline_programs),
-            np.any(non_tribal_lifeline_programs),
+            tribal_lifeline_programs > 0,
+            non_tribal_lifeline_programs > 0,
         )
-        fpg_ratio = spm_unit("fcc_fpg_ratio", period)
-        fpg_limit = p.fpg_limit
-        fpg_eligible = fpg_ratio <= fpg_limit
-        return categorically_eligible | fpg_eligible
+        # Use the new unified income eligibility variable
+        income_eligible = spm_unit("is_lifeline_income_eligible", period)
+        return categorically_eligible | income_eligible

policyengine_us/variables/gov/fcc/lifeline/is_lifeline_income_eligible.py

@@ -0,0 +1,35 @@
+from policyengine_us.model_api import *
+
+
+class is_lifeline_income_eligible(Variable):
+    value_type = bool
+    entity = SPMUnit
+    label = "Income-eligible for Lifeline"
+    documentation = (
+        "Meets income requirements for Lifeline (federal or state-expanded)"
+    )
+    definition_period = YEAR
+    reference = (
+        "https://www.law.cornell.edu/cfr/text/47/54.409",
+        "https://statutes.capitol.texas.gov/Docs/UT/htm/UT.55.htm#55.015",
+    )
+
+    def formula(spm_unit, period, parameters):
+        p = parameters(period).gov.fcc.lifeline
+        fpg_ratio = spm_unit("fcc_fpg_ratio", period)
+
+        # Some states expand eligibility beyond federal limit
+        state = spm_unit.household("state_code_str", period)
+        is_tx = state == "TX"
+
+        # Texas expands to 150% FPG per Texas Utilities Code § 55.015(d-1)
+        tx_p = parameters(period).gov.states.tx.uct.lifeline
+
+        # Use state-specific limit where applicable, otherwise federal (135%)
+        # Convert to float32 to match fpg_ratio dtype for comparison
+        # Without this, float32(1.35) > float64(1.35) due to precision differences
+        fpg_limit = where(is_tx, tx_p.fpg_limit, p.fpg_limit).astype(
+            np.float32
+        )
+
+        return fpg_ratio <= fpg_limit

policyengine_us/variables/gov/fcc/lifeline/lifeline.py

@@ -8,38 +8,40 @@ class lifeline(Variable):
     documentation = "Amount of Lifeline phone and broadband benefit"
     definition_period = YEAR
     unit = USD
+    defined_for = "is_lifeline_eligible"
     reference = "https://www.law.cornell.edu/cfr/text/47/54.403"
 
     def formula(spm_unit, period, parameters):
         # NB: Only one Lifeline benefit is available per SPM unit, per:
         # https://www.law.cornell.edu/cfr/text/47/54.409#c
-        amounts = parameters(period).gov.fcc.lifeline.amount
+        p = parameters(period).gov
+        base_amount = p.fcc.lifeline.amount.standard
         household = spm_unit.household
         is_rural_tribal = and_(
             household, period, ["is_rural", "is_on_tribal_land"]
         )
-        base_amount = amounts.standard
-        # CA and OR provide separate maximum lifeline benefit amount
-        state_code = spm_unit.household("state_code_str", period)
+        state_code = household("state_code_str", period)
 
-        p_ca = parameters(period).gov.states.ca.fcc.lifeline
-        if p_ca.in_effect:
-            ca_amount = p_ca.max_amount
-            in_ca = state_code == "CA"
-            base_amount = where(in_ca, ca_amount, base_amount)
+        # Check for state-specific Lifeline programs
+        STATES_WITH_LIFELINE = ["ca", "or"]
+        for state in STATES_WITH_LIFELINE:
+            state_params = p.states[state].fcc.lifeline
+            if hasattr(state_params, "in_effect") and state_params.in_effect:
+                base_amount = where(
+                    state_code == state.upper(),
+                    state_params.max_amount,
+                    base_amount,
+                )
 
-        p_or = parameters(period).gov.states["or"].fcc.lifeline
-        if p_or.in_effect:
-            or_amount = p_or.max_amount
-            in_or = state_code == "OR"
-            base_amount = where(in_or, or_amount, base_amount)
-
-        max_amount = (
-            base_amount + is_rural_tribal * amounts.rural_tribal_supplement
-        ) * MONTHS_IN_YEAR
+        federal_monthly_amount = (
+            base_amount
+            + is_rural_tribal * p.fcc.lifeline.amount.rural_tribal_supplement
+        )
+        # Get TX supplement for the specific month (now properly defined as MONTH period)
+        tx_supplement = spm_unit("tx_lifeline_supplement", period.first_month)
+        total_monthly_amount = federal_monthly_amount + tx_supplement
+        max_amount = total_monthly_amount * MONTHS_IN_YEAR
         phone_broadband_cost = add(
             spm_unit, period, ["phone_cost", "broadband_cost"]
         )
-        amount_if_eligible = min_(phone_broadband_cost, max_amount)
-        eligible = spm_unit("is_lifeline_eligible", period)
-        return eligible * amount_if_eligible
+        return min_(phone_broadband_cost, max_amount)

policyengine_us/variables/gov/hhs/head_start/early_head_start.py

@@ -4,6 +4,18 @@ from policyengine_us.model_api import *
 class early_head_start(Variable):
     value_type = float
     entity = Person
-    label = "Amount of Early Head Start benefit"
+    label = "Early Head Start"
+    unit = USD
     definition_period = YEAR
     defined_for = "is_early_head_start_eligible"
+    reference = "https://headstart.gov/program-data/article/head-start-program-facts-fiscal-year-2022"
+
+    def formula(person, period, parameters):
+        p = parameters(period).gov.hhs.head_start.early_head_start
+        state = person.household("state_code_str", period)
+        spending = p.spending[state]
+        enrollment = p.enrollment[state]
+        mask = enrollment > 0
+        result = np.zeros_like(p.spending[state])
+        result[mask] = spending[mask] / enrollment[mask]
+        return result

policyengine_us/variables/gov/hhs/head_start/head_start.py

@@ -4,6 +4,18 @@ from policyengine_us.model_api import *
 class head_start(Variable):
     value_type = float
     entity = Person
-    label = "Amount of Head Start benefit"
+    label = "Head Start"
+    unit = USD
     definition_period = YEAR
     defined_for = "is_head_start_eligible"
+    reference = "https://headstart.gov/program-data/article/head-start-program-facts-fiscal-year-2022"
+
+    def formula(person, period, parameters):
+        p = parameters(period).gov.hhs.head_start
+        state = person.household("state_code_str", period)
+        spending = p.spending[state]
+        enrollment = p.enrollment[state]
+        mask = enrollment > 0
+        result = np.zeros_like(p.spending[state])
+        result[mask] = spending[mask] / enrollment[mask]
+        return result

policyengine_us/variables/gov/hhs/head_start/is_head_start_categorically_eligible.py

@@ -12,7 +12,5 @@ class is_head_start_categorically_eligible(Variable):
     )
 
     def formula(person, period, parameters):
-        tax_unit = person.tax_unit
         p = parameters(period).gov.hhs.head_start
-        programs = add(tax_unit, period, p.categorical_eligibility)
-        return np.any(programs)
+        return add(person.tax_unit, period, p.categorical_eligibility) > 0

policyengine_us/variables/gov/hhs/medicaid/costs/medicaid_cost_if_enrolled.py

@@ -0,0 +1,86 @@
+from policyengine_us.model_api import *
+from policyengine_us.variables.gov.hhs.medicaid.costs.medicaid_group import (
+    MedicaidGroup,
+)
+
+
+class medicaid_cost_if_enrolled(Variable):
+    value_type = float
+    entity = Person
+    label = "Per capita Medicaid cost by eligibility group & state"
+    unit = USD
+    definition_period = YEAR
+    defined_for = "is_medicaid_eligible"
+
+    def formula(person, period, parameters):
+        state = person.household("state_code", period)
+        group = person("medicaid_group", period)
+
+        p = parameters(period).calibration.gov.hhs.medicaid
+
+        # Handle each group type separately
+        is_aged_disabled = group == MedicaidGroup.AGED_DISABLED
+        is_child = group == MedicaidGroup.CHILD
+        is_expansion_adult = group == MedicaidGroup.EXPANSION_ADULT
+        is_non_expansion_adult = group == MedicaidGroup.NON_EXPANSION_ADULT
+
+        # Calculate spend and enrollment for each group
+        aged_spend = p.spending.by_eligibility_group.aged[state]
+        disabled_spend = p.spending.by_eligibility_group.disabled[state]
+        child_spend = p.spending.by_eligibility_group.child[state]
+        expansion_adult_spend = (
+            p.spending.by_eligibility_group.expansion_adults[state]
+        )
+        non_expansion_adult_spend = (
+            p.spending.by_eligibility_group.non_expansion_adults[state]
+        )
+
+        aged_enroll = p.enrollment.aged[state]
+        disabled_enroll = p.enrollment.disabled[state]
+        child_enroll = p.enrollment.child[state]
+        expansion_adult_enroll = p.enrollment.expansion_adults[state]
+        non_expansion_adult_enroll = p.enrollment.non_expansion_adults[state]
+
+        # Combine aged and disabled for AGED_DISABLED group
+        aged_disabled_spend = aged_spend + disabled_spend
+        aged_disabled_enroll = aged_enroll + disabled_enroll
+
+        # Select the right values based on group
+        spend = select(
+            [
+                is_aged_disabled,
+                is_child,
+                is_expansion_adult,
+                is_non_expansion_adult,
+            ],
+            [
+                aged_disabled_spend,
+                child_spend,
+                expansion_adult_spend,
+                non_expansion_adult_spend,
+            ],
+            default=0,
+        )
+
+        enroll = select(
+            [
+                is_aged_disabled,
+                is_child,
+                is_expansion_adult,
+                is_non_expansion_adult,
+            ],
+            [
+                aged_disabled_enroll,
+                child_enroll,
+                expansion_adult_enroll,
+                non_expansion_adult_enroll,
+            ],
+            default=0,
+        )
+
+        # Avoid divide‑by‑zero in non‑expansion states by assigning national average.
+        per_capita = p.totals.per_capita[group]
+        mask = enroll > 0
+        per_capita[mask] = spend[mask] / enroll[mask]
+
+        return per_capita

policyengine_us/variables/gov/hhs/medicaid/costs/medicaid_group.py

@@ -12,10 +12,10 @@ class MedicaidGroup(Enum):
 class medicaid_group(Variable):
     """Maps fine-grained Medicaid categories to broader spending groups
     Precedence order (highest → lowest):
-    1. Disabled / SSI / medically‑needy → AGED_DISABLED
+    1. Disabled / SSI / medically-needy → AGED_DISABLED
     2. Pregnant                       → NON_EXPANSION_ADULT
     3. Parent                         → NON_EXPANSION_ADULT
-    4. Young adult (19–20)            → NON_EXPANSION_ADULT
+    4. Young adult (19-20)            → NON_EXPANSION_ADULT
     5. Expansion adult                → EXPANSION_ADULT
     6. Any child category             → CHILD
     """

policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/is_optional_senior_or_disabled_income_eligible.py

@@ -15,10 +15,12 @@ class is_optional_senior_or_disabled_income_eligible(Variable):
     reference = "https://www.law.cornell.edu/uscode/text/42/1396a#m"
 
     def formula(person, period, parameters):
-        # income & assets
-        personal_income = person("ssi_countable_income", period)  # $/year
+        # income
+        personal_income = person("ssi_countable_income", period)
         tax_unit = person.tax_unit
         income = tax_unit.sum(personal_income)
+        # TODO: Each state may has its own way of calculating countable income. Not necessary follow the SSA rule.
+        # Add countable income on state level, then consolidate them with this file.
 
         #  Flags & state info
         is_joint = tax_unit("tax_unit_is_joint", period)

policyengine_us/variables/gov/hhs/medicaid/eligibility/categories/medicaid_category.py

@@ -11,6 +11,7 @@ class MedicaidCategory(Enum):
     PARENT = "Parent"
     PREGNANT = "Pregnant"
     SSI_RECIPIENT = "SSI recipient"
+    SENIOR_OR_DISABLED = " Senior or disabled"
     NONE = "None"
 
 
@@ -36,6 +37,7 @@ class medicaid_category(Variable):
             is_parent_for_medicaid=MedicaidCategory.PARENT,
             is_pregnant_for_medicaid=MedicaidCategory.PREGNANT,
             is_ssi_recipient_for_medicaid=MedicaidCategory.SSI_RECIPIENT,
+            is_optional_senior_or_disabled_for_medicaid=MedicaidCategory.SENIOR_OR_DISABLED,
         )
 
         # Ensure parametric reforms to the list of categories prevent those

policyengine_us/variables/gov/hhs/medicaid/eligibility/is_medicaid_eligible.py

@@ -14,17 +14,20 @@ class is_medicaid_eligible(Variable):
     def formula(person, period, parameters):
         category = person("medicaid_category", period)
         categorically_eligible = category != category.possible_values.NONE
-        istatus = person("immigration_status", period)
-        undocumented = istatus == istatus.possible_values.UNDOCUMENTED
-        state = person.household("state_code_str", period)
-        p = parameters(period).gov.hhs.medicaid.eligibility
-        state_covers_undocumented = p.undocumented_immigrant[state].astype(
-            bool
-        )
-        immigration_status_eligible = (
-            ~undocumented | undocumented & state_covers_undocumented
+        immigration_status_eligible = person(
+            "is_medicaid_immigration_status_eligible", period
         )
         ca_ffyp_eligible = person("ca_ffyp_eligible", period)
+        p = parameters(period).gov.hhs.medicaid.eligibility
+        if p.work_requirements.applies:
+            work_requirement_eligible = person(
+                "medicaid_work_requirement_eligible", period
+            )
+            return (
+                categorically_eligible
+                & immigration_status_eligible
+                & work_requirement_eligible
+            ) | ca_ffyp_eligible
         return (
             categorically_eligible & immigration_status_eligible
         ) | ca_ffyp_eligible

policyengine_us/variables/gov/hhs/medicaid/eligibility/is_medicaid_immigration_status_eligible.py

@@ -0,0 +1,44 @@
+from policyengine_us.model_api import *
+
+
+class is_medicaid_immigration_status_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Person is eligible for Medicaid due to immigration status"
+    definition_period = YEAR
+    reference = [
+        "https://www.law.cornell.edu/uscode/text/42/1396b#v",
+        "https://www.law.cornell.edu/uscode/text/8/1641",
+        "https://www.kff.org/racial-equity-and-health-policy/fact-sheet/key-facts-on-health-coverage-of-immigrants/",
+    ]
+
+    def formula(person, period, parameters):
+        p = parameters(period).gov.hhs.medicaid.eligibility
+        immigration_status = person("immigration_status", period)
+        immigration_status_str = immigration_status.decode_to_str()
+
+        # Check if immigration status is in the eligible list
+        eligible_immigration_status = np.isin(
+            immigration_status_str, p.eligible_immigration_statuses
+        )
+
+        # Special handling for undocumented immigrants in states that cover them
+        undocumented = (
+            immigration_status
+            == immigration_status.possible_values.UNDOCUMENTED
+        )
+        state = person.household("state_code_str", period)
+        state_covers_undocumented = p.undocumented_immigrant[state].astype(
+            bool
+        )
+        undocumented_eligible = undocumented & state_covers_undocumented
+
+        ca_eligible_regardless_of_immigration_status = person(
+            "is_ca_medicaid_immigration_status_eligible", period
+        )
+
+        return (
+            eligible_immigration_status
+            | undocumented_eligible
+            | ca_eligible_regardless_of_immigration_status
+        )

policyengine_us/variables/gov/hhs/medicaid/eligibility/medicaid_work_requirement_eligible.py

@@ -0,0 +1,57 @@
+from policyengine_us.model_api import *
+
+
+class medicaid_work_requirement_eligible(Variable):
+    value_type = bool
+    entity = Person
+    label = "Eligible person for Medicaid via work requirement"
+    definition_period = YEAR
+    reference = (
+        "https://www.congress.gov/bill/119th-congress/house-bill/1/text"
+    )
+
+    def formula(person, period, parameters):
+        p = parameters(period).gov.hhs.medicaid.eligibility.work_requirements
+        # Works no less than 80 hours p.680 (2)(A)
+        monthly_hours_worked = person("monthly_hours_worked", period)
+        meets_monthly_work_hours = (
+            monthly_hours_worked >= p.monthly_hours_threshold
+        )
+        # The individual is enrolled in an educational program at least half-time. p.680 (2)(D)
+        is_full_time_student = person("is_full_time_student", period)
+        # pregnant or postpartum medical assistance p.681 (3)(A)(i)(II)(bb)
+        is_pregnant = person("is_pregnant", period)
+        # Has attained age of 19 and is under 65 is require to work p.693 (bb)
+        age = person("age", period)
+        work_required_age = p.age_range.calc(age)
+        # parent, guardian, caretaker of a disabled person
+        is_dependent = person("is_tax_unit_dependent", period)
+        is_disabled = person("is_disabled", period)
+        has_disabled = person.tax_unit.any(is_dependent & is_disabled)
+        # veteran and is_permanently_and_totally_disabled p.694 (IV)
+        is_veteran = person("is_veteran", period)
+        is_permanently_and_totally_disabled = person(
+            "is_permanently_and_totally_disabled", period
+        )
+        eligible_veteran = is_veteran & is_permanently_and_totally_disabled
+        # blind or disabled or is_incapable_of_self_care p.694 (V)
+        is_blind = person("is_blind", period)
+        is_incapable_of_self_care = person("is_incapable_of_self_care", period)
+        eligible_disabled = is_blind | is_disabled | is_incapable_of_self_care
+        # parent, guardian, caretaker of a dependent child 13 years of age or under  p.694 (III)
+        child_age_eligible = age <= p.dependent_age_limit
+        has_eligible_dependent_child = person.tax_unit.any(
+            is_dependent & child_age_eligible
+        )
+        exempted_from_work = (
+            is_full_time_student
+            | is_pregnant
+            | has_disabled
+            | eligible_veteran
+            | eligible_disabled
+        )
+        meets_base_requirement = meets_monthly_work_hours | exempted_from_work
+        meets_conditions = (
+            meets_base_requirement | has_eligible_dependent_child
+        )
+        return where(work_required_age, meets_conditions, True)

policyengine_us/variables/gov/hhs/medicaid/medicaid.py

@@ -8,8 +8,4 @@ class medicaid(Variable):
     unit = USD
     definition_period = YEAR
     reference = "https://www.law.cornell.edu/uscode/text/42/1396a"
-
-    def formula(person, period, parameters):
-        eligible = person("is_medicaid_eligible", period)
-        benefit = person("medicaid_benefit_value", period)
-        return eligible * benefit
+    adds = ["medicaid_cost"]

policyengine_us/variables/gov/hhs/medicaid/medicaid_cost.py

@@ -0,0 +1,12 @@
+from policyengine_us.model_api import *
+
+
+class medicaid_cost(Variable):
+    value_type = float
+    entity = Person
+    label = "Medicaid_cost"
+    unit = USD
+    definition_period = YEAR
+    reference = "https://www.law.cornell.edu/uscode/text/42/1396a"
+    defined_for = "medicaid_enrolled"
+    adds = ["medicaid_cost_if_enrolled"]