class BusinessHolidayUnitTests(unittest.TestCase):
def setUp(self):
self.bd = BusinessDate(19730226)
self.list = [str(i) + '0301' for i in range(1973, 2016)]
def test_holiday(self):
h = BusinessHolidays(self.list)
for l in self.list:
self.assertTrue(BusinessDate(l) in h)
self.assertNotEqual(self.bd.add_period('3b', h), self.bd.add_period('3b'))
def test_is_business_date(self):
d = self.dec31
holi = BusinessHolidays()
bdate = BusinessDate.from_ymd(2016, 1, 1)
is_bday_empty_calendar = bdate.is_business_day(holi)
self.assertTrue(is_bday_empty_calendar)
is_bday_default_calendar = bdate.is_business_day()
self.assertFalse(is_bday_default_calendar)
target_a= BusinessDate.from_ymd(2016, 1, 4)
a = d.add_business_days(2, holi)
self.assertEqual(target_a, a)
target_b = BusinessDate.from_ymd(2016, 1, 5)
b = d.add_business_days(2) # default holidays contains the target days, i.e. the 1.1.2016
self.assertEqual(target_b, b)
def test_wrapper_methods(self):
p = BusinessPeriod(years=1, months=1, days=1)
self.assertEqual(p.add_years(p.years).add_months(p.months).add_days(p.days),
BusinessPeriod(years=2, months=2, days=2))
self.assertEqual(p * 2, BusinessPeriod(years=4, months=4, days=4))
self.assertEqual(BusinessDate.add_period(BusinessDate('20160110'), BusinessPeriod(days=-1)),
BusinessDate('20160109'))
def setUp(self):
self.dec31 = BusinessDate(20151231)
self.jan01 = BusinessDate(20160101)
self.jan02 = BusinessDate(20160102)
self.jan04 = BusinessDate(20160104)
self.jan29 = BusinessDate(20160129)
self.jan31 = BusinessDate(20160131)
self.feb01 = BusinessDate(20160201)
self.feb28 = BusinessDate(20160228)
self.feb29 = BusinessDate(20160229)
self.mar31 = BusinessDate(20160331)
self.jun30 = BusinessDate(20160630)
self.sep30 = BusinessDate(20160930)
self.dates = [self.dec31, self.jan01, self.jan02, self.jan04, self.jan29, self.jan31,
self.feb01, self.feb28, self.feb29, self.mar31, self.jun30, self.sep30]
def setUp(self):
testfile = open(TEST_DATA + 'daycount_test_data.csv')
header = testfile.readline().rstrip().split(';')
start = header.index('StartDate')
header.pop(start)
period = header.index('Period')
header.pop(period)
end = header.index('EndDate')
header.pop(end)
self.test_data = list()
for line in testfile:
data = line.rstrip().split(';')
start_date = BusinessDate(data.pop(start))
_ = BusinessPeriod(data.pop(period))
end_date = BusinessDate(data.pop(end))
daycount = dict(zip(header, data))
self.test_data.append((start_date, end_date, daycount))
testfile.close()
def get_present_value(self,
value_date=BusinessDate(),
index_model_dict={}):
""" returns present value at value_date derived by given index_models if provided
:param value_date:
:param index_model_dict:
:return:
"""
return self._get_present_value_sum(self._product_list_, value_date,
index_model_dict)
def test_business_day_adjustment(self):
self.assertEqual(self.jan01.adjust_follow(), BusinessDate(20160104))
self.assertEqual(self.jan01.adjust_mod_follow(),
BusinessDate(20160104))
self.assertEqual(self.jan01.adjust_previous(), BusinessDate(20151231))
self.assertEqual(self.jan01.adjust_mod_previous(),
BusinessDate(20160104))
self.assertEqual(self.jan01.adjust_start_of_month(),
BusinessDate(20160104))
self.assertEqual(self.jan01.adjust_end_of_month(),
BusinessDate(20160129))
self.assertEqual(self.jan01.adjust_imm(), BusinessDate(20160115))
self.assertEqual(self.jan01.adjust_cds_imm(), BusinessDate(20160120))
def get_effective_rate(self,
value_date=BusinessDate(),
index_model_dict={}):
""" calculate fair rate of an InterestRateSwap
:param value_date:
:param index_model_dict:
:return: float: the fair rate of the underlying swap.
:rtype: fair_rate
"""
raise NotImplementedError
def get_annuity_value(self, index_object, value_date, base_date=BusinessDate(), cash=False):
""" calculate get_annuity_value for either cash or physical settlement
:param SwapRateIndexInterface index_object:
:param BusinessDate value_date:
:param BusinessDate base_date: (optional) default is BusinessDate()
:param boolean cash: if True, get_annuity_value for cash settlement else for physical settlement
(optional) default is False
:return: float
"""
raise NotImplementedError
def get_positive_exposure(self,
value_date=BusinessDate(),
index_model_dict={}):
""" returns positive exposure, i.e. max(0.,pv), at value_date
:param value_date:
:param (dict) index_model_dict: container of IndexModels
:return:
"""
pay_value = self.get_present_value(value_date, index_model_dict)
return max(pay_value, 0)
def get_positive_exposure(self,
value_date=BusinessDate(),
index_model_dict={}):
"""
:param value_date:
:param index_model_dict: container of IndexModels
:type index_model_dict: dict
:return:
"""
pay_value = self.get_present_value(value_date, index_model_dict)
return max(pay_value, 0)
def test_calculations(self):
self.assertEqual(self.jan01.add_days(1), self.jan02)
self.assertEqual(self.jan01.add_months(1), self.feb01)
self.assertEqual(self.jan01.add_years(1).to_string(), '20170101')
self.assertEqual(self.jan01.add_period('2D'),
self.jan02 + BusinessPeriod('1D'))
self.assertEqual(self.jan02.add_period('-2D'),
self.jan01 - BusinessPeriod('1D'))
self.assertEqual(self.jan02.add_period('-1b'),
self.jan01 - BusinessPeriod('1b'))
self.assertNotEqual(
BusinessDate(20160630).add_period(BusinessPeriod('2B')),
BusinessDate(20160630).add_period(
BusinessPeriod('2B', BusinessHolidays(['20160704']))))
self.assertEqual(self.jan01 + '1b', self.jan02 + '1b')
rng = list(range(1, 10))
periods = list()
for y in rng:
for m in rng:
for d in rng:
periods.append(
BusinessPeriod(
str(y) + 'y' + str(m) + 'm' + str(d) + 'd'))
for d in self.dates:
for p in periods:
c = d + p
self.assertEqual((c - d), BusinessPeriod(p), (c, d, c - d, p))
d = BusinessDate(20160229)
self.assertEqual(d + '1y' + '1m', BusinessDate(20170328))
self.assertEqual(d + '1m' + '1y', BusinessDate(20170329))
self.assertEqual(d + '1y1m', BusinessDate(20170329))
def test_business_holidays(self):
self.assertTrue(BusinessDate(20160101) in self.holidays)
self.assertFalse(BusinessDate(20160102) in self.holidays)
self.assertTrue(BusinessDate(20160102) not in self.holidays)
self.assertTrue(BusinessDate(20160325) in self.holidays)
self.assertTrue(BusinessDate(20160328) in self.holidays)
self.assertTrue(BusinessDate(20160501) in self.holidays)
def get_present_value(self,
value_date=BusinessDate(),
index_model_dict={}):
"""
:param BusinessDate value_date:
:param IndexModel index_model_dict:
:return: float, the pv of the cash flow
"""
payoff = self.get_expected_payoff(value_date, index_model_dict)
df_index = self._get_discount_index(self.currency)
pv_let = self._get_discounted_value(value_date, payoff, df_index)
return pv_let
def get_positive_exposure(self,
value_date=BusinessDate(),
index_model_dict={}):
""" gets the positive exposure of a contract
:param value_date: the value date of the contract
:param index_model_dict: dict of IndexModels
:return: positive exposure at value_date
"""
return sum(
c.get_positive_exposure(value_date, index_model_dict)
for c in self._contract_list_)
def __init__(self, holiday_list=list()):
"""
:param iterable holiday_list: This should be a container object of holidays
which is accessible with "in" (eg. date in holiday_obj)
"""
super(Calendar, self).__init__()
if isinstance(holiday_list, (list, tuple)):
holiday_list = [BusinessDate(x).to_date() for x in holiday_list]
if isinstance(holiday_list, str):
self._inner_cal = self._union_of_registered_calendars(holiday_list)
else:
self._inner_cal = holiday_list
def _cast_to_dates(self, *in_date):
ret = list()
r = None
for d in in_date:
if isinstance(d, BusinessDate):
r = d
else:
if isinstance(d, (datetime.date, datetime.datetime)):
r = BusinessDate.from_date(d)
elif isinstance(d, BusinessPeriod):
r = d.to_businessdate(self.origin)
ret.append(r)
return ret
def test_diff_in_years(self):
s = BusinessDate('20011110')
e = BusinessDate('20011112')
self.assertEqual(BusinessDate.diff_in_years(s, e), 2 / DAYS_IN_YEAR)
self.assertEqual(
BusinessDate.diff_in_years(BusinessDate('20161101'),
BusinessDate('20171102')),
366 / DAYS_IN_YEAR)
def test_business_day_is(self):
self.assertFalse(self.jan01.is_business_day())
self.assertTrue(BusinessDate.is_leap_year(2016))
self.assertTrue(BusinessDate.is_businessdate('20160101'))
self.assertFalse(BusinessDate.is_businessdate('ABC'))
self.assertFalse(BusinessDate.is_businessdate('20160230'))
self.assertTrue(BusinessDate.is_businessdate('20160229'))
self.assertFalse(BusinessDate.is_businessdate('20150229'))
def test_business_day_is(self):
self.assertFalse(self.jan01.is_business_day())
self.assertTrue(BusinessDate.is_leap_year(2016))
self.assertTrue(BusinessDate.is_businessdate('20160101'))
self.assertFalse(BusinessDate.is_businessdate('ABC'))
self.assertFalse(BusinessDate.is_businessdate('20160230'))
self.assertTrue(BusinessDate.is_businessdate('20160229'))
self.assertFalse(BusinessDate.is_businessdate('20150229'))
def test_cast_from(self):
for d in self.dates:
self.assertEqual(BusinessDate.from_date(d.to_date()), d)
self.assertEqual(BusinessDate.from_businessdate(d), d)
self.assertEqual(BusinessDate.from_excel(d.to_excel()), d)
self.assertEqual(BusinessDate.from_ordinal(d.to_ordinal()), d)
self.assertEqual(BusinessDate.from_string(d.to_string()), d)
self.assertEqual(BusinessDate.from_ymd(*d.to_ymd()), d)
def test_cast_from(self):
for d in self.dates:
self.assertEqual(BusinessDate.from_date(d.to_date()), d)
self.assertEqual(BusinessDate.from_businessdate(d), d)
self.assertEqual(BusinessDate.from_excel(d.to_excel()), d)
self.assertEqual(BusinessDate.from_ordinal(d.to_ordinal()), d)
self.assertEqual(BusinessDate.from_string(d.to_string()), d)
self.assertEqual(BusinessDate.from_ymd(*d.to_ymd()), d)
def get_expected_credit_loss(self,
value_date=BusinessDate(),
start_date=None,
end_date=None,
index_model_dict={}):
""" gets the expected credit loss between desired dates
:param value_date:
:param start_date:
:param end_date:
:param index_model_dict (optional): dict of index models incl. default loss model
:return: float
"""
if not end_date:
end_date = max(c.maturity for c in self._contract_list_)
end_date = end_date.to_businessdate(self.origin)
if not start_date:
start_date = self.origin
start_date = start_date.to_businessdate(self.origin)
freq = self._ecl_frequency_.period
schedule = BusinessSchedule(start_date, end_date, freq, start_date)
dcc = ActAct()
total_ecl = 0.0
for loop_date, e in zip(schedule[:-1], schedule[1:]):
df = Continuous().disc_factor_from_rate(start_date, loop_date, dcc,
self._effective_rate)
svp = self._survival_index.get_value(loop_date)
yf = BusinessDate.diff_in_years(loop_date, e)
fwd = 1 - self._survival_index.get_value(e, loop_date)
loss = self.get_expected_default_loss(loop_date, index_model_dict)
ecl = df * svp * yf * fwd * loss
total_ecl += ecl
return total_ecl
def get_stocks_ohlc(tickers,
session=SESH,
interval='1d',
start_date=None,
end_date=None,
proxies=None):
''' Get Max OHLC (includes most current bar) for the given stocks
'''
interval_rule_dict = {'1wk': 'W', '1mo': 'M'}
assert interval in ['1d'] + list(
interval_rule_dict.keys()
), f'get_stocks_ohlc: interval must be either 1d or one of {interval_rule_dict.keys()}'
session = update_session_proxy(session, proxy = random.choice(proxies)) \
if proxies else session
prices_df = yf.download(tickers=tickers,
session=session,
period='max',
interval='1d',
group_by='ticker',
progress=False)
# Date Adjustment
start_date = (BusinessDate(start_date) -
'1d').to_date() if start_date else None
end_date = (BusinessDate(end_date) + '1d').to_date() if end_date else None
prices_df = prices_df[prices_df.index > pd.Timestamp(start_date)] \
if start_date else prices_df
prices_df = prices_df[prices_df.index < pd.Timestamp(end_date)] \
if end_date else prices_df
# Interval Adjustment
if interval in interval_rule_dict.keys():
try:
prices_df = df_aggregate(prices_df,
rule=interval_rule_dict[interval])
except:
raise RuntimeError(
f'get_stocks_ohlc: daily to weekly conversion error for {tickers}'
)
return prices_df
def get_present_value(self,
value_date=BusinessDate(),
index_model_dict={}):
""" returns present value at value_date derived by given index_models if provided
:param value_date:
:param index_model_dict:
:return: float, the pv of the cash flow
"""
payoff = self.get_expected_payoff(value_date, index_model_dict)
df_index = self._get_discount_index(self.currency)
pv_let = self._get_discounted_value(value_date, payoff, df_index)
return pv_let
def get_present_value(self,
value_date=BusinessDate(),
index_model_dict={}):
""" returns present value at value_date derived by given index_models if provided
:param value_date:
:param index_model_dict:
:return: float, the pv of the cash flow
"""
flow_list = list()
for leg in self.leg_list:
flow_list.extend(leg)
return self._get_present_value_sum(flow_list, value_date,
index_model_dict)
def test_max_min_days(self):
jan31 = BusinessDate(20010131)
for date in BusinessRange(jan31, jan31 + '5y'):
for m in range(12):
period = BusinessPeriod(months=m)
mn, mx = period.min_days(), period.max_days()
fwd, bck = date.diff_in_days(date + period), (
date - period).diff_in_days(date)
self.assertTrue(mn <= fwd <= mx)
self.assertTrue(mn <= bck <= mx)
self.assertEqual(BusinessPeriod('3m').min_days(), 89)
self.assertEqual(BusinessPeriod('-3m').min_days(), -90)
self.assertEqual(BusinessPeriod('3m').max_days(), 92)
self.assertEqual(BusinessPeriod('-3m').max_days(), -92)
def get_present_value(self,
value_date=BusinessDate(),
index_model_dict={}):
""" returns present value at value_date derived by given index_models if provided
:param value_date:
:param index_model_dict:
:return:
"""
i0 = 1 if self._exclude_1st_period_ else 0
cfs = self._get_cash_flow_list()
pv = self._get_present_value_sum(cfs[i0:], value_date,
index_model_dict)
return pv
def get_timeframe_params(st_asset , data_buffer_tenor = '1y', default_tenor = '250b',
l_interval_options = ['1d','1m', '2m','5m','15m','30m','60m','90m','1h','5d','1wk','1mo','3mo']
):
''' get user inputs and return timeframe params in dictionary {'start_date':..., 'end_date':..., 'data_start_date':...,'interval':...,'tenor':...}
'''
with st_asset:
today = datetime.date.today()
end_date = st.date_input('Period End Date', value = today)
tenor = None
if st.checkbox('pick start date'):
start_date = st.date_input('Period Start Date', value = today - datetime.timedelta(days = 365))
else:
tenor = st.text_input('Period', value = default_tenor)
start_date = (BusinessDate(end_date) - tenor).to_date()
st.info(f'period start date: {start_date}')
data_start_date = (BusinessDate(start_date) - data_buffer_tenor).to_date()
interval = st.selectbox('interval', options = l_interval_options)
return {
'start_date': start_date, 'end_date': end_date,
'data_start_date': data_start_date, 'interval': interval,
'tenor': tenor
}
def test_cast(self):
self.assertEqual(BusinessPeriod.from_string('1y'),
BusinessPeriod(years=1))
self.assertEqual(self._1y.to_businessdate(BusinessDate(20150101)),
BusinessDate(20160101))
self.assertEqual(self._1y6m.to_businessdate(BusinessDate(20150101)),
BusinessDate(20160701))
self.assertEqual(self._1y.to_businessdate(BusinessDate(20160229)),
BusinessDate(20170228))
self.assertEqual(self._1y.to_date(BusinessDate(20160229)),
date(2017, 2, 28))
self.assertEqual(self._1y.to_businessperiod(BusinessDate(20160229)),
self._1y)
self.assertEqual(self._1y.to_string(), '1Y')
self.assertEqual(self._2q.to_string(), '6M')
self.assertEqual(self._2w.to_string(), '14D')
def get_present_value(self,
value_date=BusinessDate(),
index_model_dict={}):
r""" returns the forward value of a amortizing collateral
Parameters:
value_date (BusinessDate): date of the valuation
value_currency_name (Currency): valueation currrency
index_model_dict (IndexModel): dict of IndexModel
Returns:
(float): forward value of a financial security
The forward value at time :math:`t`, i.e. :math:`S_t`, is calculated
by a linear depreciation of the prime costs :math:`AK` such that
.. math::
:nowrap:
\[
S_t = \max \left( \left(AK \left(1-\frac{t-t_{AK}}
{T_{max}}\right) \right),0\right)
\]
where :math:`T_{max}` is the maximum amortization BusinessPeriod,
:math:`t_{AK}` is the time of acquisition.
"""
s = self._acquisition_date_.to_businessdate(self.origin)
e = self._amortization_date_.to_businessdate(self.origin)
t_max = BusinessDate.diff_in_years(s, e)
v = value_date.to_businessdate(self.origin)
t = BusinessDate.diff_in_years(s, v)
expected_value = max(self._notional_ * (1 - (t / t_max)), 0)
return expected_value * self._discount_index_.get_value(value_date)
def test_constructors(self):
br = BusinessRange(self.sd, self.ed)
self.assertEqual(len(br), 5)
self.assertEqual(br[0], self.sd)
self.assertEqual(br[-1], BusinessDate.add_years(self.ed, -1))
br = BusinessRange(self.sd, self.ed)
b2 = BusinessRange(self.sd, self.ed, '1y', self.ed)
ck = BusinessRange(self.sd, self.ed, '1y', self.sd)
ex = BusinessRange(self.sd, self.ed, '1y', self.ed + '1y')
sx = BusinessRange(self.sd, self.ed, '1y', self.sd - '1y')
self.assertEqual(br, b2)
self.assertEqual(b2, ck)
self.assertEqual(ck, ex)
self.assertEqual(ex, sx)
def test_constructors(self):
br = BusinessRange(self.sd, self.ed)
self.assertEqual(len(br), 5)
self.assertEqual(br[0], self.sd)
self.assertEqual(br[-1], BusinessDate.add_years(self.ed, -1))
br = BusinessRange(self.sd, self.ed)
b2 = BusinessRange(self.sd, self.ed, '1y', self.ed)
ck = BusinessRange(self.sd, self.ed, '1y', self.sd)
ex = BusinessRange(self.sd, self.ed, '1y', self.ed + '1y')
sx = BusinessRange(self.sd, self.ed, '1y', self.sd - '1y')
self.assertEqual(br, b2)
self.assertEqual(b2, ck)
self.assertEqual(ck, ex)
self.assertEqual(ex, sx)
def get_present_value(self,
value_date=BusinessDate(),
index_model_dict={}):
""" returns present value at value_date derived by given index_models if provided
:param value_date:
:param index_model_dict:
:return:
"""
pv_value_ccy = self.get_expected_payoff(value_date, index_model_dict)
fx = 1.0 # fixme: ensure ccy is self.ccy
pv = fx * pv_value_ccy * self._discount_index_.get_value(
self._settlement_date_, value_date)
return pv
def get_present_value(self,
value_date=BusinessDate(),
index_model_dict={}):
""" gets the present value of a contract
Parameters:
value_date (BusinessDate): the value date of the contract
index_model_dict (dict): dict of IndexModels
Returns:
float: present value for given value_date
"""
sum_pv = self.get_present_value_sum(self._product_list_, value_date,
index_model_dict)
return sum_pv
def get_annuity_value(self,
index_object,
value_date,
base_date=BusinessDate(),
cash=False):
""" calculate get_annuity_value for either cash or physical settlement
:param BusinessDate value_date:
:param BusinessDate base_date: (optional) default is BusinessDate()
:param boolean cash: if True, get_annuity_value for cash settlement else for physical settlement
(optional) default is False
:return: float
"""
if cash:
return self._cash_annuity(index_object, value_date, base_date)
else:
return self._swap_annuity(index_object, value_date, base_date)
def get_present_value(self,
value_date=BusinessDate(),
index_model_dict={}):
r"""
The forward value at time :math:`t`, i.e. :math:`S_t`, is calculated
by the minimum of the expected future mortgage value and the
mortgage amount such that
.. math::
S_t = S_0 \cdot e^{\mu t}
where :math:`S_0` is the current mortgage value and :math:`\mu`
the rate of return for real estate evolution.
"""
pv_0 = self._mortgage_value_ * self._asset_index_.get_value(
self._mortgage_value_date_, self.origin)
pv_t = pv_0 * self._asset_index_.get_value(value_date)
return pv_t * self._discount_index_.get_value(value_date)
class BusinessDateUnitTests(unittest.TestCase):
def setUp(self):
self.dec31 = BusinessDate(20151231)
self.jan01 = BusinessDate(20160101)
self.jan02 = BusinessDate(20160102)
self.jan04 = BusinessDate(20160104)
self.jan29 = BusinessDate(20160129)
self.jan31 = BusinessDate(20160131)
self.feb01 = BusinessDate(20160201)
self.feb28 = BusinessDate(20160228)
self.feb29 = BusinessDate(20160229)
self.mar31 = BusinessDate(20160331)
self.jun30 = BusinessDate(20160630)
self.sep30 = BusinessDate(20160930)
self.dates = [self.dec31, self.jan01, self.jan02, self.jan04, self.jan29, self.jan31,
self.feb01, self.feb28, self.feb29, self.mar31, self.jun30, self.sep30]
def test_constructors(self):
self.assertEqual(BusinessDate(date.today()), BusinessDate())
self.assertEqual(self.jan02, BusinessDate('2016-01-02'))
self.assertEqual(self.jan02, BusinessDate('01/02/2016'))
self.assertEqual(self.jan02, BusinessDate('02.01.2016'))
self.assertEqual(self.jan02, BusinessDate(42371))
self.assertEqual(self.jan02, BusinessDate(42371.0))
self.assertEqual(self.jan02, BusinessDate(735965))
self.assertEqual(self.jan02, BusinessDate(735965.0))
self.assertEqual([self.jan01, self.jan02], BusinessDate([20160101, 42371]))
def test_to_string(self):
self.assertEqual(self.jan02.to_string(), '20160102')
self.assertEqual(BusinessDate(42371).to_string(), '20160102')
def test_properties(self):
self.assertEqual(self.jan01.day, 01)
self.assertEqual(self.jan01.month, 01)
self.assertEqual(self.jan01.year, 2016)
def test_operators(self):
self.assertEqual(self.jan01 + '2D', self.jan02 + '1D')
self.assertEqual(self.jan01 - '1D', self.jan02 - '2D')
self.assertEqual(self.jan02 - '1D' + '1M', self.feb01)
self.assertRaises(TypeError, lambda: '1D' + self.jan02)
self.assertEqual(self.jan01 - BusinessPeriod('1D'), self.jan02 - '2D')
self.assertRaises(TypeError, lambda: BusinessPeriod('1D') + self.jan02)
self.assertRaises(TypeError, lambda: BusinessPeriod('1D') - self.jan01)
self.assertEqual(self.dec31.add_period(BusinessPeriod('2B', BusinessHolidays())),
self.dec31.add_period(BusinessPeriod('2B'), BusinessHolidays([self.jan02])))
def test_validations(self):
self.assertTrue(BusinessDate.is_businessdate(18991229))
self.assertTrue(BusinessDate.is_businessdate(20160131))
self.assertTrue(BusinessDate.is_businessdate(20160228))
self.assertTrue(BusinessDate.is_businessdate(20160229))
self.assertFalse(BusinessDate.is_businessdate(20160230))
self.assertFalse(BusinessDate.is_businessdate(20160231))
self.assertTrue(BusinessDate.is_businessdate(20150228))
self.assertFalse(BusinessDate.is_businessdate(20150229))
self.assertFalse(BusinessDate.is_businessdate('xyz'))
self.assertFalse(BusinessDate.is_businessdate(-125))
self.assertFalse(BusinessDate.is_businessdate(-20150228))
def test_calculations(self):
self.assertEqual(self.jan01.add_days(1), self.jan02)
self.assertEqual(self.jan01.add_months(1), self.feb01)
self.assertEqual(self.jan01.add_years(1).to_string(), '20170101')
self.assertEqual(self.jan01.add_period('2D'), self.jan02 + BusinessPeriod('1D'))
self.assertEqual(self.jan02.add_period('-2D'), self.jan01 - BusinessPeriod('1D'))
self.assertEqual(self.jan02.add_period('-1b'), self.jan01 - BusinessPeriod('1b'))
self.assertNotEqual(BusinessDate(20160630).add_period(BusinessPeriod('2B')),
BusinessDate(20160630).add_period(BusinessPeriod('2B', BusinessHolidays(['20160704']))))
self.assertEqual(self.jan01 + '1b', self.jan02 + '1b')
def test_cast_to(self):
self.assertTrue(isinstance(self.jan01.to_date(), date))
self.assertTrue(isinstance(self.jan01.to_businessdate(), BusinessDate))
self.assertTrue(isinstance(self.jan01.to_businessperiod(), BusinessPeriod))
self.assertTrue(isinstance(self.jan01.to_excel(), int))
self.assertTrue(isinstance(self.jan01.to_ordinal(), int))
self.assertTrue(isinstance(self.jan01.to_string(), str))
self.assertTrue(isinstance(self.jan01.to_ymd(), tuple))
def test_cast_from(self):
for d in self.dates:
self.assertEqual(BusinessDate.from_date(d.to_date()), d)
self.assertEqual(BusinessDate.from_businessdate(d), d)
self.assertEqual(BusinessDate.from_excel(d.to_excel()), d)
self.assertEqual(BusinessDate.from_ordinal(d.to_ordinal()), d)
self.assertEqual(BusinessDate.from_string(d.to_string()), d)
self.assertEqual(BusinessDate.from_ymd(*d.to_ymd()), d)
def test_day_count(self): # The daycount methods are also tested separately
delta = float((self.mar31.to_date() - self.jan01.to_date()).days)
total = float(((self.jan01 + '1y').to_date() - self.jan01.to_date()).days)
self.assertAlmostEqual(self.jan01.get_30_360(self.mar31), 90. / 360.)
self.assertAlmostEqual(self.jan01.get_act_360(self.mar31), delta / 360.)
self.assertAlmostEqual(self.jan01.get_act_365(self.mar31), delta / 365.)
self.assertAlmostEqual(self.jan01.get_act_36525(self.mar31), delta / 365.25)
self.assertAlmostEqual(self.jan01.get_act_act(self.mar31), delta / total)
def test_business_day_adjustment(self):
self.assertEqual(self.jan01.adjust_follow(), BusinessDate(20160104))
self.assertEqual(self.jan01.adjust_mod_follow(), BusinessDate(20160104))
self.assertEqual(self.jan01.adjust_previous(), BusinessDate(20151231))
self.assertEqual(self.jan01.adjust_mod_previous(), BusinessDate(20160104))
self.assertEqual(self.jan01.adjust_start_of_month(), BusinessDate(20160104))
self.assertEqual(self.jan01.adjust_end_of_month(), BusinessDate(20160129))
self.assertEqual(self.jan01.adjust_imm(), BusinessDate(20160115))
self.assertEqual(self.jan01.adjust_cds_imm(), BusinessDate(20160120))
def test_business_day_is(self):
self.assertFalse(self.jan01.is_business_day())
self.assertTrue(BusinessDate.is_leap_year(2016))
self.assertTrue(BusinessDate.is_businessdate('20160101'))
self.assertFalse(BusinessDate.is_businessdate('ABC'))
self.assertFalse(BusinessDate.is_businessdate('20160230'))
self.assertTrue(BusinessDate.is_businessdate('20160229'))
self.assertFalse(BusinessDate.is_businessdate('20150229'))
def test_is_business_date(self):
d = self.dec31
holi = BusinessHolidays()
bdate = BusinessDate.from_ymd(2016, 1, 1)
is_bday_empty_calendar = bdate.is_business_day(holi)
self.assertTrue(is_bday_empty_calendar)
is_bday_default_calendar = bdate.is_business_day()
self.assertFalse(is_bday_default_calendar)
target_a= BusinessDate.from_ymd(2016, 1, 4)
a = d.add_business_days(2, holi)
self.assertEqual(target_a, a)
target_b = BusinessDate.from_ymd(2016, 1, 5)
b = d.add_business_days(2) # default holidays contains the target days, i.e. the 1.1.2016
self.assertEqual(target_b, b)
def test__diff(self):
d1 = BusinessDate.from_ymd(2016, 1, 31)
d2 = BusinessDate.from_ymd(2017, 11, 1)
diff = BusinessDate.diff(d1, d2)
diff = BusinessPeriod(years=diff[0], months=diff[1], days=diff[2])
self.assertEqual('1Y9M1D', diff.to_string())
d1 = BusinessDate.from_ymd(2016, 2, 29)
d2 = BusinessDate.from_ymd(2017, 3, 1)
diff = BusinessDate.diff(d1, d2)
diff = BusinessPeriod(years=diff[0], months=diff[1], days=diff[2])
self.assertEqual('1Y1D', diff.to_string())
d2 = BusinessDate.from_ymd(2017, 2, 28)
diff = BusinessDate.diff(d1, d2)
diff = BusinessPeriod(years=diff[0], months=diff[1], days=diff[2])
self.assertEqual('1Y', diff.to_string())
d1 = BusinessDate.from_ymd(2016, 11, 15)
d2 = BusinessDate.from_ymd(2017, 1, 15)
diff = BusinessDate.diff(d1, d2)
diff = BusinessPeriod(years=diff[0], months=diff[1], days=diff[2])
self.assertEqual('2M', diff.to_string())
d1 = BusinessDate.from_ymd(2015, 7, 31)
d2 = BusinessDate.from_ymd(2017, 2, 20)
diff = BusinessDate.diff(d1, d2)
diff = BusinessPeriod(years=diff[0], months=diff[1], days=diff[2])
self.assertEqual('1Y6M20D', diff.to_string())
def setUp(self):
self.bd = BusinessDate(19730226)
self.list = [str(i) + '0301' for i in range(1973, 2016)]
def test_validations(self):
self.assertTrue(BusinessDate.is_businessdate(18991229))
self.assertTrue(BusinessDate.is_businessdate(20160131))
self.assertTrue(BusinessDate.is_businessdate(20160228))
self.assertTrue(BusinessDate.is_businessdate(20160229))
self.assertFalse(BusinessDate.is_businessdate(20160230))
self.assertFalse(BusinessDate.is_businessdate(20160231))
self.assertTrue(BusinessDate.is_businessdate(20150228))
self.assertFalse(BusinessDate.is_businessdate(20150229))
self.assertFalse(BusinessDate.is_businessdate('xyz'))
self.assertFalse(BusinessDate.is_businessdate(-125))
self.assertFalse(BusinessDate.is_businessdate(-20150228))
def test_dcc(self):
self.assertEqual(BusinessDate.get_act_36525(BusinessDate('20170101'),
BusinessDate('20180101')), 365.0 / 365.25)
def test_holidays(self):
self.assertEqual(BusinessDate.is_business_day(BusinessDate('20170101')), False)
def test_bdc(self):
self.assertEqual(BusinessDate.adjust_mod_follow(BusinessDate('20160312')), BusinessDate('20160314'))
self.assertEqual(BusinessDate.is_business_day(BusinessDate('20160312')), False)
def test_diff(self):
s = BusinessDate('20160101')
self.assertEqual(BusinessDate.diff_in_days(s, BusinessDate('20160102')), BusinessPeriod(days=1).days)
def test_add(self):
s = BusinessDate('20011110')
e = BusinessDate('20011112')
self.assertEqual(BusinessDate.add_days(s, e.day), BusinessDate('20011122'))
self.assertEqual(BusinessDate.add_months(s, 1), BusinessDate('20011210'))
self.assertEqual(BusinessDate.add_years(s, 1), BusinessDate('20021110'))
def test_diff_in_days(self):
s = BusinessDate('20011110')
e = BusinessDate('20011112')
self.assertEqual(BusinessDate.diff_in_days(s, e), 2)
def test_diff_in_years(self):
s = BusinessDate('20011110')
e = BusinessDate('20011112')
self.assertEqual(BusinessDate.diff_in_years(s, e), 2 / DAYS_IN_YEAR)
self.assertEqual(BusinessDate.diff_in_years(BusinessDate('20161101'),
BusinessDate('20171102')), 366 / DAYS_IN_YEAR)
