def test_translate_json_reform_suffixes_eic():
    # test read_json_param_files(...) using EIC-indexed parameter suffixes
    json1 = """{"policy": {
      "_II_em": {"2020": [20000], "2015": [15000]},
      "_EITC_c_0kids": {"2018": [510], "2019": [510]},
      "_EITC_c_1kid": {"2019": [3400], "2018": [3400]},
      "_EITC_c_2kids": {"2018": [5616], "2019": [5616]},
      "_EITC_c_3+kids": {"2019": [6318], "2018": [6318]}
    }}"""
    pdict1 = Calculator.read_json_param_files(reform_filename=json1,
                                              assump_filename=None,
                                              arrays_not_lists=True)
    rdict1 = pdict1['policy']
    json2 = """{"policy": {
      "_EITC_c": {"2019": [[510, 3400, 5616, 6318]],
                  "2018": [[510, 3400, 5616, 6318]]},
      "_II_em": {"2020": [20000], "2015": [15000]}
    }}"""
    pdict2 = Calculator.read_json_param_files(reform_filename=json2,
                                              assump_filename=None,
                                              arrays_not_lists=True)
    rdict2 = pdict2['policy']
    assert len(rdict2) == len(rdict1)
    for year in rdict2.keys():
        if '_II_em' in rdict2[year].keys():
            assert np.allclose(rdict1[year]['_II_em'],
                               rdict2[year]['_II_em'],
                               atol=0.01, rtol=0.0)
        if '_EITC_c' in rdict2[year].keys():
            assert np.allclose(rdict1[year]['_EITC_c'],
                               rdict2[year]['_EITC_c'],
                               atol=0.01, rtol=0.0)
def test_translate_json_reform_suffixes_mars_non_indexed():
    # test read_json_param_files(...) using MARS-indexed parameter suffixes
    json1 = """{"policy": {
      "_II_em": {"2020": [20000], "2015": [15000]},
      "_AMEDT_ec_joint": {"2018": [400000], "2016": [300000]},
      "_AMEDT_ec_separate": {"2017": [150000], "2019": [200000]}
    }}"""
    pdict1 = Calculator.read_json_param_files(reform_filename=json1,
                                              assump_filename=None,
                                              arrays_not_lists=True)
    rdict1 = pdict1['policy']
    json2 = """{"policy": {
      "_AMEDT_ec": {"2016": [[200000, 300000, 125000, 200000, 200000]],
                    "2017": [[200000, 300000, 150000, 200000, 200000]],
                    "2018": [[200000, 400000, 150000, 200000, 200000]],
                    "2019": [[200000, 400000, 200000, 200000, 200000]]},
      "_II_em": {"2015": [15000], "2020": [20000]}
    }}"""
    pdict2 = Calculator.read_json_param_files(reform_filename=json2,
                                              assump_filename=None,
                                              arrays_not_lists=True)
    rdict2 = pdict2['policy']
    assert len(rdict2) == len(rdict1)
    for year in rdict2.keys():
        if '_II_em' in rdict2[year].keys():
            assert np.allclose(rdict1[year]['_II_em'],
                               rdict2[year]['_II_em'],
                               atol=0.01, rtol=0.0)
        if '_AMEDT_ec' in rdict2[year].keys():
            assert np.allclose(rdict1[year]['_AMEDT_ec'],
                               rdict2[year]['_AMEDT_ec'],
                               atol=0.01, rtol=0.0)
def test_read_json_reform_file_two_ways(reform_file, assump_file):
    """
    Test when using file name and file contents in read_json_param_files
    """
    pd1 = Calculator.read_json_param_files(reform_file.name, assump_file.name,
                                           arrays_not_lists=False)
    pd2 = Calculator.read_json_param_files(REFORM_CONTENTS, ASSUMP_CONTENTS,
                                           arrays_not_lists=False)
    assert pd1 == pd2
def test_read_bad_json_assump_file(bad1assumpfile, bad2assumpfile,
                                   bad3assumpfile):
    with pytest.raises(ValueError):
        Calculator.read_json_param_files(None, bad1assumpfile.name)
    with pytest.raises(ValueError):
        Calculator.read_json_param_files(None, bad2assumpfile.name)
    with pytest.raises(ValueError):
        Calculator.read_json_param_files(None, bad3assumpfile.name)
    with pytest.raises(ValueError):
        Calculator.read_json_param_files(None, 'unknown_file_name')
    with pytest.raises(ValueError):
        Calculator.read_json_param_files(None, list())
