taxcalc 5.3.0__py3-none-any.whl → 6.1.0__py3-none-any.whl

taxcalc/puf_ratios.csv

@@ -1,26 +0,0 @@
-agi_bin,0,1,2,3,4,5,6,7,8,9,10,11,12,13,14,15,16,17,18
-INT2011,1.0259,0.5597,0.9448,0.9681,0.9728,0.9464,0.8390,0.8997,0.9713,0.9239,0.9342,0.9413,0.9497,0.9510,0.9693,0.9702,0.9569,1.0123,1.7014
-INT2012,0.7778,0.9454,0.8433,0.8152,0.7153,0.8101,0.7961,0.7940,0.8481,0.9063,0.9129,0.9183,1.0343,1.0435,1.0129,1.1436,1.0975,1.2339,1.3445
-INT2013,1.1325,0.7670,0.7821,0.7778,0.8935,0.8699,0.9558,0.9045,0.8342,0.8595,0.9746,1.0269,1.0499,1.0505,1.0891,0.9632,1.0449,0.9690,1.1443
-INT2014,0.9106,0.8669,0.8492,0.7738,0.8431,0.8802,0.9729,0.8840,0.8368,1.0109,0.8448,1.0532,1.0274,0.9291,1.0609,1.1524,1.0624,1.0728,1.0860
-INT2015,0.9813,0.9511,0.9323,0.9470,0.9543,0.9246,0.9368,0.9315,0.9463,0.9698,0.9887,1.0165,0.9966,0.9906,1.0241,0.9827,1.0221,1.1437,1.1671
-INT2016,0.9843,1.0086,1.0453,1.0319,1.0447,1.0342,1.0110,1.0028,1.0025,1.0174,0.9482,0.9531,0.9752,1.0131,1.0723,1.0130,1.0804,1.0810,0.9938
-INT2017,0.9932,0.9174,0.8978,0.8918,0.8944,0.9131,0.9215,0.9399,0.9611,0.9788,1.0156,1.0693,1.0312,0.9881,0.9354,0.9756,0.9565,1.0484,1.1942
-INT2018,0.9991,0.9744,0.9683,0.9673,0.9757,0.9725,0.9748,0.9779,0.9742,0.9969,0.9929,1.0038,1.0148,1.0067,1.0226,0.9898,1.0182,1.0909,0.9981
-INT2019,0.9979,0.9771,0.9763,0.9903,0.9793,0.9805,0.9769,0.9852,0.9826,0.9937,0.9934,1.0109,1.0020,1.0074,0.9985,1.0006,1.0253,1.0283,1.0196
-INT2020,1.0017,0.9799,0.9739,0.9756,0.9843,0.9849,0.9831,0.9833,0.9932,0.9965,0.9958,1.0114,1.0058,1.0047,1.0076,0.9991,1.0129,1.0113,1.0113
-INT2021,0.9959,0.9797,0.9776,0.9781,0.9836,0.9898,0.9883,0.9869,0.9920,0.9978,1.0043,0.9974,1.0066,1.0119,1.0049,1.0040,1.0303,1.0085,1.0022
-INT2022,1.0062,0.9815,0.9810,0.9783,0.9724,0.9820,0.9850,0.9893,0.9934,1.0049,1.0022,1.0050,1.0029,1.0042,1.0047,1.0044,1.0133,0.9990,1.0111
-INT2023,0.9983,0.9812,0.9761,0.9789,0.9891,0.9893,0.9852,1.0199,0.9942,0.9956,1.0022,1.0012,1.0023,1.0073,1.0006,1.0093,1.0214,1.0020,0.9943
-INT2024,1.0016,0.9843,0.9813,0.9791,0.9712,0.9789,0.9893,1.0100,0.9905,0.9984,0.9987,0.9971,1.0048,1.0077,1.0089,1.0075,1.0238,1.0148,1.0081
-INT2025,1.0086,0.9934,0.9772,0.9767,0.9834,0.9817,1.0012,0.9941,0.9935,1.0008,0.9990,0.9978,1.0051,1.0074,1.0142,1.0150,1.0238,0.9941,0.9912
-INT2026,1.0089,0.9843,0.9792,0.9796,0.9872,0.9904,0.9989,0.9909,0.9953,0.9939,0.9931,0.9932,1.0070,1.0142,1.0373,1.0250,1.0208,0.9992,0.9937
-INT2027,1.0115,0.9888,0.9839,0.9805,0.9888,0.9905,0.9824,0.9951,0.9905,0.9944,0.9993,0.9913,1.0073,1.0184,1.0175,1.0275,1.0259,0.9935,0.9946
-INT2028,1.0062,0.9977,0.9772,0.9829,0.9863,0.9878,1.0107,0.9957,0.9924,0.9954,0.9931,0.9921,1.0068,1.0177,1.0271,1.0221,1.0222,0.9960,0.9918
-INT2029,1.0101,0.9939,0.9780,0.9801,0.9824,0.9852,1.0025,0.9850,0.9945,0.9933,0.9934,0.9928,1.0033,1.0285,1.0278,1.0474,1.0236,1.0013,0.9924
-INT2030,1.0295,1.0010,0.9821,0.9840,0.9821,0.9917,0.9822,0.9859,0.9830,0.9890,0.9815,0.9922,1.0058,1.0359,1.0382,1.0449,1.0299,0.9947,0.9921
-INT2031,1.0280,1.0214,0.9858,0.9918,0.9829,0.9886,0.9858,0.9788,0.9910,0.9938,0.9791,0.9869,0.9950,1.0446,1.0442,1.0732,1.0287,1.0061,0.9932
-INT2032,1.0079,1.1009,0.9920,0.9811,0.9867,0.9849,0.9881,0.9740,0.9732,0.9791,0.9662,0.9835,0.9898,1.0786,1.0900,1.1373,1.0482,1.0099,0.9983
-INT2033,0.9352,0.8346,0.9707,0.9745,0.9896,0.9850,0.9878,1.0383,1.0313,1.0351,1.1156,1.0746,1.0377,0.8505,0.8247,0.7425,0.8974,1.0567,1.0930
-INT2034,1.0278,0.9998,0.9801,0.9808,0.9905,0.9879,0.9984,0.9804,0.9885,0.9931,0.9775,0.9841,1.0025,1.0381,1.0368,1.0580,1.0409,1.0028,0.9939
-INT2035,1.0241,1.0200,0.9891,0.9840,0.9837,0.9859,0.9886,0.9688,0.9850,0.9882,0.9774,0.9926,1.0011,1.0428,1.0542,1.0592,1.0396,0.9982,0.9940

