import os
import paramtools
import marshmallow as ma
# import ccc
from ccc.get_taxcalc_rates import get_rates
from ccc.utils import DEFAULT_START_YEAR
import ccc.paramfunctions as pf
CURRENT_PATH = os.path.abspath(os.path.dirname(__file__))
[docs]class Specification(paramtools.Parameters):
'''
Specification class, contains model parameters.
Inherits ParamTools Parameters abstract base class.
'''
defaults = os.path.join(CURRENT_PATH, "default_parameters.json")
label_to_extend = "year"
array_first = True
def __init__(self, test=False, baseline=False,
year=DEFAULT_START_YEAR, call_tc=False, iit_reform={},
data='cps'):
super().__init__()
self.set_state(year=year)
self.test = test
self.baseline = baseline
self.year = year
self.iit_reform = iit_reform
self.data = data
# initialize parameter values from JSON
self.ccc_initialize(call_tc=call_tc)
[docs] def ccc_initialize(self, call_tc=False):
'''
ParametersBase reads JSON file and sets attributes to self
Next call self.compute_default_params for further initialization
Args:
call_tc (bool): whether to use Tax-Calculator to estimate
marginal tax rates
Returns:
None
'''
if call_tc:
# Find individual income tax rates from Tax-Calculator
indiv_rates = get_rates(self.baseline, self.year,
self.iit_reform, self.data)
self.tau_pt = indiv_rates['tau_pt']
self.tau_div = indiv_rates['tau_div']
self.tau_int = indiv_rates['tau_int']
self.tau_scg = indiv_rates['tau_scg']
self.tau_lcg = indiv_rates['tau_lcg']
self.tau_td = indiv_rates['tau_td']
self.tau_h = indiv_rates['tau_h']
# does cheap calculations to find parameter values
self.compute_default_params()
[docs] def compute_default_params(self):
'''
Does cheap calculations to return parameter values
'''
self.financing_list = ['mix', 'd', 'e']
self.entity_list = ['c', 'pt']
# If new_view, then don't assume don't pay out any dividends
# This because under new view, equity investments are financed
# with retained earnings
if self.new_view:
self.m = 1
# Get after-tax return to savers
self.s, E_pt = pf.calc_s(self)
# Set rate of 1st layer of taxation on investment income
self.u = {'c': self.CIT_rate}
if not self.pt_entity_tax_ind.all():
self.u['pt'] = self.tau_pt
else:
self.u['pt'] = self.pt_entity_tax_rate
E_dict = {'c': self.E_c, 'pt': E_pt}
# Allowance for Corporate Equity
ace_dict = {'c': self.ace_c, 'pt': self.ace_pt}
# Limitation on interest deduction
int_haircut_dict = {'c': self.interest_deduct_haircut_c,
'pt': self.interest_deduct_haircut_pt}
# Debt financing ratios
f_dict = {'c': {'mix': self.f_c, 'd': 1.0, 'e': 0.0},
'pt': {'mix': self.f_pt, 'd': 1.0, 'e': 0.0}}
# Compute firm discount factors
self.r = {}
for t in self.entity_list:
self.r[t] = {}
for f in self.financing_list:
self.r[t][f] = pf.calc_r(
self.u[t],
self.nominal_interest_rate,
self.inflation_rate,
self.ace_int_rate,
f_dict[t][f],
int_haircut_dict[t],
E_dict[t],
ace_dict[t]
)
# Compute firm after-tax rates of return
r_prime = {}
for t in self.entity_list:
r_prime[t] = {}
for f in self.financing_list:
r_prime[t][f] = pf.calc_r_prime(
self.nominal_interest_rate,
self.inflation_rate,
f_dict[t][f],
E_dict[t]
)
# if no entity level taxes on pass-throughs, ensure mettr and metr
# on non-corp entities the same
if not self.pt_entity_tax_ind:
for f in self.financing_list:
r_prime['pt'][f] = self.s['pt'][f] + self.inflation_rate
# if entity level tax, assume distribute earnings at same rate corps
# distribute dividends and these are taxed at dividends tax rate
# (which seems likely). Also implicitly assumed that if entity
# level tax, then only additional taxes on pass-through income are
# capital gains and dividend taxes
else:
# keep debt and equity financing ratio the same even though now
# entity level tax that might now favor debt
self.s['pt']['mix'] = (self.f_pt * self.s['pt']['d'] +
(1 - self.f_pt) * self.s['c']['e'])
self.r_prime = r_prime
# Map string tax methods into multiple of declining balance
self.tax_methods = {'DB 200%': 2.0, 'DB 150%': 1.5, 'SL': 1.0,
'Economic': 1.0, 'Expensing': 1.0}
# Create dictionaries with depreciation system and rate of bonus
# depreciation by asset class
class_list = [3, 5, 7, 10, 15, 20, 25, 27.5, 39]
class_list_str = [
(str(i) if i != 27.5 else '27_5') for i in class_list
]
self.bonus_deprec = {}
for cl in class_list_str:
self.bonus_deprec[cl] = getattr(
self, 'BonusDeprec_{}yr'.format(cl))
# to handle land and inventories
# this is fixed later, but should work on this
self.bonus_deprec['100'] = 0.0
[docs] def default_parameters(self):
'''
Return Specification object same as self except it contains
default values of all the parameters.
Returns:
dps (CCC Specification object): Specification instance with
the default parameter values
'''
dps = Specification()
return dps
[docs] def update_specification(self, revision, raise_errors=True):
'''
Updates parameter specification with values in revision dictionary.
Args:
revision (dict): dictionary or JSON string with one or more
`PARAM: YEAR-VALUE-DICTIONARY` pairs
raise_errors (boolean):
if True (the default), raises ValueError when
`parameter_errors` exists;
if False, does not raise ValueError when
`parameter_errors` exists and leaves error handling
to caller of the update_specification method.
Returns:
None
Raises:
ValueError: if `raise_errors` is True AND
`_validate_parameter_names_types` generates errors OR
`_validate_parameter_values` generates errors.
Notes:
Given a revision dictionary, typical usage of the
Specification class is as follows::
>>> spec = Specification()
>>> spec.update_specification(revision)
An example of a multi-parameter revision dictionary is as follows::
>>> revison = {
'CIT_rate': {2021: [0.25]},
'BonusDeprec_3yr': {2021: 0.60},
}
'''
if not (isinstance(revision, dict) or
isinstance(revision, str)):
raise ValueError(
'ERROR: revision is not a dictionary or string')
self.adjust(revision, raise_errors=raise_errors)
self.compute_default_params()
[docs] @staticmethod
def _read_json_revision(obj):
'''
Return a revision dictionary, which is suitable for use with the
update_specification method, that is derived from the specified
JSON object, which can be None or a string containing
a local filename,
a URL beginning with 'http' pointing to a JSON file hosted
online, or a valid JSON text.
'''
return paramtools.Parameters.read_params(obj, 'revision')
# end of Specification class
class DepreciationRules(ma.Schema):
# set some field validation ranges that can't set in JSON
life = ma.fields.Float(validate=ma.validate.Range(min=0, max=100))
method = ma.fields.String(
validate=ma.validate.OneOf(choices=[
"SL", "Expensing", "DB 150%", "DB 200%", "Economic"])
)
# Register custom type defined above
paramtools.register_custom_type("depreciation_rules",
ma.fields.Nested(DepreciationRules()))
[docs]class DepreciationParams(paramtools.Parameters):
'''
Depreciation parameters class, contains model depreciation
parameters.
Inherits ParamTools Parameters abstract base class.
'''
defaults = os.path.join(
CURRENT_PATH, "tax_depreciation_rules.json")
[docs]def revision_warnings_errors(spec_revision):
'''
Return warnings and errors for the specified Cost-of-Capital-Calculator
Specificaton revision in parameter values.
Args:
spec_revision (dict): dictionary suitable for use with the
`Specification.update_specification method`.
Returns:
rtn_dict (dict): dicionary containing any warning or error messages
'''
rtn_dict = {'warnings': '', 'errors': ''}
spec = Specification()
try:
spec.update_specification(spec_revision, raise_errors=False)
if spec._errors:
rtn_dict['errors'] = spec._errors
except ValueError as valerr_msg:
rtn_dict['errors'] = valerr_msg.__str__()
return rtn_dict