def test_read_json_param_files_with_suffixes_and_errors():
    # test interaction of policy parameter suffixes and reform errors
    # (fails without 0.10.2 bug fix as reported by Hank Doupe in TB PR#641)
    reform = {
        u'policy': {
            u'_II_brk4_separate': {u'2017': [5000.0]},
            u'_STD_separate': {u'2017': [8000.0]},
            u'_STD_single': {u'2018': [1000.0]},
            u'_II_brk2_headhousehold': {u'2017': [1000.0]},
            u'_II_brk4_single': {u'2017': [500.0]},
            u'_STD_joint': {u'2017': [10000.0], u'2020': [150.0]},
            u'_II_brk2_separate': {u'2017': [1000.0]},
            u'_II_brk2_single': {u'2017': [1000.0]},
            u'_II_brk2_joint': {u'2017': [1000.0]},
            u'_FICA_ss_trt': {u'2017': [-1.0], u'2019': [0.1]},
            u'_II_brk4_headhousehold': {u'2017': [500.0]},
            u'_STD_headhousehold': {u'2017': [10000.0], u'2020': [150.0]},
            u'_II_brk4_joint': {u'2017': [500.0]},
            u'_ID_BenefitSurtax_Switch_medical': {u'2017': [True]}
        }
    }
    json_reform = json.dumps(reform)
    params = Calculator.read_json_param_files(json_reform, None)
    assert isinstance(params, dict)
    pol = Policy()
    pol.implement_reform(params['policy'])
    assert len(pol.reform_errors) > 0
    assert len(pol.reform_warnings) > 0
def test_read_bad_json_reform_file(bad1reformfile, bad2reformfile,
                                   bad3reformfile):
    with pytest.raises(ValueError):
        Calculator.read_json_param_files(bad1reformfile.name, None)
    with pytest.raises(ValueError):
        Calculator.read_json_param_files(bad2reformfile.name, None)
    with pytest.raises(ValueError):
        Calculator.read_json_param_files(bad3reformfile.name, None)
    with pytest.raises(ValueError):
        Calculator.read_json_param_files(list(), None)
 def __init__(self,
              input_filename,
              reform,
              exact_calculations,
              emulate_taxsim_2441_logic,
              output_records):
     """
     SimpleTaxIO class constructor.
     """
     # pylint: disable=too-many-arguments
     # check that input_filename is a string
     if not isinstance(input_filename, six.string_types):
         msg = 'SimpleTaxIO.ctor input_filename is not a string'
         raise ValueError(msg)
     # construct output_filename and delete old output file if it exists
     # ... construct reform extension to output_filename
     if reform is None:
         ref = ''
         self._using_reform_file = True
     else:  # if reform is not None
         if isinstance(reform, six.string_types):
             if reform.endswith('.json'):
                 ref = '-{}'.format(reform[:-5])
             else:
                 ref = '-{}'.format(reform)
             self._using_reform_file = True
         elif isinstance(reform, dict):
             ref = ''
             self._using_reform_file = False
         else:
             msg = 'SimpleTaxIO.ctor reform is neither None, str, nor dict'
             raise ValueError(msg)
     # ... construct whole output_filename
     self._using_input_file = True
     self._output_filename = '{}.out-simtax{}'.format(input_filename, ref)
     if os.path.isfile(self._output_filename):
         os.remove(self._output_filename)
     # check for existence of file named input_filename
     if not os.path.isfile(input_filename):
         msg = 'INPUT file named {} could not be found'
         raise ValueError(msg.format(input_filename))
     # read input file contents into self._input dictionary
     self._read_input(input_filename)
     self.policy = Policy()
     # implement reform if reform is specified
     if reform:
         if self._using_reform_file:
             param_dict = Calculator.read_json_param_files(reform, None)
             r_pol = param_dict['policy']
         else:
             r_pol = reform
         self.policy.implement_reform(r_pol)
     # validate input variable values
     self._validate_input()
     self.calc = self._calc_object(exact_calculations,
                                   emulate_taxsim_2441_logic,
                                   output_records)
Exemple #8
0
def test_calculate_baseline_and_reform_error(puf_1991_path, reform_file,
                                             assump_file):
    usermods = Calculator.read_json_param_files(reform_file.name,
                                                assump_file.name)
    usermods['behavior'] = {2016: {'_BE_sub': [0.20]}}
    usermods['growdiff_response'] = {2020: {'_ABOOK': [0.01]}}
    usermods['gdp_elasticity'] = dict()
    tax_data = pd.read_csv(puf_1991_path)
    with pytest.raises(ValueError):
        calculate_baseline_and_reform(2, 2015, tax_data, usermods)