taxcalc/tests/test_compare.py

@@ -1,330 +0,0 @@
-"""
-Compares Tax-Calculator PUF and CPS results with historical information.
-"""
-# CODING-STYLE CHECKS:
-# pycodestyle test_compare.py
-# pylint --disable=locally-disabled test_compare.py
-
-import os
-import pytest
-import numpy as np
-from taxcalc.policy import Policy
-from taxcalc.records import Records
-from taxcalc.calculator import Calculator
-from taxcalc.utils import add_income_table_row_variable, SOI_AGI_BINS
-
-
-# 2015 IRS-SOI amounts by AGI category are from "Table 3.3 All Returns: Tax
-# Liability, Tax Credits, and Tax Payments by Size of Adjusted Gross Income,
-# Tax Year 2015" which is available as a spreadsheet at this URL:
-# <https://www.irs.gov/statistics/soi-tax-stats-individual-
-#  statistical-tables-by-size-of-adjusted-gross-income>
-# The IRS-SOI amounts are from 19 rows in the spreadsheet numbered from
-# 11 (AGI under one dollar) through 29 (AGI $10M or more).
-# Dollar IRS-SOI amounts are expressed in billions of dollars and rounded
-# to the nearest one-tenth of a million dollars.
-ITAX = {
-    '0:EITC': {
-        # Full earned income credit
-        # in 2015 using the IRS-SOI information described above.
-        # EITC is column (37) in the Table 3.3 spreadsheet,
-        # which is the sum of columns (47), (75) and (97).
-        'SOI': [0.2104,
-                1.1843,
-                7.1562,
-                16.5927,
-                15.8799,
-                11.1025,
-                7.5150,
-                7.4528,
-                1.3936,
-                0.0375,
-                0.0000,
-                0.0000,
-                0.0000,
-                0.0000,
-                0.0000,
-                0.0000,
-                0.0000,
-                0.0000,
-                0.0000],
-        'TC': ['eitc']
-    },
-
-    '1:FCTC': {
-        # Full (basic and additional, refundable and nonrefundable) child tax
-        # credit in 2015 using the IRS-SOI information described above.
-        # FCTC is sum of columns (13) and (39) in the Table 3.3 spreadsheet.
-        'SOI': [0.1301,
-                0.0793,
-                1.4740,
-                4.2580,
-                5.2104,
-                4.6582,
-                4.3166,
-                7.2320,
-                5.2848,
-                9.4151,
-                6.4075,
-                5.2222,
-                0.0018,
-                0.0000,
-                0.0000,
-                0.0000,
-                0.0000,
-                0.0000,
-                0.0000],
-        'TC': ['c07220',  # FCTC that is nonrefundable
-               'c11070']  # FCTC that isrefundable
-    },
-
-    '2:NIIT': {
-        # Net investment income tax
-        # in 2015 using the IRS-SOI information described above.
-        # NIIT is column (53) in the Table 3.3 spreadsheet.
-        # NIIT is included in Tax-Calculator individual income tax liability.
-        'SOI': [0.0004,
-                0.0000,
-                0.0000,
-                0.0000,
-                0.0000,
-                0.0000,
-                0.0001,
-                0.0000,
-                0.0000,
-                0.0014,
-                0.0005,
-                0.0213,
-                2.6397,
-                3.1356,
-                1.6715,
-                1.0775,
-                3.1267,
-                2.0949,
-                8.2730],
-        'TC': ['niit']
-    },
-
-    '3:ITAX': {
-        # Total income tax liability
-        # in 2015 using the IRS-SOI information described above.
-        # ITAX is column (55) in the Table 3.3 spreadsheet,
-        # which includes NIIT and is after all credits.
-        'SOI': [0.2425,
-                0.0409,
-                0.3680,
-                1.3813,
-                3.5238,
-                6.1911,
-                8.7526,
-                25.1677,
-                32.5302,
-                99.7918,
-                105.9015,
-                316.3496,
-                299.8322,
-                154.3888,
-                66.3236,
-                39.6716,
-                101.4885,
-                56.3344,
-                139.6113],
-        'TC': ['iitax']
-    },
-
-    '4:SETAX': {
-        # Self-employment tax
-        # in 2015 using the IRS-SOI information described above.
-        # SETAX is column (59) in the Table 3.3 spreadsheet,
-        # which is not part of ITAX but is part of total payroll taxes.
-        'SOI': [0.6557,
-                0.5554,
-                1.8956,
-                3.5143,
-                2.8228,
-                1.9959,
-                1.8020,
-                3.3598,
-                2.8199,
-                5.9579,
-                5.2751,
-                12.1488,
-                9.6864,
-                3.4864,
-                1.1938,
-                0.6432,
-                1.2527,
-                0.4698,
-                0.6383],
-        'TC': ['setax']
-    },
-
-    '5:AMTAX': {
-        # Additional Medicare tax
-        # in 2015 using the IRS-SOI information described above.
-        # AMTAX is column (71) in the Table 3.3 spreadsheet,
-        # which is not part of ITAX but is part of total payroll taxes.
-        'SOI': [0.0225,
-                0.0003,
-                0.0000,
-                0.0002,
-                0.0002,
-                0.0004,
-                0.0002,
-                0.0041,
-                0.0071,
-                0.0057,
-                0.0026,
-                0.0372,
-                1.8356,
-                2.0214,
-                0.8602,
-                0.4898,
-                1.1730,
-                0.5805,
-                0.9787],
-        'TC': ['ptax_amc']
-    }
-}
-
-
-def comparison(cname, calc, cmpdata, ofile):
-    """
-    Write comparison results for cname to ofile.
-    """
-    # pylint: disable=too-many-locals
-    # generate compare table for cvarname
-    vardf = calc.dataframe(['s006', 'c00100'])  # weight and AGI
-    # add compare variable to vardf
-    cvar = np.zeros(calc.array_len)
-    for var in cmpdata[cname]['TC']:
-        cvar += calc.array(var)
-    vardf['cvar'] = cvar
-    # construct AGI table
-    vardf = add_income_table_row_variable(vardf, 'c00100', SOI_AGI_BINS)
-    gbydf = vardf.groupby('table_row', as_index=False, observed=True)
-    # write AGI table with ALL row at bottom of ofile
-    ofile.write(f"TABLE for {cname.split(':')[1]}\n")
-    results = '{:23s}\t{:8.3f}\t{:8.3f}\t{:+6.1f}\n'
-    colhead = f"{'AGIcategory':23s}\t{'T-C':>8s}\t{'SOI':>8s}\t{'%diff':>6s}\n"
-    ofile.write(colhead)
-    # pylint: disable=consider-using-f-string
-    txc_tot = 0.
-    soi_tot = 0.
-    idx = 0
-    for grp_interval, grp in gbydf:
-        txc = (grp['cvar'] * grp['s006']).sum() * 1e-9
-        soi = cmpdata[cname]['SOI'][idx]
-        txc_tot += txc
-        soi_tot += soi
-        if soi > 0:
-            pct_diff = 100. * ((txc / soi) - 1.)
-        else:
-            pct_diff = np.nan
-        glabel = f'[{grp_interval.left:.8g}, {grp_interval.right:.8g})'
-        ofile.write(results.format(glabel, txc, soi, pct_diff))
-        idx += 1
-    pct_diff = 100. * ((txc_tot / soi_tot) - 1.)
-    ofile.write(results.format('ALL', txc_tot, soi_tot, pct_diff))
-    # pylint: enable=consider-using-f-string
-
-
-def nonsmall_diffs(linelist1, linelist2, small=0.0):
-    """
-    Return True if line lists differ significantly; otherwise return False.
-    Significant numerical difference means one or more numbers differ (between
-    linelist1 and linelist2) by more than the specified small amount.
-    """
-    # embedded function used only in nonsmall_diffs function
-    def isfloat(value):
-        """
-        Return True if value can be cast to float; otherwise return False.
-        """
-        try:
-            float(value)
-            return True
-        except ValueError:
-            return False
-    # begin nonsmall_diffs logic
-    assert isinstance(linelist1, list)
-    assert isinstance(linelist2, list)
-    if len(linelist1) != len(linelist2):
-        return True
-    assert 0.0 <= small <= 1.0
-    epsilon = 1e-6
-    smallamt = small + epsilon
-    for line1, line2 in zip(linelist1, linelist2):
-        if line1 == line2:
-            continue
-        tokens1 = line1.replace(',', '').split()
-        tokens2 = line2.replace(',', '').split()
-        for tok1, tok2 in zip(tokens1, tokens2):
-            tok1_isfloat = isfloat(tok1)
-            tok2_isfloat = isfloat(tok2)
-            if tok1_isfloat and tok2_isfloat:
-                if abs(float(tok1) - float(tok2)) <= smallamt:
-                    continue
-                return True
-            if not tok1_isfloat and not tok2_isfloat:
-                if tok1 == tok2:
-                    continue
-                return True
-            return True
-        return False
-
-
-def differences(afilename, efilename):
-    """
-    Check for differences between results in afilename and efilename files.
-    """
-    with open(afilename, 'r', encoding='utf-8') as afile:
-        actres = afile.read()
-    with open(efilename, 'r', encoding='utf-8') as efile:
-        expres = efile.read()
-    diffs = nonsmall_diffs(actres.splitlines(True),
-                           expres.splitlines(True), 0.0)
-    if diffs:
-        afname = os.path.basename(afilename)
-        efname = os.path.basename(efilename)
-        msg = 'COMPARE RESULTS DIFFER\n'
-        msg += '-------------------------------------------------\n'
-        msg += f'--- NEW RESULTS IN {afname} FILE   ---\n'
-        msg += f'--- if new OK, copy {afname} to    ---\n'
-        msg += f'---                 {efname}       ---\n'
-        msg += '---            and rerun test.                ---\n'
-        msg += '-------------------------------------------------\n'
-        raise ValueError(msg)
-    os.remove(afilename)
-
-
-@pytest.mark.pre_release
-@pytest.mark.requires_pufcsv
-@pytest.mark.parametrize('using_puf', [True, False])
-def test_itax_compare(tests_path, using_puf, puf_fullsample, cps_fullsample):
-    """
-    Conduct income tax comparisons using ITAX data.
-    """
-    using_puf_adjust_ratios = True
-    # generate 2015 estimates by AGI category using Tax-Calculator
-    if using_puf:
-        if using_puf_adjust_ratios:
-            recs = Records(data=puf_fullsample)
-        else:
-            recs = Records(data=puf_fullsample, adjust_ratios=None)
-    else:
-        recs = Records.cps_constructor(data=cps_fullsample)
-    calc = Calculator(policy=Policy(), records=recs, verbose=False)
-    calc.advance_to_year(2015)
-    calc.calc_all()
-    # open actual output file
-    if using_puf:
-        afilename = os.path.join(tests_path, 'cmpi_puf_actual.txt')
-    else:
-        afilename = os.path.join(tests_path, 'cmpi_cps_actual.txt')
-    with open(afilename, 'w', encoding='utf-8') as afile:
-        # write compare results to afile
-        for cname in sorted(ITAX.keys()):
-            comparison(cname, calc, ITAX, afile)
-    # check for differences between actual and expect output files
-    efilename = afilename.replace('actual', 'expect')
-    differences(afilename, efilename)

