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

taxcalc/tests/test_consumption.py

@@ -0,0 +1,144 @@
+# CODING-STYLE CHECKS:
+# pycodestyle test_consumption.py
+
+import numpy as np
+import paramtools
+import pytest
+import copy
+from taxcalc import Policy, Records, Calculator, Consumption
+
+
+def test_year_consistency():
+    assert Consumption.JSON_START_YEAR == Policy.JSON_START_YEAR
+    assert Consumption.DEFAULT_NUM_YEARS == Policy.DEFAULT_NUM_YEARS
+
+
+def test_validity_of_consumption_vars_set():
+    records_varinfo = Records(data=None)
+    assert Consumption.RESPONSE_VARS.issubset(records_varinfo.USABLE_READ_VARS)
+    useable_vars = set(['housing', 'snap', 'tanf', 'vet', 'wic',
+                        'mcare', 'mcaid', 'other'])
+    assert Consumption.BENEFIT_VARS.issubset(useable_vars)
+
+
+def test_update_consumption():
+    consump = Consumption()
+    consump.update_consumption({})
+    revision = {
+        'MPC_e20400': {2014: 0.05,
+                       2015: 0.06},
+        'BEN_mcare_value': {2014: 0.75,
+                            2015: 0.80}
+    }
+    consump.update_consumption(revision)
+    expected_mpc_e20400 = np.full((Consumption.DEFAULT_NUM_YEARS,), 0.06)
+    expected_mpc_e20400[0] = 0.0
+    expected_mpc_e20400[1] = 0.05
+    assert np.allclose(consump._MPC_e20400,
+                       expected_mpc_e20400,
+                       rtol=0.0)
+    assert np.allclose(consump._MPC_e17500,
+                       np.zeros((Consumption.DEFAULT_NUM_YEARS,)),
+                       rtol=0.0)
+    expected_ben_mcare_value = np.full((Consumption.DEFAULT_NUM_YEARS,), 0.80)
+    expected_ben_mcare_value[0] = 1.0
+    expected_ben_mcare_value[1] = 0.75
+    assert np.allclose(consump._BEN_mcare_value,
+                       expected_ben_mcare_value,
+                       rtol=0.0)
+    assert np.allclose(consump._BEN_snap_value,
+                       np.ones((Consumption.DEFAULT_NUM_YEARS,)),
+                       rtol=0.0)
+    consump.set_year(2015)
+    assert consump.current_year == 2015
+    assert consump.MPC_e20400 == 0.06
+    assert consump.MPC_e17500 == 0.0
+    assert consump.BEN_mcare_value == 0.80
+    assert consump.BEN_snap_value == 1.0
+
+
+def test_incorrect_update_consumption():
+    with pytest.raises(paramtools.ValidationError):
+        Consumption().update_consumption([])
+    with pytest.raises(paramtools.ValidationError):
+        Consumption().update_consumption({'MPC_e17500': {'xyz': 0.2}})
+    with pytest.raises(paramtools.ValidationError):
+        Consumption().update_consumption({'MPC_e17500': {2012: 0.2}})
+    with pytest.raises(paramtools.ValidationError):
+        Consumption().update_consumption({'MPC_e17500': {2099: 0.2}})
+    with pytest.raises(paramtools.ValidationError):
+        Consumption().update_consumption({'MPC_exxxxx': {2014: 0.2}})
+    with pytest.raises(paramtools.ValidationError):
+        Consumption().update_consumption({'MPC_e17500': {2014: -0.1}})
+    with pytest.raises(paramtools.ValidationError):
+        Consumption().update_consumption({'MPC_e17500-indexed': {2014: 0.1}})
+
+
+def test_future_update_consumption():
+    consump = Consumption()
+    assert consump.current_year == consump.start_year
+    assert consump.has_response() is False
+    cyr = 2020
+    consump.set_year(cyr)
+    consump.update_consumption({'MPC_e20400': {cyr: 0.01}})
+    assert consump.current_year == cyr
+    assert consump.has_response() is True
+    consump.set_year(cyr - 1)
+    assert consump.has_response() is False
+    # test future updates for benefits
+    consump_ben = Consumption()
+    assert consump_ben.current_year == consump_ben.start_year
+    assert consump_ben.has_response() is False
+    consump_ben.set_year(cyr)
+    consump_ben.update_consumption({'BEN_vet_value': {cyr: 0.95}})
+    assert consump_ben.current_year == cyr
+    assert consump_ben.has_response() is True
+    consump_ben.set_year(cyr - 1)
+    assert consump_ben.has_response() is False
+
+
+def test_consumption_default_data():
+    consump = Consumption()
+    pdata = consump.specification(meta_data=True, ignore_state=True)
+    for pname in pdata.keys():
+        if pname.startswith('MPC'):
+            assert pdata[pname]['value'] == [{"value": 0.0, "year": 2013}]
+        elif pname.startswith('BEN'):
+            assert pdata[pname]['value'] == [{"value": 1.0, "year": 2013}]
+
+
+def test_consumption_response(cps_subsample):
+    consump = Consumption()
+    mpc = 0.5
+    consumption_response = {'MPC_e20400': {2013: mpc}}
+    consump.update_consumption(consumption_response)
+    # test incorrect call to response method
+    with pytest.raises(ValueError):
+        consump.response(list(), 1)
+    # test correct call to response method
+    rec = Records.cps_constructor(data=cps_subsample)
+    pre = copy.deepcopy(rec.e20400)
+    consump.response(rec, 1.0)
+    post = rec.e20400
+    actual_diff = post - pre
+    expected_diff = np.ones(rec.array_length) * mpc
+    assert np.allclose(actual_diff, expected_diff)
+    # compute earnings mtr with no consumption response
+    rec = Records.cps_constructor(data=cps_subsample)
+    ided0 = copy.deepcopy(rec.e20400)
+    calc0 = Calculator(policy=Policy(), records=rec, consumption=None)
+    (mtr0_ptax, mtr0_itax, _) = calc0.mtr(variable_str='e00200p',
+                                          wrt_full_compensation=False)
+    assert np.allclose(calc0.array('e20400'), ided0)
+    # compute earnings mtr with consumption response
+    calc1 = Calculator(policy=Policy(), records=rec, consumption=consump)
+    mtr1_ptax, mtr1_itax, _ = calc1.mtr(variable_str='e00200p',
+                                        wrt_full_compensation=False)
+    assert np.allclose(calc1.array('e20400'), ided0)
+    # confirm that payroll mtr values are no different
+    assert np.allclose(mtr1_ptax, mtr0_ptax)
+    # confirm that all mtr with cons-resp are no greater than without cons-resp
+    assert np.all(np.less_equal(np.around(mtr1_itax, decimals=5),
+                                np.around(mtr0_itax, decimals=5)))
+    # confirm that some mtr with cons-resp are less than without cons-resp
+    assert np.any(np.less(mtr1_itax, mtr0_itax))

