def run_ccc_with_baseline_delta(base_params, reform_params, data=None):
"""
Runner script that kicks off the calculations for Cost-of-Capital-Calculator
Args:
test_run: boolean, True if test run (doesn't use puf.csv)
start_year: interger, tax year METRs computed for
user_params: dictionary, user defined parametesr for Cost-of-Capital-Calculator
Returns:
ModelDiffs: tuple, contains 6 dataframes for output by asset and
industry for baseline, refor, and difference
"""
base_output_by_asset, base_output_by_industry = \
run_ccc(base_params, True, data=data)
asset_row_grouping = {}
subset = zip(*(getattr(base_output_by_asset, at)
for at in ('Asset', 'asset_category', 'mettr_c',
'mettr_nc')))
for asset, cat, mettr_c, mettr_nc in subset:
if cat != cat: # A string column that may have NaN, so can't do isnan
cat = asset # These are some summary rows that don't have all info
asset, cat = map(replace_unicode_spaces, (asset, cat))
asset_row_grouping[cat] = asset_row_grouping[asset] =\
{'major_grouping': cat, 'summary_c': mettr_c,
'summary_nc': mettr_nc, }
industry_row_grouping = {}
subset = zip(*(getattr(base_output_by_industry, at)
for at in ('Industry', 'major_industry', 'mettr_c',
'mettr_nc')))
for industry, cat, mettr_c, mettr_nc in subset:
industry, cat = map(replace_unicode_spaces, (industry, cat))
industry_row_grouping[cat] = industry_row_grouping[industry] =\
{'major_grouping': cat, 'summary_c': mettr_c,
'summary_nc': mettr_nc, }
row_grouping = {
'asset': asset_row_grouping,
'industry': industry_row_grouping
}
reform_output_by_asset, reform_output_by_industry =\
run_ccc(reform_params, False, data=data)
changed_output_by_asset =\
diff_two_tables(reform_output_by_asset, base_output_by_asset)
changed_output_by_industry =\
diff_two_tables(reform_output_by_industry, base_output_by_industry)
# save output to csv - useful if run locally
base_output_by_industry.to_csv('baseline_byindustry.csv', encoding='utf-8')
reform_output_by_industry.to_csv('reform_byindustry.csv', encoding='utf-8')
base_output_by_asset.to_csv('baseline_byasset.csv', encoding='utf-8')
reform_output_by_asset.to_csv('reform_byasset.csv', encoding='utf-8')
changed_output_by_industry.to_csv('changed_byindustry.csv',
encoding='utf-8')
changed_output_by_asset.to_csv('changed_byasset.csv', encoding='utf-8')
return ModelDiffs(base_output_by_asset, reform_output_by_asset,
changed_output_by_asset, base_output_by_industry,
reform_output_by_industry, changed_output_by_industry,
row_grouping)
def test_diff_two_tables():
'''
Test of the diff_two_tables() function
'''
dict1 = {'var1': [1, 2, 3, 4, 5], 'var2': [2, 4, 6, 8, 10]}
dict2 = {'var1': [1, 2, 3, 4, 5], 'var2': [2, 4, 6, 8, 10]}
df1 = pd.DataFrame.from_dict(dict1)
df2 = pd.DataFrame.from_dict(dict2)
expected_dict = {'var1': [0, 0, 0, 0, 0], 'var2': [0, 0, 0, 0, 0]}
expected_df = pd.DataFrame.from_dict(expected_dict)
test_df = utils.diff_two_tables(df1, df2)
pd.testing.assert_frame_equal(test_df, expected_df)
# specify baseline and reform Calculator objects for 2019 calculations
assets = Assets()
baseline_parameters = Specification(year=cyr)
calc1 = Calculator(baseline_parameters, assets)
reform_parameters = Specification(year=cyr)
reform_parameters.update_specification(business_tax_reform)
calc2 = Calculator(reform_parameters, assets)
# do calculations by asset and by industry
baseln_assets_df = calc1.calc_by_asset()
reform_assets_df = calc2.calc_by_asset()
baseln_industry_df = calc1.calc_by_industry()
reform_industry_df = calc2.calc_by_industry()
# generate dataframes with reform-minus-baseline differences
diff_assets_df = diff_two_tables(reform_assets_df, baseln_assets_df)
diff_industry_df = diff_two_tables(reform_industry_df, baseln_industry_df)
# save dataframes to disk as csv files in this directory
baseln_industry_df.to_csv('baseline_byindustry.csv', float_format='%.5f')
reform_industry_df.to_csv('reform_byindustry.csv', float_format='%.5f')
baseln_assets_df.to_csv('baseline_byasset.csv', float_format='%.5f')
reform_assets_df.to_csv('reform_byasset.csv', float_format='%.5f')
diff_industry_df.to_csv('changed_byindustry.csv', float_format='%.5f')
diff_assets_df.to_csv('changed_byasset.csv', float_format='%.5f')
# create and show in browser a range plot
p = calc1.range_plot(calc2)
show(p)
def summary_table(self, calc, output_variable='mettr',
include_land=True, include_inventories=True,
output_type='csv', path=''):
'''
Create table summarizing the output_variable under the baseline
and reform policies.
Parameters
----------
calc : Calculator object
calc represents the reform while self represents the baseline
output_variable : string
specifies which output variable to summarize in the table
include_land : boolean
specifies whether to include land in overall calculations
include_inventories : boolean
specifies whether to include inventories in overall calculations
output_type : string
specifies the type of file to save table to:
- 'csv'
- 'tex'
- 'excel'
- 'json'
path : string
specifies path to save file with table to
Returns
-------
table saved to disk
'''
var_dict = {'mettr': 'Marginal Effective Total Tax Rate',
'metr': 'Marginal Effective Tax Rate',
'rho': 'Cost of Capital',
'ucc': 'User Cost of Capital',
'tax_wedge': 'Tax Wedge',
'z': 'NPV of Depreciation Deductions'}
self.calc_base()
calc.calc_base()
base_df = self.__assets.df
reform_df = calc.__assets.df
dfs = [base_df, reform_df]
dfs_out = []
for df in dfs:
if not include_land:
df = df.drop(df[df.asset_name == 'Land'].index,
inplace=True)
if not include_inventories:
df = df.drop(df[df.asset_name == 'Inventories'].index,
inplace=True)
# Compute overall separately by tax treatment
treat_df = pd.DataFrame(df.groupby(
['tax_treat']).apply(self.__f)).reset_index()
treat_df = self.calc_other(treat_df)
# Compute overall values, across corp and non-corp
# just making up a column with same value in all rows so can
# continute to use groupby
df['include'] = 1
all_df = pd.DataFrame.from_dict(
df.groupby(['include']).apply(self.__f).to_dict())
# set tax_treat to corporate b/c only corp and non-corp
# recognized in calc_other()
all_df['tax_treat'] = 'corporate'
all_df = self.calc_other(all_df)
all_df['tax_treat'] = 'all'
# Put df's together
dfs_out.append(pd.concat([treat_df, all_df],
ignore_index=True, copy=True,
sort=True).reset_index())
base_tab = dfs_out[0]
reform_tab = dfs_out[1]
# print('reform table = ', reform_tab)
diff_tab = diff_two_tables(base_tab, reform_tab)
table_dict = {
'': ['Overall', 'Corporations', ' Equity Financed',
' Debt Financed', 'Pass-Through Entities',
' Equity Financed', ' Debt Financed'],
var_dict[output_variable]: [
reform_tab[
reform_tab['tax_treat'] ==
'all'][output_variable + '_mix'].values[0],
reform_tab[
reform_tab['tax_treat'] ==
'corporate'][output_variable + '_mix'].values[0],
reform_tab[
reform_tab['tax_treat'] ==
'corporate'][output_variable + '_e'].values[0],
reform_tab[
reform_tab['tax_treat'] ==
'corporate'][output_variable + '_d'].values[0],
reform_tab[
reform_tab['tax_treat'] ==
'non-corporate'][output_variable + '_mix'].values[0],
reform_tab[
reform_tab['tax_treat'] ==
'non-corporate'][output_variable + '_e'].values[0],
reform_tab[
reform_tab['tax_treat'] ==
'non-corporate'][output_variable + '_d'].values[0]],
'Change from Baseline (pp)': [
diff_tab[
diff_tab['tax_treat'] ==
'all'][output_variable + '_mix'].values[0],
diff_tab[
diff_tab['tax_treat'] ==
'corporate'][output_variable + '_mix'].values[0],
diff_tab[
diff_tab['tax_treat'] ==
'corporate'][output_variable + '_e'].values[0],
diff_tab[
diff_tab['tax_treat'] ==
'corporate'][output_variable + '_d'].values[0],
diff_tab[
diff_tab['tax_treat'] ==
'non-corporate'][output_variable + '_mix'].values[0],
diff_tab[
diff_tab['tax_treat'] ==
'non-corporate'][output_variable + '_e'].values[0],
diff_tab[
diff_tab['tax_treat'] ==
'non-corporate'][output_variable + '_d'].values[0]]}
# Make df with dict so can use pandas functions
table_df = pd.DataFrame.from_dict(table_dict, orient='columns')
if output_type == 'tex':
table_df.to_latex(buf=path, index=False, na_rep='',
float_format=lambda x: '%.2f' % x)
elif output_type == 'csv':
table_df.to_csv(path_or_buf=path, index=False, na_rep='',
float_format="%.2f")
elif output_type == 'json':
table_df.to_json(path_or_buf=path, double_precision=2)
elif output_type == 'excel':
table_df.to_excel(excel_writer=path, index=False, na_rep='',
float_format="%.2f")
else:
print('Please enter a valid output format')
assert(False)