def test_incorrect_update_behavior():
with pytest.raises(ValueError):
Behavior().update_behavior([])
with pytest.raises(ValueError):
Behavior().update_behavior({2013: {'_BE_inc': [+0.2]}})
with pytest.raises(ValueError):
Behavior().update_behavior({2013: {'_BE_sub': [-0.2]}})
with pytest.raises(ValueError):
Behavior().update_behavior({2013: {'_BE_cg': [+0.8]}})
with pytest.raises(ValueError):
Behavior().update_behavior({2013: {'_BE_xx': [0.0]}})
with pytest.raises(ValueError):
Behavior().update_behavior({2013: {'_BE_xx_cpi': [True]}})
# year in update must be greater than or equal start year
with pytest.raises(ValueError):
Behavior(start_year=2014).update_behavior({2013: {'_BE_inc': [-0.2]}})
# year in update must be greater than or equal to current year
with pytest.raises(ValueError):
behv = Behavior(start_year=2014)
behv.set_year(2015)
behv.update_behavior({2014: {'_BE_inc': [-0.2]}})
# start year greater than start_year + DEFAULT_NUM_YEARS
with pytest.raises(ValueError):
Behavior().update_behavior({2040: {'_BE_inc': [-0.2]}})
# invalid start year
with pytest.raises(ValueError):
Behavior().update_behavior({'notayear': {'_BE_inc': [-0.2]}})
def test_incorrect_behavior_instantiation():
with pytest.raises(ValueError):
Behavior(start_year=2000)
with pytest.raises(ValueError):
Behavior(num_years=0)
with pytest.raises(FloatingPointError):
np.divide(1., 0.)
def test_incorrect_Behavior_instantiation():
with pytest.raises(ValueError):
behv = Behavior(behavior_dict=list())
bad_behv_dict = {'_BE_bad': {'start_year': 2013, 'value': [0.0]}}
with pytest.raises(ValueError):
behv = Behavior(behavior_dict=bad_behv_dict)
with pytest.raises(ValueError):
behv = Behavior(num_years=0)
def test_validate_param_names_types_errors():
behv0 = Behavior()
specs0 = {2020: {'_BE_bad': [-1.0]}}
with pytest.raises(ValueError):
behv0.update_behavior(specs0)
behv1 = Behavior()
specs1 = {2019: {'_BE_inc': [True]}}
with pytest.raises(ValueError):
behv1.update_behavior(specs1)
def test_validate_param_values_errors():
behv0 = Behavior()
specs0 = {2020: {'_BE_cg': [0.2]}}
with pytest.raises(ValueError):
behv0.update_behavior(specs0)
behv1 = Behavior()
specs1 = {2022: {'_BE_sub': [-0.2]}}
with pytest.raises(ValueError):
behv1.update_behavior(specs1)
behv2 = Behavior()
specs2 = {2020: {'_BE_cg': [-0.2], '_BE_sub': [0.3]}}
behv2.update_behavior(specs2)
def test_response_json(tests_path):
"""
Check that each JSON file can be converted into dictionaries that
can be used to construct objects needed for a Calculator object.
"""
responses_path = os.path.join(tests_path, '..', 'responses', '*.json')
for jpf in glob.glob(responses_path):
# read contents of jpf (JSON parameter filename)
jfile = open(jpf, 'r')
jpf_text = jfile.read()
# check that jpf_text can be used to construct objects
response_file = ('"consumption"' in jpf_text and
'"behavior"' in jpf_text and
'"growdiff_baseline"' in jpf_text and
'"growdiff_response"' in jpf_text)
if response_file:
# pylint: disable=protected-access
(con, beh, gdiff_base,
gdiff_resp) = Calculator._read_json_econ_assump_text(jpf_text)
cons = Consumption()
cons.update_consumption(con)
behv = Behavior()
behv.update_behavior(beh)
growdiff_baseline = Growdiff()
growdiff_baseline.update_growdiff(gdiff_base)
growdiff_response = Growdiff()
growdiff_response.update_growdiff(gdiff_resp)
else: # jpf_text is not a valid JSON response assumption file
print('test-failing-filename: ' +
jpf)
assert False
def test_correct_update_behavior():
beh = Behavior(start_year=2013)
beh.update_behavior({
2014: {
'_BE_sub': [0.5]
},
2015: {
'_BE_cg': [-1.2]
},
2016: {
'_BE_charity': [[-0.5, -0.5, -0.5]]
}
})
should_be = np.full((Behavior.DEFAULT_NUM_YEARS, ), 0.5)
should_be[0] = 0.0
assert np.allclose(beh._BE_sub, should_be, rtol=0.0)
assert np.allclose(beh._BE_inc,
np.zeros((Behavior.DEFAULT_NUM_YEARS, )),
rtol=0.0)
beh.set_year(2017)
assert beh.current_year == 2017
assert beh.BE_sub == 0.5
assert beh.BE_inc == 0.0
assert beh.BE_cg == -1.2
assert beh.BE_charity.tolist() == [-0.5, -0.5, -0.5]
def test_taxbrain_json(taxbrain_path): # pylint: disable=redefined-outer-name
"""
Check that each JSON parameter file can be converted into dictionaries
that can be used to construct objects needed for a Calculator object.
"""
for jpf in glob.glob(taxbrain_path):
# read contents of jpf (JSON parameter filename)
jfile = open(jpf, 'r')
jpf_text = jfile.read()
# check that jpf_text can be used to construct objects
if '"policy"' in jpf_text:
pol = Calculator.read_json_policy_reform_text(jpf_text)
policy = Policy()
policy.implement_reform(pol)
elif ('"consumption"' in jpf_text and
'"behavior"' in jpf_text and
'"growdiff_baseline"' in jpf_text and
'"growdiff_response"' in jpf_text):
(con, beh, gdiff_base,
gdiff_resp) = Calculator.read_json_econ_assump_text(jpf_text)
cons = Consumption()
cons.update_consumption(con)
behv = Behavior()
behv.update_behavior(beh)
growdiff_baseline = Growdiff()
growdiff_baseline.update_growdiff(gdiff_base)
growdiff_response = Growdiff()
growdiff_response.update_growdiff(gdiff_resp)
else: # jpf_text is not a valid JSON parameter file
print('test-failing-filename: ' +
jpf)
assert False
def test_make_behavioral_Calculator():
# create Records objects
records_x = Records(data=TAXDATA, weights=WEIGHTS, start_year=2009)
records_y = Records(data=TAXDATA, weights=WEIGHTS, start_year=2009)
# create Policy objects
policy_x = Policy()
policy_y = Policy()
# implement policy_y reform
reform = {2013: {"_II_rt7": [0.496]}}
policy_y.implement_reform(reform)
# create two Calculator objects
behavior_y = Behavior()
calc_x = Calculator(policy=policy_x, records=records_x)
calc_y = Calculator(policy=policy_y,
records=records_y,
behavior=behavior_y)
# create behavioral calculators and vary substitution and income effects
behavior1 = {2013: {"_BE_sub": [0.4], "_BE_inc": [0.15]}}
behavior_y.update_behavior(behavior1)
calc_y_behavior1 = behavior(calc_x, calc_y)
behavior2 = {2013: {"_BE_sub": [0.5], "_BE_inc": [0.15]}}
behavior_y.update_behavior(behavior2)
calc_y_behavior2 = behavior(calc_x, calc_y)
behavior3 = {2013: {"_BE_sub": [0.4], "_BE_inc": [0.0]}}
behavior_y.update_behavior(behavior3)
calc_y_behavior3 = behavior(calc_x, calc_y)
# check that total income tax liability differs across the three behaviors
assert (calc_y_behavior1.records._iitax.sum() !=
calc_y_behavior2.records._iitax.sum() !=
calc_y_behavior3.records._iitax.sum())
def run_reform(name, reform, behave):
puf = pd.read_csv("../tax-calculator/puf.csv")
policy_base = Policy(start_year=2013)
records_base = Records(puf)
policy_reform = Policy()
records_reform = Records(puf)
bhv = Behavior()
calcbase = Calculator(policy=policy_base, records=records_base)
calcreform = Calculator(policy=policy_reform,
records=records_reform,
behavior=bhv)
policy_reform.implement_reform(reform)
calcbase.advance_to_year(CURRENT_YEAR)
calcreform.advance_to_year(CURRENT_YEAR)
calcbase.calc_all()
calcreform.calc_all()
bhv.update_behavior(behave)
calc_behav = Behavior.response(calcbase, calcreform)
calc_behav.calc_all()
base_list = multiyear_diagnostic_table(calcbase, 10)
reform_list = multiyear_diagnostic_table(calc_behav, 10)
difflist = (reform_list.iloc[18] - base_list.iloc[18])
return difflist
def test_xtr_graph_plot(cps_subsample):
calc = Calculator(policy=Policy(),
records=Records.cps_constructor(data=cps_subsample),
behavior=Behavior())
mtr = 0.20 * np.ones_like(cps_subsample['e00200'])
vdf = calc.dataframe(['s006', 'MARS', 'c00100'])
vdf['mtr1'] = mtr
vdf['mtr2'] = mtr
gdata = mtr_graph_data(vdf,
calc.current_year,
mtr_measure='ptax',
income_measure='agi',
dollar_weighting=False)
gplot = xtr_graph_plot(gdata)
assert gplot
vdf = calc.dataframe(['s006', 'expanded_income'])
vdf['mtr1'] = mtr
vdf['mtr2'] = mtr
gdata = mtr_graph_data(vdf,
calc.current_year,
mtr_measure='itax',
alt_e00200p_text='Taxpayer Earnings',
income_measure='expanded_income',
dollar_weighting=False)
assert isinstance(gdata, dict)
def test_behavioral_response_Calculator(cps_subsample):
# create Records objects
records_x = Records.cps_constructor(data=cps_subsample)
records_y = Records.cps_constructor(data=cps_subsample)
year = records_x.current_year
# create Policy objects
policy_x = Policy()
policy_y = Policy()
# implement policy_y reform
reform = {year: {'_II_rt7': [0.496],
'_PT_rt7': [0.496]}}
policy_y.implement_reform(reform)
# create two Calculator objects
behavior_y = Behavior()
calc_x = Calculator(policy=policy_x, records=records_x)
calc_y = Calculator(policy=policy_y, records=records_y,
behavior=behavior_y)
# test incorrect use of Behavior._mtr_xy method
with pytest.raises(ValueError):
behv = Behavior._mtr_xy(calc_x, calc_y,
mtr_of='e00200p',
tax_type='nonsense')
# vary substitution and income effects in calc_y
behavior0 = {year: {'_BE_sub': [0.0],
'_BE_cg': [0.0],
'_BE_charity': [[0.0, 0.0, 0.0]]}}
behavior_y.update_behavior(behavior0)
calc_y_behavior0 = Behavior.response(calc_x, calc_y)
behavior1 = {year: {'_BE_sub': [0.3], '_BE_inc': [-0.1], '_BE_cg': [0.0],
'_BE_subinc_wrt_earnings': [True]}}
behavior_y.update_behavior(behavior1)
assert behavior_y.has_response() is True
epsilon = 1e-9
assert abs(behavior_y.BE_sub - 0.3) < epsilon
assert abs(behavior_y.BE_inc - -0.1) < epsilon
assert abs(behavior_y.BE_cg - 0.0) < epsilon
calc_y_behavior1 = Behavior.response(calc_x, calc_y)
behavior2 = {year: {'_BE_sub': [0.5], '_BE_cg': [-0.8]}}
behavior_y.update_behavior(behavior2)
calc_y_behavior2 = Behavior.response(calc_x, calc_y)
behavior3 = {year: {'_BE_inc': [-0.2], '_BE_cg': [-0.8]}}
behavior_y.update_behavior(behavior3)
calc_y_behavior3 = Behavior.response(calc_x, calc_y)
behavior4 = {year: {'_BE_cg': [-0.8]}}
behavior_y.update_behavior(behavior4)
calc_y_behavior4 = Behavior.response(calc_x, calc_y)
behavior5 = {year: {'_BE_charity': [[-0.5, -0.5, -0.5]]}}
behavior_y.update_behavior(behavior5)
calc_y_behavior5 = Behavior.response(calc_x, calc_y)
# check that total income tax liability differs across the
# six sets of behavioral-response elasticities
assert (calc_y_behavior0.records.iitax.sum() !=
calc_y_behavior1.records.iitax.sum() !=
calc_y_behavior2.records.iitax.sum() !=
calc_y_behavior3.records.iitax.sum() !=
calc_y_behavior4.records.iitax.sum() !=
calc_y_behavior5.records.iitax.sum())
# test incorrect _mtr_xy() usage
with pytest.raises(ValueError):
Behavior._mtr_xy(calc_x, calc_y, mtr_of='e00200p', tax_type='?')
def test_validate_param_names_types_errors():
behv0 = Behavior()
specs0 = {2020: {'_BE_bad': [-1.0]}}
with pytest.raises(ValueError):
behv0.update_behavior(specs0)
behv1 = Behavior()
specs1 = {2019: {'_BE_inc': [True]}}
with pytest.raises(ValueError):
behv1.update_behavior(specs1)
behv2 = Behavior()
specs2 = {2020: {'_BE_charity': ['not-a-number']}}
with pytest.raises(ValueError):
behv2.update_behavior(specs2)
behv3 = Behavior()
specs3 = {2020: {'_BE_subinc_wrt_earnings': [0.3]}}
with pytest.raises(ValueError):
behv3.update_behavior(specs3)
def test_incorrect_behavior_instantiation():
with pytest.raises(ValueError):
Behavior(behavior_dict=list())
bad_behv_dict = {
'_BE_bad': {'start_year': 2013, 'value': [0.0]}
}
with pytest.raises(ValueError):
Behavior(behavior_dict=bad_behv_dict)
with pytest.raises(ValueError):
Behavior(num_years=0)
with pytest.raises(FloatingPointError):
np.divide(1., 0.)
with pytest.raises(ValueError):
Behavior(behavior_dict={})
bad_behv_dict = {
'_BE_subinc_wrt_earnings': {'start_year': 2013, 'value': [True]}
}
with pytest.raises(ValueError):
Behavior(behavior_dict=bad_behv_dict)
bad_behv_dict = {
'_BE_subinc_wrt_earnings': {'start_year': 2013, 'value': [True]},
'_BE_sub': {'start_year': 2017, 'value': [0.25]}
}
with pytest.raises(ValueError):
Behavior(behavior_dict=bad_behv_dict)
bad_behv_dict = {
54321: {'start_year': 2013, 'value': [0.0]}
}
with pytest.raises(ValueError):
Behavior(behavior_dict=bad_behv_dict)
def test_behavioral_response_Calculator(puf_1991, weights_1991):
# create Records objects
records_x = Records(data=puf_1991, weights=weights_1991, start_year=2009)
records_y = Records(data=puf_1991, weights=weights_1991, start_year=2009)
# create Policy objects
policy_x = Policy()
policy_y = Policy()
# implement policy_y reform
reform = {2013: {'_II_rt7': [0.496],
'_PT_rt7': [0.496]}}
policy_y.implement_reform(reform)
# create two Calculator objects
behavior_y = Behavior()
calc_x = Calculator(policy=policy_x, records=records_x)
calc_y = Calculator(policy=policy_y, records=records_y,
behavior=behavior_y)
# test incorrect use of Behavior._mtr_xy method
with pytest.raises(ValueError):
behv = Behavior._mtr_xy(calc_x, calc_y,
mtr_of='e00200p',
tax_type='nonsense')
# vary substitution and income effects in calc_y
behavior0 = {2013: {'_BE_sub': [0.0],
'_BE_cg': [0.0],
'_BE_charity': [[0.0, 0.0, 0.0]]}}
behavior_y.update_behavior(behavior0)
calc_y_behavior0 = Behavior.response(calc_x, calc_y)
behavior1 = {2013: {'_BE_sub': [0.3], '_BE_cg': [0.0]}}
behavior_y.update_behavior(behavior1)
assert behavior_y.has_response() is True
assert behavior_y.BE_sub == 0.3
assert behavior_y.BE_inc == 0.0
assert behavior_y.BE_cg == 0.0
calc_y_behavior1 = Behavior.response(calc_x, calc_y)
behavior2 = {2013: {'_BE_sub': [0.5], '_BE_cg': [-0.8]}}
behavior_y.update_behavior(behavior2)
calc_y_behavior2 = Behavior.response(calc_x, calc_y)
behavior3 = {2013: {'_BE_inc': [-0.2], '_BE_cg': [-0.8]}}
behavior_y.update_behavior(behavior3)
calc_y_behavior3 = Behavior.response(calc_x, calc_y)
behavior4 = {2013: {'_BE_cg': [-0.8]}}
behavior_y.update_behavior(behavior4)
calc_y_behavior4 = Behavior.response(calc_x, calc_y)
behavior5 = {2013: {'_BE_charity': [[-0.5, -0.5, -0.5]]}}
behavior_y.update_behavior(behavior5)
calc_y_behavior5 = Behavior.response(calc_x, calc_y)
# check that total income tax liability differs across the
# six sets of behavioral-response elasticities
assert (calc_y_behavior0.records.iitax.sum() !=
calc_y_behavior1.records.iitax.sum() !=
calc_y_behavior2.records.iitax.sum() !=
calc_y_behavior3.records.iitax.sum() !=
calc_y_behavior4.records.iitax.sum() !=
calc_y_behavior5.records.iitax.sum())
# test incorrect _mtr_xy() usage
with pytest.raises(ValueError):
Behavior._mtr_xy(calc_x, calc_y, mtr_of='e00200p', tax_type='?')
def reform_warnings_errors(user_mods, using_puf):
"""
The reform_warnings_errors function assumes user_mods is a dictionary
returned by the Calculator.read_json_param_objects() function.
This function returns a dictionary containing five STR:STR subdictionaries,
where the dictionary keys are: 'policy', 'behavior', consumption',
'growdiff_baseline' and 'growdiff_response'; and the subdictionaries are:
{'warnings': '<empty-or-message(s)>', 'errors': '<empty-or-message(s)>'}.
Note that non-policy parameters have no warnings, so the 'warnings'
string for the non-policy parameters is always empty.
"""
rtn_dict = {'policy': {'warnings': '', 'errors': ''},
'behavior': {'warnings': '', 'errors': ''},
'consumption': {'warnings': '', 'errors': ''},
'growdiff_baseline': {'warnings': '', 'errors': ''},
'growdiff_response': {'warnings': '', 'errors': ''}}
# create GrowDiff objects
gdiff_baseline = GrowDiff()
try:
gdiff_baseline.update_growdiff(user_mods['growdiff_baseline'])
except ValueError as valerr_msg:
rtn_dict['growdiff_baseline']['errors'] = valerr_msg.__str__()
gdiff_response = GrowDiff()
try:
gdiff_response.update_growdiff(user_mods['growdiff_response'])
except ValueError as valerr_msg:
rtn_dict['growdiff_response']['errors'] = valerr_msg.__str__()
# create Growfactors object
growfactors = GrowFactors()
gdiff_baseline.apply_to(growfactors)
gdiff_response.apply_to(growfactors)
# create Policy object
pol = Policy(gfactors=growfactors)
try:
pol.implement_reform(user_mods['policy'],
print_warnings=False,
raise_errors=False)
if using_puf:
rtn_dict['policy']['warnings'] = pol.parameter_warnings
rtn_dict['policy']['errors'] = pol.parameter_errors
except ValueError as valerr_msg:
rtn_dict['policy']['errors'] = valerr_msg.__str__()
# create Behavior object
behv = Behavior()
try:
behv.update_behavior(user_mods['behavior'])
except ValueError as valerr_msg:
rtn_dict['behavior']['errors'] = valerr_msg.__str__()
# create Consumption object
consump = Consumption()
try:
consump.update_consumption(user_mods['consumption'])
except ValueError as valerr_msg:
rtn_dict['consumption']['errors'] = valerr_msg.__str__()
# return composite dictionary of warnings/errors
return rtn_dict
def reform_warnings_errors(user_mods):
"""
The reform_warnings_errors function assumes user_mods is a dictionary
returned by the Calculator.read_json_param_objects() function.
This function returns a dictionary containing two STR:STR pairs:
{'warnings': '<empty-or-message(s)>', 'errors': '<empty-or-message(s)>'}
In each pair the second string is empty if there are no messages.
Any returned messages are generated using current_law_policy.json
information on known policy parameter names and parameter value ranges.
Note that this function will return one or more error messages if
the user_mods['policy'] dictionary contains any unknown policy
parameter names or if any *_cpi parameters have values other than
True or False. These situations prevent implementing the policy
reform specified in user_mods, and therefore, no range-related
warnings or errors will be returned in this case.
"""
rtn_dict = {
'policy': {
'warnings': '',
'errors': ''
},
'behavior': {
'warnings': '',
'errors': ''
}
}
# create Growfactors object
gdiff_baseline = Growdiff()
gdiff_baseline.update_growdiff(user_mods['growdiff_baseline'])
gdiff_response = Growdiff()
gdiff_response.update_growdiff(user_mods['growdiff_response'])
growfactors = Growfactors()
gdiff_baseline.apply_to(growfactors)
gdiff_response.apply_to(growfactors)
# create Policy object and implement reform
pol = Policy(gfactors=growfactors)
try:
pol.implement_reform(user_mods['policy'],
print_warnings=False,
raise_errors=False)
rtn_dict['policy']['warnings'] = pol.parameter_warnings
rtn_dict['policy']['errors'] = pol.parameter_errors
except ValueError as valerr_msg:
rtn_dict['policy']['errors'] = valerr_msg.__str__()
# create Behavior object and implement revisions
# Note that Behavior does not have a `parameter_warnings`
# attribute.
behv = Behavior()
try:
behv.update_behavior(user_mods['behavior'])
rtn_dict['behavior']['errors'] = behv.parameter_errors
except ValueError as valerr_msg:
rtn_dict['behavior']['errors'] = valerr_msg.__str__()
return rtn_dict
def test_xtr_graph_plot_no_bokeh(records_2009):
import taxcalc
taxcalc.utils.BOKEH_AVAILABLE = False
calc = Calculator(policy=Policy(),
records=records_2009,
behavior=Behavior())
gdata = mtr_graph_data(calc, calc)
with pytest.raises(RuntimeError):
gplot = xtr_graph_plot(gdata)
taxcalc.utils.BOKEH_AVAILABLE = True
def test_future_update_behavior():
behv = Behavior()
assert behv.current_year == behv.start_year
assert behv.has_response() is False
cyr = 2020
behv.set_year(cyr)
behv.update_behavior({cyr: {'_BE_cg': [-1.0]}})
assert behv.current_year == cyr
assert behv.has_response() is True
behv.set_year(cyr - 1)
assert behv.has_response() is False
def reform_results(reform_dict, puf_data, reform_2017_law):
"""
Return actual results of the reform specified in reform_dict.
"""
# pylint: disable=too-many-locals
rec = Records(data=puf_data)
# create baseline Calculator object, calc1
pol = Policy()
if reform_dict['baseline'] == '2017_law.json':
pol.implement_reform(reform_2017_law)
elif reform_dict['baseline'] == 'current_law_policy.json':
pass
else:
msg = 'illegal baseline value {}'
raise ValueError(msg.format(reform_dict['baseline']))
calc1 = Calculator(policy=pol, records=rec, verbose=False, behavior=None)
# create reform Calculator object, calc2, with possible behavioral response
start_year = reform_dict['start_year']
beh = Behavior()
if '_BE_cg' in reform_dict['value']:
elasticity = reform_dict['value']['_BE_cg']
del reform_dict['value']['_BE_cg'] # in order to have a valid reform
beh_assump = {start_year: {'_BE_cg': elasticity}}
beh.update_behavior(beh_assump)
reform = {start_year: reform_dict['value']}
pol.implement_reform(reform)
calc2 = Calculator(policy=pol, records=rec, verbose=False, behavior=beh)
# increment both Calculator objects to reform's start_year
calc1.advance_to_year(start_year)
calc2.advance_to_year(start_year)
# calculate prereform and postreform output for several years
output_type = reform_dict['output_type']
num_years = 4
results = list()
for _ in range(0, num_years):
calc1.calc_all()
prereform = calc1.array(output_type)
if calc2.behavior_has_response():
calc2_br = Behavior.response(calc1, calc2)
postreform = calc2_br.array(output_type)
else:
calc2.calc_all()
postreform = calc2.array(output_type)
diff = postreform - prereform
weighted_sum_diff = (diff * calc1.array('s006')).sum() * 1.0e-9
results.append(weighted_sum_diff)
calc1.increment_year()
calc2.increment_year()
# write actual results to actual_str
actual_str = 'Tax-Calculator'
for iyr in range(0, num_years):
actual_str += ',{:.1f}'.format(results[iyr])
return actual_str
def test_incorrect_update_behavior():
behv = Behavior()
with pytest.raises(ValueError):
behv.update_behavior({2013: {'_BE_inc': [+0.2]}})
with pytest.raises(ValueError):
behv.update_behavior({2013: {'_BE_sub': [-0.2]}})
with pytest.raises(ValueError):
behv.update_behavior({2013: {'_BE_cg': [+0.8]}})
with pytest.raises(ValueError):
behv.update_behavior({2013: {'_BE_xx': [0.0]}})
with pytest.raises(ValueError):
behv.update_behavior({2013: {'_BE_xx_cpi': [True]}})
def test_multiyear_diagnostic_table(records_2009):
behv = Behavior()
calc = Calculator(policy=Policy(), records=records_2009, behavior=behv)
with pytest.raises(ValueError):
adt = multiyear_diagnostic_table(calc, 0)
with pytest.raises(ValueError):
adt = multiyear_diagnostic_table(calc, 20)
adt = multiyear_diagnostic_table(calc, 3)
assert isinstance(adt, DataFrame)
behv.update_behavior({2013: {'_BE_sub': [0.3]}})
assert calc.behavior.has_response()
adt = multiyear_diagnostic_table(calc, 3)
assert isinstance(adt, DataFrame)
def reform_results(reform_dict, puf_data):
"""
Return actual results of the reform specified in reform_dict.
"""
# pylint: disable=too-many-locals
# create current-law-policy Calculator object
pol1 = Policy()
rec1 = Records(data=puf_data)
calc1 = Calculator(policy=pol1, records=rec1, verbose=False, behavior=None)
# create reform Calculator object with possible behavioral responses
start_year = reform_dict['start_year']
beh2 = Behavior()
if '_BE_cg' in reform_dict['value']:
elasticity = reform_dict['value']['_BE_cg']
del reform_dict['value']['_BE_cg'] # in order to have a valid reform
beh_assump = {start_year: {'_BE_cg': elasticity}}
beh2.update_behavior(beh_assump)
reform = {start_year: reform_dict['value']}
pol2 = Policy()
pol2.implement_reform(reform)
rec2 = Records(data=puf_data)
calc2 = Calculator(policy=pol2, records=rec2, verbose=False, behavior=beh2)
# increment both calculators to reform's start_year
calc1.advance_to_year(start_year)
calc2.advance_to_year(start_year)
# calculate prereform and postreform output for several years
output_type = reform_dict['output_type']
num_years = 4
results = list()
for _ in range(0, num_years):
calc1.calc_all()
prereform = getattr(calc1.records, output_type)
if calc2.behavior.has_response():
calc_clp = calc2.current_law_version()
calc2_br = Behavior.response(calc_clp, calc2)
postreform = getattr(calc2_br.records, output_type)
else:
calc2.calc_all()
postreform = getattr(calc2.records, output_type)
diff = postreform - prereform
weighted_sum_diff = (diff * calc1.records.s006).sum() * 1.0e-9
results.append(weighted_sum_diff)
calc1.increment_year()
calc2.increment_year()
# write actual results to actual_str
reform_description = reform_dict['name']
actual_str = '{}\n'.format(reform_description)
actual_str += 'Tax-Calculator'
for iyr in range(0, num_years):
actual_str += ',{:.1f}'.format(results[iyr])
return actual_str
def test_validate_param_values_errors():
behv0 = Behavior()
specs0 = {2020: {'_BE_cg': [0.2]}}
behv0.update_behavior(specs0, raise_errors=False)
assert len(behv0.parameter_errors) > 0
behv1 = Behavior()
specs1 = {2022: {'_BE_sub': [-0.2]}}
behv1.update_behavior(specs1, raise_errors=False)
assert len(behv1.parameter_errors) > 0
behv2 = Behavior()
specs2 = {
2020: {
'_BE_subinc_wrt_earnings': [True],
'_BE_cg': [-0.2],
'_BE_sub': [0.3]
}
}
behv2.update_behavior(specs2, raise_errors=False)
assert len(behv2.parameter_errors) == 0
behv3 = Behavior()
specs3 = {2022: {'_BE_sub': [-0.2]}}
with pytest.raises(ValueError):
behv3.update_behavior(specs1, raise_errors=True)
def test_incorrect_update_behavior():
with pytest.raises(ValueError):
Behavior().update_behavior({2013: {'_BE_inc': [+0.2]}})
with pytest.raises(ValueError):
Behavior().update_behavior({2013: {'_BE_sub': [-0.2]}})
with pytest.raises(ValueError):
Behavior().update_behavior({2017: {'_BE_subinc_wrt_earnings': [2]}})
with pytest.raises(ValueError):
Behavior().update_behavior({2020: {'_BE_subinc_wrt_earnings': [True]}})
with pytest.raises(ValueError):
Behavior().update_behavior({2013: {'_BE_charity': [[0.2, -0.2, 0.2]]}})
with pytest.raises(ValueError):
Behavior().update_behavior({2013: {'_BE_cg': [+0.8]}})
with pytest.raises(ValueError):
Behavior().update_behavior({2013: {'_BE_xx': [0.0]}})
with pytest.raises(ValueError):
Behavior().update_behavior({2013: {'_BE_xx_cpi': [True]}})
def test_multiyear_diagnostic_table(cps_subsample):
rec = Records.cps_constructor(data=cps_subsample)
pol = Policy()
beh = Behavior()
calc = Calculator(policy=pol, records=rec, behavior=beh)
with pytest.raises(ValueError):
multiyear_diagnostic_table(calc, 0)
with pytest.raises(ValueError):
multiyear_diagnostic_table(calc, 20)
adt = multiyear_diagnostic_table(calc, 3)
assert isinstance(adt, pd.DataFrame)
beh.update_behavior({2013: {'_BE_sub': [0.3]}})
calc = Calculator(policy=pol, records=rec, behavior=beh)
assert calc.behavior.has_response()
adt = multiyear_diagnostic_table(calc, 3)
assert isinstance(adt, pd.DataFrame)
def test_xtr_graph_plot(records_2009):
calc = Calculator(policy=Policy(),
records=records_2009,
behavior=Behavior())
gdata = mtr_graph_data(calc,
calc,
mtr_measure='ptax',
income_measure='agi',
dollar_weighting=False)
gplot = xtr_graph_plot(gdata)
assert gplot
gdata = mtr_graph_data(calc,
calc,
mtr_measure='itax',
income_measure='expanded_income',
dollar_weighting=False)
assert type(gdata) == dict
def test_xtr_graph_plot(cps_subsample):
calc = Calculator(policy=Policy(),
records=Records.cps_constructor(data=cps_subsample),
behavior=Behavior())
gdata = mtr_graph_data(calc,
calc,
mtr_measure='ptax',
income_measure='agi',
dollar_weighting=False)
gplot = xtr_graph_plot(gdata)
assert gplot
gdata = mtr_graph_data(calc,
calc,
mtr_measure='itax',
alt_e00200p_text='Taxpayer Earnings',
income_measure='expanded_income',
dollar_weighting=False)
assert isinstance(gdata, dict)
def test_make_Calculator(cps_subsample):
parm = Policy(start_year=2014, num_years=9)
assert parm.current_year == 2014
recs = Records.cps_constructor(data=cps_subsample)
consump = Consumption()
consump.update_consumption({2014: {'_MPC_e20400': [0.05]}})
assert consump.current_year == 2013
calc = Calculator(policy=parm, records=recs, consumption=consump,
behavior=Behavior())
assert calc.current_year == 2014
# test incorrect Calculator instantiation:
with pytest.raises(ValueError):
calc = Calculator(policy=None, records=recs)
with pytest.raises(ValueError):
calc = Calculator(policy=parm, records=None)
with pytest.raises(ValueError):
calc = Calculator(policy=parm, records=recs, behavior=list())
with pytest.raises(ValueError):
calc = Calculator(policy=parm, records=recs, consumption=list())
def test_myr_diag_table_w_behv(cps_subsample):
pol = Policy()
rec = Records.cps_constructor(data=cps_subsample)
year = rec.current_year
beh = Behavior()
calc = Calculator(policy=pol, records=rec, behavior=beh)
assert calc.current_year == year
reform = {year: {'_II_rt7': [0.33], '_PT_rt7': [0.33]}}
pol.implement_reform(reform)
reform_behav = {year: {'_BE_sub': [0.4], '_BE_cg': [-3.67]}}
beh.update_behavior(reform_behav)
calc_clp = calc.current_law_version()
calc_beh = Behavior.response(calc_clp, calc)
calc_beh.calc_all()
liabilities_x = (calc_beh.records.combined * calc_beh.records.s006).sum()
adt = multiyear_diagnostic_table(calc_beh, 1)
# extract combined liabilities as a float and
# adopt units of the raw calculator data in liabilities_x
liabilities_y = adt.iloc[19].tolist()[0] * 1e9
assert np.allclose(liabilities_x, liabilities_y, atol=0.01, rtol=0.0)