taxcalc/tests/test_cpscsv.py

@@ -0,0 +1,163 @@
+"""
+Tests of Tax-Calculator using cps.csv input.
+
+Note that the CPS-related files that are required to run this program
+have been constructed by the Tax-Calculator development team from publicly
+available Census data files.  Hence, the CPS-related files are freely
+available and are part of the Tax-Calculator repository.
+
+Read Tax-Calculator/TESTING.md for details.
+"""
+# CODING-STYLE CHECKS:
+# pycodestyle test_cpscsv.py
+# pylint --disable=locally-disabled test_cpscsv.py
+
+import os
+import json
+import pytest
+import numpy as np
+import pandas as pd
+# pylint: disable=import-error
+from taxcalc import Policy, Records, Calculator
+
+
+START_YEAR = 2017
+
+
+@pytest.mark.cpscsv_agg
+def test_agg(tests_path, cps_fullsample):
+    """
+    Test current-law aggregate taxes using cps.csv file.
+    """
+    # pylint: disable=too-many-statements,too-many-locals
+    nyrs = 10
+    # create a baseline Policy object with current-law policy parameters
+    baseline_policy = Policy()
+    # create a Records object (rec) containing all cps.csv input records
+    recs = Records.cps_constructor(data=cps_fullsample)
+    # create a Calculator object using baseline policy and cps records
+    calc = Calculator(policy=baseline_policy, records=recs)
+    calc.advance_to_year(START_YEAR)
+    calc_start_year = calc.current_year
+    # create aggregate diagnostic table (adt) as a Pandas DataFrame object
+    adt = calc.diagnostic_table(nyrs).round(1)  # column labels are int
+    taxes_fullsample = adt.loc["Combined Liability ($b)"]
+    # compare actual DataFrame, adt, with the expected DataFrame, edt
+    aggres_path = os.path.join(tests_path, 'cpscsv_agg_expect.csv')
+    edt = pd.read_csv(aggres_path, index_col=False)  # column labels are str
+    edt.drop('Unnamed: 0', axis='columns', inplace=True)
+    assert len(adt.columns.values) == len(edt.columns.values)
+    diffs = False
+    for icol in adt.columns.values:
+        if not np.allclose(adt[icol], edt[str(icol)]):
+            diffs = True
+    if diffs:
+        new_filename = '{}{}'.format(aggres_path[:-10], 'actual.csv')
+        adt.to_csv(new_filename, float_format='%.1f')
+        msg = 'CPSCSV AGG RESULTS DIFFER\n'
+        msg += '-------------------------------------------------\n'
+        msg += '--- NEW RESULTS IN cpscsv_agg_actual.csv FILE ---\n'
+        msg += '--- if new OK, copy cpscsv_agg_actual.csv to  ---\n'
+        msg += '---                 cpscsv_agg_expect.csv     ---\n'
+        msg += '---            and rerun test.                ---\n'
+        msg += '---       (both are in taxcalc/tests)         ---\n'
+        msg += '-------------------------------------------------\n'
+        raise ValueError(msg)
+    # create aggregate diagnostic table using unweighted sub-sample of records
+    rn_seed = 180  # to ensure sub-sample is always the same
+    subfrac = 0.07# 0.03  # sub-sample fraction
+    subsample = cps_fullsample.sample(frac=subfrac, random_state=rn_seed)
+    recs_subsample = Records.cps_constructor(data=subsample)
+    calc_subsample = Calculator(policy=baseline_policy, records=recs_subsample)
+    calc_subsample.advance_to_year(START_YEAR)
+    adt_subsample = calc_subsample.diagnostic_table(nyrs)
+    # compare combined tax liability from full and sub samples for each year
+    taxes_subsample = adt_subsample.loc["Combined Liability ($b)"]
+    print('taxes_submsampe = ', taxes_subsample)
+    print('TAXES full sample = ', taxes_fullsample)
+    msg = ''
+    for cyr in range(calc_start_year, calc_start_year + nyrs):
+        if cyr == calc_start_year:
+            reltol = 0.0232
+        else:
+            reltol = 0.0444
+        if not np.allclose(taxes_subsample[cyr], taxes_fullsample[cyr],
+                           atol=0.0, rtol=reltol):
+            reldiff = (taxes_subsample[cyr] / taxes_fullsample[cyr]) - 1.
+            line1 = '\nCPSCSV AGG SUB-vs-FULL RESULTS DIFFER IN {}'
+            line2 = '\n  when subfrac={:.3f}, rtol={:.4f}, seed={}'
+            line3 = '\n  with sub={:.3f}, full={:.3f}, rdiff={:.4f}'
+            msg += line1.format(cyr)
+            msg += line2.format(subfrac, reltol, rn_seed)
+            msg += line3.format(taxes_subsample[cyr],
+                                taxes_fullsample[cyr],
+                                reldiff)
+    if msg:
+        raise ValueError(msg)
+
+
+def test_cps_availability(tests_path, cps_path):
+    """
+    Cross-check records_variables.json data with variables in cps.csv file.
+    """
+    cpsdf = pd.read_csv(cps_path)
+    cpsvars = set(list(cpsdf))
+    # make set of variable names that are marked as cps.csv available
+    rvpath = os.path.join(tests_path, '..', 'records_variables.json')
+    with open(rvpath, 'r') as rvfile:
+        rvdict = json.load(rvfile)
+    recvars = set()
+    for vname, vdict in rvdict['read'].items():
+        if 'taxdata_cps' in vdict.get('availability', ''):
+            recvars.add(vname)
+    # check that cpsvars and recvars sets are the same
+    assert (cpsvars - recvars) == set()
+    assert (recvars - cpsvars) == set()
+
+
+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

