taxcalc 4.2.1__py3-none-any.whl → 4.3.0__py3-none-any.whl

taxcalc/tests/test_compare.py

@@ -0,0 +1,336 @@
+"""
+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
+# pylint: disable=import-error,pointless-string-statement
+from taxcalc import Policy, Records, Calculator
+from taxcalc 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)
+    # write AGI table with ALL row at bottom to ofile
+    ofile.write('TABLE for {}\n'.format(cname.split(':')[1]))
+    results = '{:23s}\t{:8.3f}\t{:8.3f}\t{:+6.1f}\n'
+    colhead = '{:23s}\t{:>8s}\t{:>8s}\t{:>6s}\n'
+    ofile.write(colhead.format('AGI category', 'T-C', 'SOI', '%diff'))
+    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 = '[{:.8g}, {:.8g})'.format(grp_interval.left,
+                                           grp_interval.right)
+        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))
+
+
+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
+        else:
+            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
+                    else:
+                        return True
+                elif not tok1_isfloat and not tok2_isfloat:
+                    if tok1 == tok2:
+                        continue
+                    else:
+                        return True
+                else:
+                    return True
+        return False
+
+
+def differences(afilename, efilename):
+    """
+    Check for differences between results in afilename and efilename files.
+    """
+    with open(afilename, 'r') as afile:
+        actres = afile.read()
+    with open(efilename, 'r') 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 += '--- NEW RESULTS IN {} FILE ---\n'
+        msg += '--- if new OK, copy {} to  ---\n'
+        msg += '---                 {}     ---\n'
+        msg += '---            and rerun test.                ---\n'
+        msg += '-------------------------------------------------\n'
+        raise ValueError(msg.format(afname, afname, efname))
+    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')
+    afile = open(afilename, 'w')
+    # write compare results to afile
+    for cname in sorted(ITAX.keys()):
+        comparison(cname, calc, ITAX, afile)
+    # close actual output file
+    afile.close()
+    # check for differences between actual and expect output files
+    efilename = afilename.replace('actual', 'expect')
+    differences(afilename, efilename)

taxcalc/tests/test_compatible_data.py

@@ -0,0 +1,338 @@
+"""
+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 import Policy, Records, Calculator  # pylint: disable=import-error
+
+
+@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 = list()
+    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 'list of problem_pnames' == 'empty list'
+
+
+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,
+            'ID_BenefitSurtax_trt': 0.1,
+            'ID_BenefitSurtax_crt': 0.1,
+            'UBI_u18': 1000,
+            'UBI_1820': 1000,
+            'UBI_21': 1000,
+            'PT_brk7': [1000000, 1000000, 1000000, 1000000, 1000000],
+            '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,
+            'ID_AmountCap_rt': 0.9,
+            'II_brk7': [1000000, 1000000, 1000000, 1000000, 1000000],
+            'ID_BenefitCap_rt': 0.3,
+            'PT_rt7': 0.35,
+            '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=[i for i in 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-locals
+    # pylint: disable=too-many-statements,too-many-branches
+
+    # 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 'compatible_data' == 'invalid'