def test_translate_json_reform_suffixes_idedtype():
    # test read_json_param_files(...) using idedtype-indexed parameter suffixes
    json1 = """{"policy": {
      "_ID_BenefitCap_rt": {"2019": [0.2]},
      "_ID_BenefitCap_Switch_medical": {"2019": [false]},
      "_ID_BenefitCap_Switch_casualty": {"2019": [false]},
      "_ID_BenefitCap_Switch_misc": {"2019": [false]},
      "_ID_BenefitCap_Switch_interest": {"2019": [false]},
      "_ID_BenefitCap_Switch_charity": {"2019": [false]},
      "_II_em": {"2020": [20000], "2015": [15000]}
    }}"""
    pdict1 = Calculator.read_json_param_files(reform_filename=json1,
                                              assump_filename=None,
                                              arrays_not_lists=True)
    rdict1 = pdict1['policy']
    json2 = """{"policy": {
      "_II_em": {"2020": [20000], "2015": [15000]},
      "_ID_BenefitCap_Switch": {
        "2019": [[false, true, true, false, false, false, false]]
      },
      "_ID_BenefitCap_rt": {"2019": [0.2]}
    }}"""
    pdict2 = Calculator.read_json_param_files(reform_filename=json2,
                                              assump_filename=None,
                                              arrays_not_lists=True)
    rdict2 = pdict2['policy']
    assert len(rdict2) == len(rdict1)
    for year in rdict2.keys():
        if '_II_em' in rdict2[year].keys():
            assert np.allclose(rdict1[year]['_II_em'],
                               rdict2[year]['_II_em'],
                               atol=0.01, rtol=0.0)
        if '_ID_BenefitCap_rt' in rdict2[year].keys():
            assert np.allclose(rdict1[year]['_ID_BenefitCap_rt'],
                               rdict2[year]['_ID_BenefitCap_rt'],
                               atol=0.01, rtol=0.0)
        if '_ID_BenefitCap_Switch' in rdict2[year].keys():
            assert np.allclose(rdict1[year]['_ID_BenefitCap_Switch'],
                               rdict2[year]['_ID_BenefitCap_Switch'],
                               atol=0.01, rtol=0.0)
def test_translate_json_reform_suffixes_mars_indexed():
    # test read_json_param_files(...) using MARS-indexed parameter suffixes
    json1 = """{"policy": {
      "_II_em": {"2020": [20000], "2015": [15000]},
      "_STD_single": {"2018": [18000], "2016": [16000]},
      "_STD_widow": {"2017": [17000], "2019": [19000]}
    }}"""
    assump_json = """{
      "consumption": {},
      "behavior": {},
      "growdiff_baseline": {
        "_ACPIU": {"2013": [0.01]},
        "_AWAGE": {"2013": [0.01]}},
      "growdiff_response": {}
    }"""
    pdict1 = Calculator.read_json_param_files(reform_filename=json1,
                                              assump_filename=assump_json,
                                              arrays_not_lists=True)
    rdict1 = pdict1['policy']
    json2 = """{"policy": {
      "_STD": {"2016": [[16000.00, 12600.00, 6300.00,  9300.00, 12600.00]],
               "2017": [[16524.80, 13013.28, 6506.64,  9605.04, 17000.00]],
               "2018": [[18000.00, 13432.31, 6716.15,  9914.32, 17547.40]],
               "2019": [[18592.20, 13874.23, 6937.11, 10240.50, 19000.00]]},
      "_II_em": {"2020": [20000], "2015": [15000]}
    }}"""
    pdict2 = Calculator.read_json_param_files(reform_filename=json2,
                                              assump_filename=assump_json,
                                              arrays_not_lists=True)
    rdict2 = pdict2['policy']
    assert len(rdict2) == len(rdict1)
    for year in rdict2.keys():
        if '_II_em' in rdict2[year].keys():
            assert np.allclose(rdict1[year]['_II_em'],
                               rdict2[year]['_II_em'],
                               atol=0.01, rtol=0.0)
        if '_STD' in rdict2[year].keys():
            assert np.allclose(rdict1[year]['_STD'],
                               rdict2[year]['_STD'],
                               atol=0.01, rtol=0.0)
Exemple #11
0
def test_check_user_mods(puf_1991_path, reform_file, assump_file):
    usermods = list()
    with pytest.raises(ValueError):
        check_user_mods(usermods)
    usermods = Calculator.read_json_param_files(reform_file.name,
                                                assump_file.name)
    with pytest.raises(ValueError):
        check_user_mods(usermods)
    usermods['gdp_elasticity'] = dict()
    check_user_mods(usermods)
    usermods['unknown_key'] = dict()
    with pytest.raises(ValueError):
        check_user_mods(usermods)