taxcalc/tests/test_data.py

@@ -0,0 +1,133 @@
+# CODING-STYLE CHECKS:
+# pycodestyle test_data.py
+
+import os
+import tempfile
+import pytest
+import numpy as np
+import pandas as pd
+from taxcalc import Data, GrowFactors
+
+
+# Test specification and use of simple Data-derived class.
+# This derived class is called Recs and it contains aged data.
+#
+# The following pytest fixture specifies the VARINFO file for the
+# Recs class, which is defined in the test_recs_class function.
+
+
+VARINFO_JSON = """
+{
+  "read": {
+    "RECID": {
+      "required": true,
+      "type": "int",
+      "desc": "Unique numeric identifier for record"
+    },
+    "MARS": {
+      "required": true,
+      "type": "int",
+      "desc": "Filing (marital) status [1..5]"
+    },
+    "e00300": {
+      "type": "float",
+      "desc": "Taxable interest income"
+    },
+    "s006": {
+      "type": "float",
+      "desc": "Record sampling weight"
+    }
+  },
+  "calc": {
+    "expanded_income": {
+      "type": "float"
+    }
+  }
+}
+"""
+
+
+@pytest.fixture(scope='module', name='recs_varinfo_file')
+def fixture_recs_varinfo_json_file():
+    """
+    Define JSON VARINFO file for Data-derived Recs class.
+    """
+    with tempfile.NamedTemporaryFile(mode='a', delete=False) as pfile:
+        pfile.write(VARINFO_JSON + '\n')
+    pfile.close()
+    yield pfile
+    os.remove(pfile.name)
+
+
+def test_recs_class(recs_varinfo_file, cps_subsample):
+    """
+    Specify Data-derived Recs class and test it.
+    """
+
+    class Recs(Data):
+        """
+        The Recs class is derived from the abstract base Data class.
+        """
+        VARINFO_FILE_NAME = recs_varinfo_file.name
+        VARINFO_FILE_PATH = ''
+
+        def __init__(self, data, start_year, gfactors, weights):
+            super().__init__(data, start_year, gfactors, weights)
+
+        def _extrapolate(self, year):
+            self.e00300 *= self.gfactors.factor_value('AINTS', year)
+
+    # test Recs class for incorrect instantiation
+    with pytest.raises(ValueError):
+        Recs(data=list(), start_year=2000,
+             gfactors=None, weights=None)
+    with pytest.raises(ValueError):
+        Recs(data=cps_subsample, start_year=list(),
+             gfactors=None, weights=None)
+    with pytest.raises(ValueError):
+        Recs(data=cps_subsample, start_year=2000,
+             gfactors=None, weights='')
+    with pytest.raises(ValueError):
+        Recs(data=cps_subsample, start_year=2000,
+             gfactors=GrowFactors(), weights=None)
+    with pytest.raises(ValueError):
+        Recs(data=cps_subsample, start_year=2000,
+             gfactors='', weights='')
+    # test Recs class for correct instantiation with no aging of data
+    syr = 2014
+    rec = Recs(data=cps_subsample, start_year=syr,
+               gfactors=None, weights=None)
+    assert isinstance(rec, Recs)
+    assert np.all(rec.MARS != 0)
+    assert rec.data_year == syr
+    assert rec.current_year == syr
+    sum_e00300_in_syr = rec.e00300.sum()
+    rec.increment_year()
+    assert rec.data_year == syr
+    assert rec.current_year == syr + 1
+    sum_e00300_in_syr_plus_one = rec.e00300.sum()
+    assert np.allclose([sum_e00300_in_syr], [sum_e00300_in_syr_plus_one])
+    del rec
+    # test Recs class for correct instantiation with aging of data
+    wghts_path = os.path.join(GrowFactors.FILE_PATH, 'cps_weights.csv.gz')
+    wghts_df = pd.read_csv(wghts_path)
+    rec = Recs(data=cps_subsample, start_year=syr,
+               gfactors=GrowFactors(), weights=wghts_df)
+    assert isinstance(rec, Recs)
+    assert np.all(rec.MARS != 0)
+    assert rec.data_year == syr
+    assert rec.current_year == syr
+    sum_s006_in_syr = rec.s006.sum()
+    sum_e00300_in_syr = rec.e00300.sum()
+    rec.increment_year()
+    assert rec.data_year == syr
+    assert rec.current_year == syr + 1
+    sum_s006_in_syr_plus_one = rec.s006.sum()
+    assert sum_s006_in_syr_plus_one > sum_s006_in_syr
+    sum_e00300_in_syr_plus_one = rec.e00300.sum()
+    assert sum_e00300_in_syr_plus_one > sum_e00300_in_syr
+    # test private methods
+    rec._read_data(data=None)
+    rec._read_weights(weights=None)
+    with pytest.raises(ValueError):
+        rec._read_weights(weights=list())