taxcalc/tests/test_compatible_data.py

@@ -1,334 +0,0 @@
-"""
-Tests of the compatible_data fields in the policy_current_law.json file.
-
-In order to tap into the parallelization capabilities of py.test, this module
-leans heavily on py.tests's `parametrization` method. Once you do so, the
-plug-in pytest-xdist is able to run all parametrized functions in parallel
-"""
-# CODING-STYLE CHECKS:
-# pycodestyle test_compatible_data.py
-# pylint --disable=locally-disabled test_compatible_data.py
-
-import copy
-import pytest
-import numpy as np
-from taxcalc.policy import Policy
-from taxcalc.records import Records
-from taxcalc.calculator import Calculator
-
-
-@pytest.fixture(scope='module', name='allparams')
-def fixture_allparams():
-    """
-    Return metadata for current-law policy parameters.
-    """
-    clp = Policy()
-    return clp.metadata()
-
-
-def test_compatible_data_presence(allparams):
-    """
-    Test that every parameter in the policy_current_law.json file
-    has a compatible_data field that is a dictionary.
-    """
-    compatible_data_keys_set = set(['puf', 'cps'])
-
-    # Nested function used only in test_compatible_data_presence
-    def valid_compatible_data(compatible_data):
-        """
-        Return True if compatible_data is a valid dictionary;
-        otherwise return False
-        """
-        if not isinstance(compatible_data, dict):
-            return False
-        if set(compatible_data.keys()) != compatible_data_keys_set:
-            return False
-        for key in compatible_data:
-            boolean = (compatible_data[key] is True or
-                       compatible_data[key] is False)
-            if not boolean:
-                return False
-        return True
-
-    # Main logic of test_compatible_data_presence function
-    problem_pnames = []
-    for pname in allparams:
-        if 'compatible_data' in allparams[pname]:
-            compatible_data = allparams[pname]['compatible_data']
-        else:
-            compatible_data = None
-        if not valid_compatible_data(compatible_data):
-            problem_pnames.append(pname)
-    if problem_pnames:
-        msg = '{} has no or invalid compatible_data field'
-        for pname in problem_pnames:
-            print(msg.format(pname))
-        assert False, 'ERROR: list of problem_pnames is above'
-
-
-XX_YEAR = 2019
-TEST_YEAR = 2020
-
-
-@pytest.fixture(scope='module', name='reform_xx')
-def fixture_reform_xx():
-    """
-    Fixture for reform dictionary where reform starts before TEST_YEAR.
-
-    The provisions in the baseline reform, designated in _reform_xx,
-    are chosen to activate parameters that are inactive under current law.
-    For example a phaseout rate for a new credit is inactive if the credit's
-    amount is set to zero under current law. In order to activate the phaseout
-    rate, the credit amount should be set above zero. The provisions interact
-    with each other: you may acidentally deactivate one parameter
-    by introducing a provision to activate another. If you find that a pair of
-    parameters are impossible test jointly, add one to the local variable
-    `exempt_from_testing` in `test_compatible_data()` as a last resort.
-    """
-    assert XX_YEAR < TEST_YEAR
-
-    # Set baseline to activate parameters that are inactive under current law.
-    _reform_xx = {
-        XX_YEAR: {
-            'FST_AGI_trt': 0.5,
-            'CTC_new_rt': 0.5,
-            'CTC_new_c': 5000,
-            'CTC_new_prt': 0.1,
-            'CTC_new_refund_limited': True,
-            'CTC_new_refund_limit_payroll_rt': 1,
-            'ACTC_ChildNum': 1,
-            'UBI_u18': 1000,
-            'UBI_1820': 1000,
-            'UBI_21': 1000,
-            'II_credit_prt': 0.1,
-            'II_credit': [100, 100, 100, 100, 100],
-            'CG_brk3': [1000000, 1000000, 1000000, 1000000, 1000000],
-            'ALD_Dependents_Child_c': 1000,
-            'II_credit_nr': [1000, 1000, 1000, 1000, 1000],
-            'II_credit_nr_prt': 0.1,
-            'AMT_CG_brk3': [500000, 500000, 500000, 500000, 500000],
-            'AGI_surtax_thd': [1000000, 1000000, 1000000, 1000000, 1000000],
-            'AGI_surtax_trt': 0.5,
-            'II_brk7': [1000000, 1000000, 1000000, 1000000, 1000000],
-            'II_em': 1000,
-            'ID_Casualty_hc': 0.1,
-            'ID_Miscellaneous_hc': 0.1,
-            'ID_prt': 0.03,
-            'ID_crt': 0.8,
-            'CR_Charity_rt': 0.4,
-            'CR_Charity_f': [5000, 5000, 5000, 5000, 5000],
-            'CR_Charity_frt': 0.5,
-            'CR_SchR_hc': 0.5
-        }
-    }
-    return _reform_xx
-
-
-@pytest.fixture(scope='module', name='sorted_param_names')
-def fixture_sorted_param_names(allparams):
-    """
-    Fixture for storing a sorted parameter list
-    """
-    return sorted(list(allparams.keys()))
-
-
-NPARAMS = 219  # hard-code NPARAMS to len(allparams)
-BATCHSIZE = 10
-BATCHES = int(np.floor(NPARAMS / BATCHSIZE)) + 1
-
-
-@pytest.fixture(scope='module', name='allparams_batch',
-                params=list(range(0, BATCHES)))
-def fixture_allparams_batch(request, allparams, sorted_param_names):
-    """
-    Fixture for grouping Tax-Calculator parameters
-
-    Experiments indicated that there is some overhead when you run
-    `test_compatible_data` on each parameter individually. Suppose it takes X
-    amount of time to set up the test data for `test_compatible_data` and Y
-    amount of time to run `test_compatible_data` on each parameter wihtout
-    parallelization. Then, if there is no overhead from parallelization, you
-    would expect it to take Y + (X / NUMBER_WORKERS) to run these tests in
-    parallel. Note that setup data is only created once if you set the
-    fixture scope to 'module'. However, experiments indicated that there was
-    so much overhead that the tests weren't that much faster in parallel than
-    if they were run sequentially.
-
-    I found that running the parameters in batches decreased the amount of
-    overhead. Further, there was an optimal batch size that I found through
-    trial and error. On my local machine, this was something like 10
-    parameters. Others may find a different optimal batch size on their
-    machines. Further, if the number of parameters changes, the optimal
-    batch size could change, too.
-
-    Math for partitioning the parameters:
-
-    Suppose we have N parameters and choose batch size n. Then, we have
-    B batches where B equals floor(N / n) + 1.
-
-    Case 1: N  %  n = 0
-    Then we have:
-    idx_min = {i * b, i = 0, 1, 2, 3, ..., B - 1} and
-    idx_max = {min((i + 1) * b, N), i = 0, 1, 2, 3, ..., B - 1}
-
-    So, if i equals 0, the batch contains the first b - 1 parameters.
-    Then, if i equals B, then idx_min is n * (B - 1) = N and idx_max is N and
-    thus, the last batch is empty.
-
-    Case 2: N  %  n = r > 0
-    Then, everything is the same as case 1, except for the final batch.
-    In the final batch, idx_min = b * (B - 1) = b * floor(N / n) < N, and
-    idx_max is N. So, we our final batch size is
-    idx_max - idx_min = N - b * B = r.
-
-    returns: dictionary of size, BATCHSIZE, or for the final batch,
-    either an empty dictionary or dictionary of size NPARAMS mod BATCHSIZE
-    """
-    idx = request.param
-    idx_start = idx * BATCHSIZE
-    idx_end = min((idx + 1) * BATCHSIZE, NPARAMS)
-    pnames = sorted_param_names[idx_start: idx_end]
-    return {pname: allparams[pname] for pname in pnames}
-
-
-@pytest.fixture(scope='module', name='tc_objs',
-                params=[True, False])
-def fixture_tc_objs(request, reform_xx, puf_subsample, cps_subsample):
-    """
-    Fixture for creating Tax-Calculator objects that use the PUF and
-    use the CPS (called only twice: once for PUF and once for CPS)
-    """
-    puftest = request.param
-    p_xx = Policy()
-    p_xx.implement_reform(reform_xx, raise_errors=False)
-    if puftest:
-        rec_xx = Records(data=puf_subsample)
-    else:
-        rec_xx = Records.cps_constructor(data=cps_subsample)
-    c_xx = Calculator(policy=p_xx, records=rec_xx)
-    c_xx.advance_to_year(TEST_YEAR)
-    c_xx.calc_all()
-    return rec_xx, c_xx, puftest
-
-
-@pytest.mark.skip
-@pytest.mark.pre_release
-@pytest.mark.compatible_data
-@pytest.mark.requires_pufcsv
-def test_compatible_data(cps_subsample, puf_subsample,
-                         allparams, reform_xx,
-                         tc_objs, allparams_batch):
-    """
-    Test that the compatible_data attribute in policy_current_law.json
-    is accurate by implementing the min and max values of each parameter
-    as reforms and ensuring that revenue differs from baseline when for
-    at least one of these reforms when using datasets marked compatible
-    and does not differ when using datasets marked as incompatible.
-    """
-    # pylint: disable=too-many-arguments,too-many-positional-arguments
-    # pylint: disable=too-many-statements,too-many-branches,too-many-locals
-
-    # Check NPARAMS value
-    assert NPARAMS == len(allparams)
-
-    # Get taxcalc objects from tc_objs fixture
-    rec_xx, c_xx, puftest = tc_objs
-
-    # These parameters are exempt because they are not active under
-    # current law and activating them would deactivate other parameters,
-    # or if it is difficult to devise a test for them.
-    exempt_from_testing = [
-        'CG_ec', 'CG_reinvest_ec_rt',
-        'II_prt', 'ID_prt', 'ID_crt',
-        'CR_SchR_hc', 'ACTC_ChildNum'
-    ]
-
-    # Loop through the parameters in allparams_batch
-    errmsg = 'ERROR: {} {}\n'
-    errors = ''
-    for pname in allparams_batch:
-        param = allparams_batch[pname]
-        max_listed = param['valid_values']['max']
-        # handle links to other params or self
-        if isinstance(max_listed, str):
-            if isinstance(allparams[max_listed]['value'][0], list):
-                max_val = allparams[max_listed]['value'][0]
-            else:
-                max_val = float(allparams[max_listed]['value'][0])
-        else:
-            if isinstance(param['value'][0], list):
-                max_val = [max_listed] * len(param['value'][0])
-            else:
-                max_val = max_listed
-        min_listed = param['valid_values']['min']
-        if isinstance(min_listed, str):
-            if isinstance(allparams[min_listed]['value'][0], list):
-                min_val = allparams[min_listed]['value'][0]
-            else:
-                min_val = float(allparams[min_listed]['value'][0])
-        else:
-            if isinstance(param['value'][0], list):
-                min_val = [min_listed] * len(param['value'][0])
-            else:
-                min_val = min_listed
-        # create reform dictionaries
-        max_reform = copy.deepcopy(reform_xx)
-        min_reform = copy.deepcopy(reform_xx)
-        max_reform[XX_YEAR][str(pname)] = [max_val]
-        min_reform[XX_YEAR][str(pname)] = [min_val]
-        # assess whether max reform changes results
-        if puftest:
-            rec_yy = Records(data=puf_subsample)
-        else:
-            rec_yy = Records.cps_constructor(data=cps_subsample)
-        p_yy = Policy()
-        p_yy.implement_reform(max_reform, raise_errors=False)
-        c_yy = Calculator(policy=p_yy, records=rec_yy, verbose=False)
-        c_yy.advance_to_year(TEST_YEAR)
-        c_yy.calc_all()
-        if pname.startswith('BEN') and pname.endswith('_repeal'):
-            max_reform_change = (
-                c_yy.weighted_total('benefit_cost_total') -
-                c_xx.weighted_total('benefit_cost_total')
-            )
-        else:
-            max_reform_change = (
-                c_yy.weighted_total('combined') -
-                c_xx.weighted_total('combined')
-            )
-        min_reform_change = 0
-        # assess whether min reform changes results, if max reform did not
-        if max_reform_change == 0:
-            p_yy = Policy()
-            p_yy.implement_reform(min_reform, raise_errors=False)
-            c_yy = Calculator(policy=p_yy, records=rec_xx)
-            c_yy.advance_to_year(TEST_YEAR)
-            c_yy.calc_all()
-            if pname.startswith('BEN') and pname.endswith('_repeal'):
-                min_reform_change = (
-                    c_yy.weighted_total('benefit_cost_total') -
-                    c_xx.weighted_total('benefit_cost_total')
-                )
-            else:
-                min_reform_change = (
-                    c_yy.weighted_total('combined') -
-                    c_xx.weighted_total('combined')
-                )
-            if min_reform_change == 0 and pname not in exempt_from_testing:
-                if puftest:
-                    if param['compatible_data']['puf'] is True:
-                        errors += errmsg.format(pname, 'is not True for puf')
-                else:
-                    if param['compatible_data']['cps'] is True:
-                        errors += errmsg.format(pname, 'is not True for cps')
-        if max_reform_change != 0 or min_reform_change != 0:
-            if puftest:
-                if param['compatible_data']['puf'] is False:
-                    errors += errmsg.format(pname, 'is not False for puf')
-            else:
-                if param['compatible_data']['cps'] is False:
-                    errors += errmsg.format(pname, 'is not False for cps')
-    # test failure if any errors
-    if errors:
-        print(errors)
-        assert False, 'ERROR: compatible_data is invalid; see errors above'