Exemple #12
0
def test_run_gdp_elast_model(puf_1991_path, rjson, reform_file, assump_file):
    usermods = Calculator.read_json_param_files(reform_file.name,
                                                assump_file.name)
    usermods['gdp_elasticity'] = {'value': 0.36}
    fyr = 2016
    nyrs = 3
    tax_data = pd.read_csv(puf_1991_path)
    ans = dropq.run_gdp_elast_model(tax_data,
                                    start_year=fyr,
                                    user_mods=usermods,
                                    return_json=rjson,
                                    num_years=nyrs)
    assert len(ans) == (nyrs - 1)  # number of annual calculations done
Exemple #13
0
def test_run_nth_year_model(puf_1991_path, reform_file, assump_file):
    usermods = Calculator.read_json_param_files(reform_file.name,
                                                assump_file.name)
    usermods['gdp_elasticity'] = dict()
    tax_data = pd.read_csv(puf_1991_path)
    year_n = 2
    start_year = 2016
    non_json_results = dropq.run_nth_year_model(year_n,
                                                start_year,
                                                tax_data,
                                                usermods,
                                                return_json=False)
    assert len(non_json_results) == 13
def test_calc_all(reform_file, rawinputfile):
    cyr = 2016
    policy = Policy()
    param_dict = Calculator.read_json_param_files(reform_file.name, None)
    policy.implement_reform(param_dict['policy'])
    policy.set_year(cyr)
    nonpuf = Records(data=rawinputfile.name, gfactors=None,
                     weights=None, start_year=cyr)
    assert nonpuf.dim == RAWINPUTFILE_FUNITS
    calc = Calculator(policy=policy,
                      records=nonpuf,
                      sync_years=False)  # keeps raw data unchanged
    assert calc.current_year == cyr
    calc.calc_all()
Exemple #15
0
def test_run_model_with_usermods_from_files(puf_1991_path, reform_file,
                                            assump_file):
    usermods = Calculator.read_json_param_files(reform_file.name,
                                                assump_file.name)
    usermods['gdp_elasticity'] = dict()
    # for this usermods the computed seed = 4109528928
    fyr = 2016
    tax_data = pd.read_csv(puf_1991_path)
    (_, _, _, _, _, _, _, _, _, _,
     fiscal_tots) = dropq.run_model(tax_data,
                                    start_year=fyr,
                                    user_mods=usermods,
                                    return_json=True,
                                    num_years=3)
    assert fiscal_tots is not None
def test_read_json_reform_file_and_implement_reform(reform_file,
                                                    assump_file,
                                                    set_year):
    """
    Test reading and translation of reform file into a reform dictionary
    that is then used to call implement_reform method and Calculate.calc_all()
    NOTE: implement_reform called when policy.current_year == policy.start_year
    """
    policy = Policy()
    if set_year:
        policy.set_year(2015)
    param_dict = Calculator.read_json_param_files(reform_file.name,
                                                  assump_file.name)
    policy.implement_reform(param_dict['policy'])
    syr = policy.start_year
    amt_brk1 = policy._AMT_brk1
    assert amt_brk1[2015 - syr] == 200000
    assert amt_brk1[2016 - syr] > 200000
    assert amt_brk1[2017 - syr] == 300000
    assert amt_brk1[2018 - syr] > 300000
    ii_em = policy._II_em
    assert ii_em[2016 - syr] == 6000
    assert ii_em[2017 - syr] == 6000
    assert ii_em[2018 - syr] == 7500
    assert ii_em[2019 - syr] > 7500
    assert ii_em[2020 - syr] == 9000
    assert ii_em[2021 - syr] > 9000
    amt_em = policy._AMT_em
    assert amt_em[2016 - syr, 0] > amt_em[2015 - syr, 0]
    assert amt_em[2017 - syr, 0] > amt_em[2016 - syr, 0]
    assert amt_em[2018 - syr, 0] == amt_em[2017 - syr, 0]
    assert amt_em[2019 - syr, 0] == amt_em[2017 - syr, 0]
    assert amt_em[2020 - syr, 0] == amt_em[2017 - syr, 0]
    assert amt_em[2021 - syr, 0] > amt_em[2020 - syr, 0]
    assert amt_em[2022 - syr, 0] > amt_em[2021 - syr, 0]
    add4aged = policy._ID_Medical_frt_add4aged
    assert add4aged[2015 - syr] == -0.025
    assert add4aged[2016 - syr] == -0.025
    assert add4aged[2017 - syr] == 0.0
    assert add4aged[2022 - syr] == 0.0