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

policyengine_us/reforms/ctc/ctc_minimum_refundable_amount.py

@@ -0,0 +1,143 @@
+from policyengine_us.model_api import *
+from policyengine_core.periods import period as period_
+from policyengine_core.periods import instant
+
+
+def create_ctc_minimum_refundable_amount() -> Reform:
+    class ctc_minimum_refundable_amount(Variable):
+        value_type = float
+        entity = Person
+        label = "CTC minimum refundable amount"
+        unit = USD
+        defined_for = "ctc_qualifying_child"
+        documentation = "Minimum refundable amount per child, exempt from phase-in but subject to phase-out."
+        definition_period = YEAR
+
+        def formula(person, period, parameters):
+            p = parameters(period).gov.contrib.ctc.minimum_refundable
+
+            age = person("age", period)
+
+            return p.amount.calc(age)
+
+    class refundable_ctc(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "refundable CTC"
+        unit = USD
+        documentation = (
+            "The portion of the Child Tax Credit that is refundable."
+        )
+        definition_period = YEAR
+        reference = "https://www.law.cornell.edu/uscode/text/26/24#d"
+
+        def formula(tax_unit, period, parameters):
+            # This line corresponds to "the credit which would be allowed under this section [the CTC section]"
+            # without regard to this subsection [the refundability section] and the limitation under
+            # section 26(a) [the section that limits the amount of the non-refundable CTC to tax liability].
+            # This is the full CTC. This is then limited to the maximum refundable amount per child as per the
+            # TCJA provision.
+
+            maximum_amount = tax_unit("ctc_refundable_maximum", period)
+            total_ctc = tax_unit("ctc", period)
+
+            maximum_refundable_ctc = min_(maximum_amount, total_ctc)
+            minimum_refundable_ctc = add(
+                tax_unit, period, ["ctc_minimum_refundable_amount"]
+            )
+            phase_in = tax_unit("ctc_phase_in", period)
+
+            phase_in_with_minimum = phase_in + minimum_refundable_ctc
+            ctc_capped_by_increased_tax = min_(
+                total_ctc, phase_in_with_minimum
+            )
+
+            return min_(maximum_refundable_ctc, ctc_capped_by_increased_tax)
+
+    class ctc_refundable_maximum(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Maximum refundable CTC"
+        unit = USD
+        documentation = "The maximum refundable CTC for this person."
+        definition_period = YEAR
+        reference = (
+            "https://www.law.cornell.edu/uscode/text/26/24#a",
+            "https://www.law.cornell.edu/uscode/text/26/24#h",
+            "https://www.law.cornell.edu/uscode/text/26/24#i",
+            "https://www.irs.gov/pub/irs-prior/f1040--2021.pdf",
+            "https://www.irs.gov/pub/irs-prior/f1040s8--2021.pdf",
+        )
+
+        def formula(tax_unit, period, parameters):
+            person = tax_unit.members
+            # Use either normal or ARPA CTC maximums.
+            individual_max = person("ctc_child_individual_maximum", period)
+            arpa_max = person("ctc_child_individual_maximum_arpa", period)
+            child_amount = tax_unit.sum(individual_max + arpa_max)
+            ctc = parameters(period).gov.irs.credits.ctc
+            qualifying_children = tax_unit("ctc_qualifying_children", period)
+            refundable_max = (
+                ctc.refundable.individual_max * qualifying_children
+            )
+            return min_(child_amount, refundable_max)
+
+    class non_refundable_ctc(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "non-refundable CTC"
+        unit = USD
+        documentation = (
+            "The portion of the Child Tax Credit that is not refundable."
+        )
+        definition_period = YEAR
+
+        def formula(tax_unit, period, parameters):
+            return 0
+
+    class ctc_value(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "CTC value"
+        unit = USD
+        documentation = "Actual value of the Child Tax Credit"
+        definition_period = YEAR
+
+        adds = ["refundable_ctc"]
+
+    class reform(Reform):
+        def apply(self):
+            self.update_variable(ctc_minimum_refundable_amount)
+            self.update_variable(refundable_ctc)
+            self.update_variable(ctc_value)
+            self.update_variable(ctc_refundable_maximum)
+            self.update_variable(non_refundable_ctc)
+
+    return reform
+
+
+def create_ctc_minimum_refundable_amount_reform(
+    parameters, period, bypass: bool = False
+):
+    if bypass:
+        return create_ctc_minimum_refundable_amount()
+
+    p = parameters.gov.contrib.ctc.minimum_refundable
+
+    reform_active = False
+    current_period = period_(period)
+    for i in range(5):
+        if p(current_period).in_effect:
+            reform_active = True
+            break
+        current_period = current_period.offset(1, "year")
+
+    if reform_active:
+        return create_ctc_minimum_refundable_amount()
+    else:
+        return None
+
+
+ctc_minimum_refundable_amount = create_ctc_minimum_refundable_amount_reform(
+    None, None, bypass=True
+)

policyengine_us/reforms/ctc/ctc_per_child_phase_in.py

@@ -0,0 +1,58 @@
+from policyengine_us.model_api import *
+from policyengine_core.periods import period as period_
+from policyengine_core.periods import instant
+
+
+def create_ctc_per_child_phase_in() -> Reform:
+    class ctc_phase_in_relevant_earnings(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Relevant earnings for the CTC phase-in"
+        unit = USD
+        definition_period = YEAR
+        reference = "https://www.law.cornell.edu/uscode/text/26/24#d"
+
+        def formula(tax_unit, period, parameters):
+
+            ctc = parameters(period).gov.irs.credits.ctc
+
+            earnings = tax_unit("tax_unit_earned_income", period)
+            earnings_over_threshold = max_(
+                0, earnings - ctc.refundable.phase_in.threshold
+            )
+            qualifying_children = tax_unit("ctc_qualifying_children", period)
+            phase_in_rate = ctc.refundable.phase_in.rate * qualifying_children
+            return earnings_over_threshold * phase_in_rate
+
+    class reform(Reform):
+        def apply(self):
+            self.update_variable(ctc_phase_in_relevant_earnings)
+
+    return reform
+
+
+def create_ctc_per_child_phase_in_reform(
+    parameters, period, bypass: bool = False
+):
+    if bypass:
+        return create_ctc_per_child_phase_in()
+
+    p = parameters.gov.contrib.ctc.per_child_phase_in
+
+    reform_active = False
+    current_period = period_(period)
+    for i in range(5):
+        if p(current_period).in_effect:
+            reform_active = True
+            break
+        current_period = current_period.offset(1, "year")
+
+    if reform_active:
+        return create_ctc_per_child_phase_in()
+    else:
+        return None
+
+
+ctc_per_child_phase_in = create_ctc_per_child_phase_in_reform(
+    None, None, bypass=True
+)

policyengine_us/reforms/ctc/ctc_per_child_phase_out.py

@@ -0,0 +1,123 @@
+from policyengine_us.model_api import *
+import numpy as np
+from policyengine_core.periods import period as period_
+from policyengine_core.periods import instant
+import numpy as np
+
+
+def create_ctc_per_child_phase_out() -> Reform:
+    class ctc_phase_out(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "CTC reduction from income"
+        unit = USD
+        documentation = "Reduction of the total CTC due to income."
+        definition_period = YEAR
+
+        def formula(tax_unit, period, parameters):
+            # TCJA's phase-out changes are purely parametric so don't require
+            # structural reform.
+
+            # The ARPA CTC has two phase-outs: the original, and a new phase-out
+            # applying before and only to the increase in the maximum CTC under ARPA.
+
+            # Start with the normal phase-out.
+            income = tax_unit("adjusted_gross_income", period)
+            p = parameters(period).gov.irs.credits.ctc.phase_out
+            phase_out_threshold = tax_unit("ctc_phase_out_threshold", period)
+            qualifying_children = tax_unit("ctc_qualifying_children", period)
+            excess = max_(0, income - phase_out_threshold)
+            increments = np.ceil(excess / p.increment)
+            reduction_amount = p.amount * qualifying_children
+            base_reduction_uncapped = increments * reduction_amount
+
+            # Option to avoid overlap between regular and ARPA phase-outs
+            p_contrib = parameters(period).gov.contrib.ctc.per_child_phase_out
+            if p_contrib.avoid_overlap:
+                # Sequential application: ARPA phase-out reduces ARPA addition only,
+                # then regular phase-out applies to base + remaining ARPA
+                # NOTE: ctc_arpa_addition already has ARPA phase-out subtracted,
+                # so we only need to return the regular phase-out here
+                arpa_addition = tax_unit("ctc_arpa_addition", period)
+                base_ctc = tax_unit("ctc_maximum", period)
+
+                # Regular phase-out applies to base CTC + remaining ARPA addition
+                ctc_before_regular = base_ctc + arpa_addition
+                base_reduction = min_(
+                    base_reduction_uncapped, ctc_before_regular
+                )
+
+                # Return only the regular phase-out
+                # ARPA phase-out is already applied in ctc_arpa_addition
+                return base_reduction
+            else:
+                return base_reduction_uncapped
+
+    class ctc_arpa_uncapped_phase_out(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Uncapped phase-out of ARPA CTC increase"
+        unit = USD
+        definition_period = YEAR
+
+        def formula(tax_unit, period, parameters):
+            # Logic sequence follows the form, which is clearer than the IRC.
+            p = parameters(period).gov.irs.credits.ctc.phase_out.arpa
+            # defined_for didn't work.
+            if not p.in_effect:
+                return 0
+            # The ARPA CTC has two phase-outs: the original, and a new phase-out
+            # applying before and only to the increase in the maximum CTC under ARPA.
+            # Calculate the income used to assess the new phase-out.
+            arpa_threshold = tax_unit("ctc_arpa_phase_out_threshold", period)
+            agi = tax_unit("adjusted_gross_income", period)
+
+            # Check if we should cap ARPA phase-out to avoid overlap with regular phase-out
+            p_contrib = parameters(period).gov.contrib.ctc.per_child_phase_out
+            if p_contrib.avoid_overlap:
+                # Cap the ARPA phase-out at the regular phase-out threshold
+                # so ARPA only applies to income between its threshold and the regular threshold
+                regular_threshold = tax_unit("ctc_phase_out_threshold", period)
+                capped_income = min_(agi, regular_threshold)
+                excess = max_(0, capped_income - arpa_threshold)
+            else:
+                excess = max_(0, agi - arpa_threshold)
+
+            increments = np.ceil(excess / p.increment)
+            qualifying_children = tax_unit("ctc_qualifying_children", period)
+            reduction_amount = p.amount * qualifying_children
+            return increments * reduction_amount
+
+    class reform(Reform):
+        def apply(self):
+            self.update_variable(ctc_phase_out)
+            self.update_variable(ctc_arpa_uncapped_phase_out)
+
+    return reform
+
+
+def create_ctc_per_child_phase_out_reform(
+    parameters, period, bypass: bool = False
+):
+    if bypass:
+        return create_ctc_per_child_phase_out()
+
+    p = parameters.gov.contrib.ctc.per_child_phase_out
+
+    reform_active = False
+    current_period = period_(period)
+    for i in range(5):
+        if p(current_period).in_effect:
+            reform_active = True
+            break
+        current_period = current_period.offset(1, "year")
+
+    if reform_active:
+        return create_ctc_per_child_phase_out()
+    else:
+        return None
+
+
+ctc_per_child_phase_out = create_ctc_per_child_phase_out_reform(
+    None, None, bypass=True
+)

policyengine_us/reforms/harris/capital_gains/harris_capital_gains.py

@@ -29,9 +29,9 @@ def create_harris_capital_gains() -> Reform:
 
             filing_status = tax_unit("filing_status", period)
 
-            first_threshold = p_ref.brackets.thresholds["1"][filing_status]
-            second_threshold = p_ref.brackets.thresholds["2"][filing_status]
-            third_threshold = p_ref.brackets.thresholds["3"][filing_status]
+            first_threshold = p_ref.thresholds["1"][filing_status]
+            second_threshold = p_ref.thresholds["2"][filing_status]
+            third_threshold = p_ref.thresholds["3"][filing_status]
 
             income_ordinarily_under_second_rate = clip(
                 taxable_income, 0, first_threshold
@@ -82,10 +82,10 @@ def create_harris_capital_gains() -> Reform:
             )
 
             main_cg_tax = (
-                cg_in_first_bracket * p_ref.brackets.rates["1"]
-                + cg_in_second_bracket * p_ref.brackets.rates["2"]
-                + cg_in_third_bracket * p_ref.brackets.rates["3"]
-                + cg_in_fourth_bracket * p_ref.brackets.rates["4"]
+                cg_in_first_bracket * p_ref.rates["1"]
+                + cg_in_second_bracket * p_ref.rates["2"]
+                + cg_in_third_bracket * p_ref.rates["3"]
+                + cg_in_fourth_bracket * p_ref.rates["4"]
             )
 
             unrecaptured_s_1250_gain = tax_unit(

policyengine_us/reforms/reforms.py

@@ -29,6 +29,9 @@ from .harris.rent_relief_act.rent_relief_tax_credit import (
 from .congress.tlaib import (
     create_end_child_poverty_act_reform,
 )
+from .congress.tlaib.economic_dignity_for_all_agenda import (
+    create_end_child_poverty_act_reform as create_edaa_end_child_poverty_act_reform,
+)
 from .congress.tlaib.boost import (
     create_boost_middle_class_tax_credit_reform,
 )
@@ -59,6 +62,9 @@ from .state_dependent_exemptions import (
 from .ctc import (
     create_ctc_older_child_supplement_reform,
     create_ctc_additional_bracket_reform,
+    create_ctc_per_child_phase_in_reform,
+    create_ctc_per_child_phase_out_reform,
+    create_ctc_minimum_refundable_amount_reform,
 )
 from .snap import (
     create_abolish_snap_deductions_reform,
@@ -95,6 +101,9 @@ from .reconciliation import (
 from .states.mi.surtax import (
     create_mi_surtax_reform,
 )
+from .states.ut import (
+    create_ut_refundable_eitc_reform,
+)
 from .additional_tax_bracket import (
     create_additional_tax_bracket_reform,
 )
@@ -105,6 +114,15 @@ from .crfb import (
     create_non_refundable_ss_credit_reform,
     create_senior_deduction_extension_reform,
 )
+from .states.ri.ctc.ri_ctc_reform import create_ri_ctc_reform
+from .states.ri.exemption.ri_exemption_reform import (
+    create_ri_exemption_reform_fn,
+)
+from .aca import (
+    create_aca_ptc_additional_bracket_reform,
+    create_aca_ptc_simplified_bracket_reform,
+)
+
 
 from policyengine_core.reforms import Reform
 import warnings
@@ -156,6 +174,9 @@ def create_structural_reforms_from_parameters(parameters, period):
     end_child_poverty_act = create_end_child_poverty_act_reform(
         parameters, period
     )
+    edaa_end_child_poverty_act = create_edaa_end_child_poverty_act_reform(
+        parameters, period
+    )
     boost_middle_class_tax_credit = (
         create_boost_middle_class_tax_credit_reform(parameters, period)
     )
@@ -231,10 +252,28 @@ def create_structural_reforms_from_parameters(parameters, period):
         parameters, period
     )
     mi_surtax = create_mi_surtax_reform(parameters, period)
+    ut_refundable_eitc = create_ut_refundable_eitc_reform(parameters, period)
 
     american_worker_rebate_act = create_american_worker_rebate_act_reform(
         parameters, period
     )
+    ctc_per_child_phase_out = create_ctc_per_child_phase_out_reform(
+        parameters, period
+    )
+    ctc_per_child_phase_in = create_ctc_per_child_phase_in_reform(
+        parameters, period
+    )
+    ctc_minimum_refundable_amount = (
+        create_ctc_minimum_refundable_amount_reform(parameters, period)
+    )
+    ri_ctc = create_ri_ctc_reform(parameters, period)
+    ri_exemption = create_ri_exemption_reform_fn(parameters, period)
+    aca_ptc_additional_bracket = create_aca_ptc_additional_bracket_reform(
+        parameters, period
+    )
+    aca_ptc_simplified_bracket = create_aca_ptc_simplified_bracket_reform(
+        parameters, period
+    )
 
     reforms = [
         afa_reform,
@@ -254,6 +293,7 @@ def create_structural_reforms_from_parameters(parameters, period):
         middle_class_tax_credit,
         rent_relief_tax_credit,
         end_child_poverty_act,
+        edaa_end_child_poverty_act,
         boost_middle_class_tax_credit,
         mn_walz_hf1938,
         or_rebate_state_tax_exempt,
@@ -280,8 +320,16 @@ def create_structural_reforms_from_parameters(parameters, period):
         reconciled_ssn_for_llc_and_aoc,
         ctc_additional_bracket,
         mi_surtax,
+        ut_refundable_eitc,
         additional_tax_bracket,
         american_worker_rebate_act,
+        ctc_per_child_phase_out,
+        ctc_per_child_phase_in,
+        ctc_minimum_refundable_amount,
+        ri_ctc,
+        ri_exemption,
+        aca_ptc_additional_bracket,
+        aca_ptc_simplified_bracket,
     ]
     reforms = tuple(filter(lambda x: x is not None, reforms))
 

policyengine_us/reforms/states/ri/__init__.py

@@ -0,0 +1,2 @@
+from .ctc import create_ri_ctc_reform
+from .exemption import create_ri_exemption_reform_fn

policyengine_us/reforms/states/ri/ctc/__init__.py

@@ -0,0 +1 @@
+from .ri_ctc_reform import create_ri_ctc_reform

policyengine_us/reforms/states/ri/ctc/ri_ctc_reform.py

@@ -0,0 +1,207 @@
+from policyengine_us.model_api import *
+from policyengine_core.periods import period as period_
+from policyengine_core.periods import instant
+
+
+def create_ri_ctc() -> Reform:
+    class ri_ctc_eligible_children(Variable):
+        value_type = int
+        entity = TaxUnit
+        label = "Rhode Island CTC eligible children count"
+        definition_period = YEAR
+        defined_for = StateCode.RI
+
+        def formula(tax_unit, period, parameters):
+            p = parameters(period).gov.contrib.states.ri.ctc
+
+            person = tax_unit.members
+            age = person("age", period)
+            is_dependent = person("is_tax_unit_dependent", period)
+
+            # Check age eligibility
+            meets_age = age < p.age_limit
+
+            eligible = is_dependent & meets_age
+            return tax_unit.sum(eligible)
+
+    class ri_ctc_young_child_boost(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Rhode Island CTC young child boost"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.RI
+
+        def formula(tax_unit, period, parameters):
+            p = parameters(period).gov.contrib.states.ri.ctc
+
+            person = tax_unit.members
+            age = person("age", period)
+            is_dependent = person("is_tax_unit_dependent", period)
+
+            # Check both general CTC eligibility and young child age limit
+            meets_age = age < p.age_limit
+            meets_young_child_age = age < p.young_child_boost.age_limit
+
+            eligible_young_children = tax_unit.sum(
+                is_dependent & meets_age & meets_young_child_age
+            )
+            return eligible_young_children * p.young_child_boost.amount
+
+    class ri_ctc_maximum(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Rhode Island CTC maximum amount before phaseout"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.RI
+
+        def formula(tax_unit, period, parameters):
+            p = parameters(period).gov.contrib.states.ri.ctc
+
+            # Base credit for all eligible children
+            eligible_children = tax_unit("ri_ctc_eligible_children", period)
+            base_credit = eligible_children * p.amount
+
+            # Young child boost
+            young_child_boost = tax_unit("ri_ctc_young_child_boost", period)
+
+            return base_credit + young_child_boost
+
+    class ri_ctc_phaseout(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Rhode Island CTC phaseout amount"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.RI
+
+        def formula(tax_unit, period, parameters):
+            p = parameters(period).gov.contrib.states.ri.ctc
+
+            filing_status = tax_unit("filing_status", period)
+            agi = tax_unit("ri_agi", period)
+
+            threshold = p.phaseout.threshold[filing_status]
+            excess_income = max_(agi - threshold, 0)
+            return excess_income * p.phaseout.rate
+
+    class ri_total_ctc(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Rhode Island Child Tax Credit"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.RI
+
+        def formula(tax_unit, period, parameters):
+            p = parameters(period).gov.contrib.states.ri.ctc
+
+            # Calculate maximum credit
+            maximum = tax_unit("ri_ctc_maximum", period)
+
+            # Apply phaseout
+            phaseout = tax_unit("ri_ctc_phaseout", period)
+
+            return max_(maximum - phaseout, 0)
+
+    class ri_refundable_ctc(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Rhode Island CTC refundable portion"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.RI
+
+        def formula(tax_unit, period, parameters):
+            p = parameters(period).gov.contrib.states.ri.ctc
+
+            total_credit = tax_unit("ri_total_ctc", period)
+
+            # The refundable portion is the minimum of the cap and total credit
+            # This ensures the refundable amount never exceeds the total credit
+            # - If cap = 0: credit is nonrefundable
+            # - If 0 < cap < total_credit: credit is partially refundable
+            # - If cap >= total_credit: credit is fully refundable
+            return min_(total_credit, p.refundability.cap)
+
+    class ri_non_refundable_ctc(Variable):
+        value_type = float
+        entity = TaxUnit
+        label = "Rhode Island CTC non-refundable portion"
+        unit = USD
+        definition_period = YEAR
+        defined_for = StateCode.RI
+
+        def formula(tax_unit, period, parameters):
+            p = parameters(period).gov.contrib.states.ri.ctc
+
+            total_credit = tax_unit("ri_total_ctc", period)
+            refundable_portion = tax_unit("ri_refundable_ctc", period)
+            return max_(total_credit - refundable_portion, 0)
+
+    def modify_parameters(parameters):
+        # Add ri_refundable_ctc to refundable credits list
+        refundable = parameters.gov.states.ri.tax.income.credits.refundable
+        current_refundable = refundable(instant("2025-01-01"))
+        if "ri_refundable_ctc" not in current_refundable:
+            new_refundable = list(current_refundable) + ["ri_refundable_ctc"]
+            refundable.update(
+                start=instant("2025-01-01"),
+                stop=instant("2100-12-31"),
+                value=new_refundable,
+            )
+
+        # Add ri_non_refundable_ctc to non-refundable credits list
+        non_refundable = (
+            parameters.gov.states.ri.tax.income.credits.non_refundable
+        )
+        current_non_refundable = non_refundable(instant("2025-01-01"))
+        if "ri_non_refundable_ctc" not in current_non_refundable:
+            new_non_refundable = list(current_non_refundable) + [
+                "ri_non_refundable_ctc"
+            ]
+            non_refundable.update(
+                start=instant("2025-01-01"),
+                stop=instant("2100-12-31"),
+                value=new_non_refundable,
+            )
+
+        return parameters
+
+    class reform(Reform):
+        def apply(self):
+            self.update_variable(ri_ctc_eligible_children)
+            self.update_variable(ri_ctc_young_child_boost)
+            self.update_variable(ri_ctc_maximum)
+            self.update_variable(ri_ctc_phaseout)
+            self.update_variable(ri_total_ctc)
+            self.update_variable(ri_refundable_ctc)
+            self.update_variable(ri_non_refundable_ctc)
+            self.modify_parameters(modify_parameters)
+
+    return reform
+
+
+def create_ri_ctc_reform(parameters, period, bypass: bool = False):
+    if bypass:
+        return create_ri_ctc()
+
+    p = parameters.gov.contrib.states.ri.ctc
+
+    reform_active = False
+    current_period = period_(period)
+
+    for i in range(5):
+        if p(current_period).in_effect:
+            reform_active = True
+            break
+        current_period = current_period.offset(1, "year")
+
+    if reform_active:
+        return create_ri_ctc()
+    else:
+        return None
+
+
+ri_ctc = create_ri_ctc_reform(None, None, bypass=True)

policyengine_us/reforms/states/ri/exemption/__init__.py

@@ -0,0 +1 @@
+from .ri_exemption_reform import create_ri_exemption_reform_fn