def test_Prefix_decorator(self):
baz = 'baz'
barz = 'barz'
name = 'fara'
with Record() as rec:
foo = Foo(name)
foo.do_something(baz, barz)
foo.bar(baz, barz)
assumed_record_entries = {
('Foo({}).do_something'.format(name), 'again_a_key'):
baz,
('Foo({}).do_something'.format(name), 'so_creative'):
barz,
('Foo({}).bar'.format(name), 'Foo({}).do_something'.format(name), 'again_a_key'):
baz,
('Foo({}).bar'.format(name), 'Foo({}).do_something'.format(name), 'so_creative'):
barz,
('Foo({}).bar'.format(name), 'a_key'):
"That's",
('Foo({}).bar'.format(name), 'another_key'):
"great"
}
self.assertEqual(Record().entries, assumed_record_entries)
def get_present_value(self,
value_date=BusinessDate(),
index_model_dict={}):
"""
:param value_date:
:param index_model_dict:
:return:
"""
pv_let = 0.0
pv_let_value_ccy = None
df = None
fx = None
if self._pay_date_ > value_date:
fx = 1.0 # fixme: handle other ccy, too.
df = self._discount_index_.get_value(self._pay_date_, value_date)
pv_let_value_ccy = df * self._notional_
pv_let = fx * pv_let_value_ccy
Record(notional=self._notional_,
pay_date=self._pay_date_,
disc_fact=df,
fx=fx,
pv_let=pv_let,
pv_let_value_ccy=pv_let_value_ccy,
disc_index=self._discount_index_.object_name,
fx_index=self._f_x_index_.object_name)
return pv_let
def _get_discounted_value(self,
value_date,
payoff,
discount_index,
pay_date=None):
""" discounts the payoff by discount_index values
:param value_date:
:param payoff:
:param discount_index:
:param pay_date:
:return:
"""
if pay_date is None:
pay_date = self.pay_date
df = discount_index.get_value(pay_date, value_date)
pv_let = df * payoff
Record(pay_off=payoff,
pv_let=pv_let,
disc_fact=df,
disc_index=str(discount_index),
pay_date=self.pay_date)
return pv_let
def get_expected_payoff(self,
value_date=BusinessDate(),
index_model_dict={}):
""" calculates expected payoff at paydate
:param BusinessDate value_date:
:param IndexModel index_model_dict:
:return: float, the pv of the cash flow
"""
idx_model = index_model_dict.get(self._rate_index_.object_name,
self._rate_index_.index_model)
payoff = 0.0
is_fixed_cash_flow = False
fwd = None
fixing_value = None
time = None
vol = None
strike = self._get_strike_value()
effective_strike = (strike - self._spread_) / self._multiplier_
pay_rec = 1.0 if self._notional_ >= 0.0 else -1.0
rate_ccy = self._rate_index_.currency
if self._pay_date_ > value_date:
if self._rate_index_.has_fixing(self._reset_date_):
is_fixed_cash_flow = True
fixing_value = self._rate_index_.get_fixing(self._reset_date_)
rate = self._payoff(fixing_value, effective_strike)
else:
rate, vol, time, fwd = self._get_option_value(
idx_model, effective_strike)
rate *= self._multiplier_
rate += self._spread_
payoff = rate * self._year_fraction_ * self._notional_ + self._amount_
Record(pay_rec="REC" if pay_rec == 1.0 else "PAY",
year_fraction=self.year_fraction,
cf_name=self.object_name,
notional=self._notional_,
currency=self.currency,
forward=fwd,
is_fixed_cash_flow=is_fixed_cash_flow,
fixing_value=fixing_value,
vol=vol,
expiry_time=time,
spread=self._spread_,
reset_date=self._reset_date_,
start_date=self._start_date_,
end_date=self._end_date_,
pay_date=self._pay_date_,
constant_rate=self._constant_rate_,
amount=self._amount_,
strike=strike,
effective_strike=effective_strike,
index=self._rate_index_.object_name,
expected_payoff=payoff,
rate_ccy=rate_ccy) # pylint: disable=unexpected-keyword-arg
return payoff
def get_expected_payoff(self,
value_date=BusinessDate(),
index_model_dict={}):
""" calculates expected payoff at paydate
:param BusinessDate value_date:
:param IndexModel index_model_dict:
:return: float, the pv of the cash flow
"""
rate = 0.0
is_fix_rate = True
is_fixed_cash_flow = False
fwd = None
fixing_value = None
time = None
vol = None
effective_floor_strike = None
effective_cap_strike = None
pay_rec = 1.0 if self._notional_ >= 0.0 else -1.0
payoff = 0.0
rate_ccy = self.currency
if self._pay_date_ > value_date:
rate += self._constant_rate_
fx_index = self._get_fx_index(self.currency)
fx = fx_index.get_value(value_date) if fx_index else 1.0
payoff = fx * rate * self._year_fraction_ * self._notional_ + self._amount_
Record(pay_rec="REC" if pay_rec == 1.0 else "PAY",
year_fraction=self.year_fraction,
cf_name=self.object_name,
notional=self._notional_,
currency=self.currency,
rate_ccy=rate_ccy,
is_fix_rate=is_fix_rate,
forward=fwd,
is_fixed_cash_flow=is_fixed_cash_flow,
fixing_value=fixing_value,
vol=vol,
expiry_time=time,
spread=self._spread_,
reset_date=self._reset_date_,
start_date=self._start_date_,
end_date=self._end_date_,
pay_date=self._pay_date_,
constant_rate=self._constant_rate_,
amount=self._amount_,
effective_floor_strike=effective_floor_strike,
effective_cap_strike=effective_cap_strike,
index=self._rate_index_.object_name,
expected_payoff=payoff,
floor=None if self._floor_ == NO_FLOOR_VALUE else self._floor_,
cap=None if self._cap_ == NO_CAP_VALUE else self._cap_) # pylint: disable=unexpected-keyword-arg
return payoff
def test_call_to_RecordClass_start_stop(self):
value = 'value'
a_dict = {'a_key': 'a_value'}
b_dict = {'b_key': 'b_value'}
Record().start()
Record(key=value)
self.assertEqual(Record().entries, {('key',):'value'})
Record(a_dict)
self.assertEqual(Record().entries, {('key',):'value', ('a_key',):'a_value'})
Record().stop()
Record(b_dict, INT=12345)
self.assertEqual(Record().entries, {('key',):'value', ('a_key',):'a_value'})
def test_multilevel_record_context(self):
R1 = Record()
R2 = Record()
self.assertEqual(R1, R2)
with Record() as R1:
with Record() as R2a:
self.assertNotEqual(R1, R2a)
self.assertEqual(Record(), R2a)
with Record() as R2b:
self.assertNotEqual(R1, R2b)
self.assertEqual(Record(), R2b)
self.assertNotEqual(R2a, R2b)
def _prepare_return(self, value, vol, time, forward):
possign = self._position_sign()
payoff = self._notional_ * possign * value
#pv = self._get_discounted_value(value_date, payoff, self._underlying_.domestic_currency)
Record(expected_payoff=payoff,
opt_value=value,
vol=vol,
time=time,
forward=forward,
strike=self._strike_,
position_sign=possign,
notional=self._notional_,
pay_ccy=self._pay_currency_)
return payoff
def test_call_to_RecordClass_not_started(self):
value = 'value'
a_dict = {'a_key': 'a_value'}
Record(key=value)
self.assertEqual(Record().entries, dict())
Record(a_dict)
self.assertEqual(Record().entries, dict())
Record(a_dict, key=value)
self.assertEqual(Record().entries, dict())
def test_Record_as_context(self):
a_dict = {'a_key': 'a_value'}
Record(a_dict, key='value')
self.assertEqual(Record().entries, dict())
with Record() as R:
Record(a_dict)
self.assertEqual(Record().entries, {('a_key',): 'a_value'})
self.assertEqual(R, Record())
self.assertEqual(R.entries, {('a_key',): 'a_value'})
def get_expected_payoff(self,
value_date=BusinessDate(),
index_model_dict={}):
"""
:param value_date:
:param index_model_dict:
:return:
"""
payoff = 0.0
rate = None
if self._pay_date_ > value_date:
rate_idx = self._rate_index_
fixing_fct = OISCashFlow.ConstFixing(rate_idx)
oispayoff = OISCashFlow.OISPayoff(rate_idx.index_model.yieldcurve,
fixing_fct, rate_idx._calendar_,
rate_idx._day_count_)
rate = oispayoff.calc_payoff(value_date, self._start_date_,
self._end_date_, self._year_fraction_)
rate *= self._multiplier_
rate += self._spread_
payoff = rate * self._year_fraction_ * self._notional_ + self._amount_
Record(year_fraction=self.year_fraction,
cf_name=self.object_name,
notional=self._notional_,
currency=self.currency,
forward=rate,
spread=self._spread_,
reset_date=self._reset_date_,
start_date=self._start_date_,
end_date=self._end_date_,
pay_date=self._pay_date_,
amount=self._amount_,
index=self._rate_index_.object_name,
expected_payoff=payoff) # pylint: disable=unexpected-keyword-arg
return payoff
def get_expected_payoff(self,
value_date=BusinessDate(),
index_model_dict={}):
""" calculates expected payoff at paydate
:param BusinessDate value_date:
:param IndexModel index_model_dict:
:return: float, the pv of the cash flow
"""
idx_model = index_model_dict.get(self._rate_index_.object_name,
self._rate_index_.index_model)
rate = 0.0
is_fix_rate = True
is_fixed_cash_flow = False
fwd = None
fixing_value = None
time = None
vol = None
effective_floor_strike = None
effective_cap_strike = None
pay_rec = 1.0 if self.is_rec else -1.0
payoff = 0.0
rate_ccy = self.currency
if self._pay_date_ > value_date:
if self._constant_rate_:
rate += self._constant_rate_
else:
is_fix_rate = False # fixme: be consistent, use is_fixed_flow?
rate_ccy = self._rate_index_.currency
if self._rate_index_.has_fixing(self._reset_date_):
is_fixed_cash_flow = True
fixing_value = self._rate_index_.get_fixing(
self._reset_date_)
rate = fixing_value
else:
fwd = idx_model.get_value(self._rate_index_,
self._reset_date_,
self._pay_date_)
rate = fwd
if self._floor_ != NO_FLOOR_VALUE:
effective_floor_strike = (
self._floor_ - self._spread_) / self._multiplier_
if not is_fixed_cash_flow:
value, vol, time, fwd = idx_model.get_option_payoff_value(
self._rate_index_, Put(), effective_floor_strike,
self._reset_date_)
else:
value = max(effective_floor_strike - rate, 0)
rate += value
if self._cap_ != NO_CAP_VALUE:
effective_cap_strike = (self._cap_ -
self._spread_) / self._multiplier_
if not is_fixed_cash_flow:
value, vol, time, fwd = idx_model.get_option_payoff_value(
self._rate_index_, Call(), effective_cap_strike,
self._reset_date_)
else:
value = max(rate - effective_cap_strike, 0)
rate -= value
rate *= self._multiplier_
rate += self._spread_
fx_index = self._get_fx_index(self.currency)
fx = fx_index.get_value(value_date) if fx_index else 1.0
payoff = fx * rate * self._year_fraction_ * self._notional_ + self._amount_
Record(pay_rec="REC" if pay_rec == 1.0 else "PAY",
year_fraction=self.year_fraction,
cf_name=self.object_name,
notional=self._notional_,
currency=self.currency,
rate_ccy=rate_ccy,
is_fix_rate=is_fix_rate,
forward=fwd,
is_fixed_cash_flow=is_fixed_cash_flow,
fixing_value=fixing_value,
vol=vol,
expiry_time=time,
spread=self._spread_,
reset_date=self._reset_date_,
start_date=self._start_date_,
end_date=self._end_date_,
pay_date=self._pay_date_,
constant_rate=self._constant_rate_,
amount=self._amount_,
effective_floor_strike=effective_floor_strike,
effective_cap_strike=effective_cap_strike,
index=self._rate_index_.object_name,
expected_payoff=payoff,
floor=None if self._floor_ == NO_FLOOR_VALUE else self._floor_,
cap=None if self._cap_ == NO_CAP_VALUE else self._cap_) # pylint: disable=unexpected-keyword-arg
return payoff
def test_record_of_RecordObject(self):
value = 'value'
a_dict = {'a_key': 'a_value'}
b_dict = {'b_key': 'b_value'}
R = Record()
R._record(key=value)
self.assertEqual(Record().entries, {('key',):'value'})
R._record(a_dict)
self.assertEqual(Record().entries, {('key',):'value', ('a_key',):'a_value'})
R._record(b_dict, INT=12345)
self.assertEqual(Record().entries, {('key',):'value', ('a_key',):'a_value', ('b_key',): 'b_value', ('INT',):12345} )
def test_multilevel_record_append_prefix_context(self):
with Record() as R1:
with Record().append_prefix('level2'):
self.assertEqual(Record()._prefix_stack, ['level2'])
with Record() as R2a:
self.assertEqual(Record()._prefix_stack, [])
Record(level=Record._record_level, name='R2a')
self.assertEqual(Record().entries, {('level',): 2, ('name',): 'R2a'})
self.assertNotEqual(Record(), R2a)
self.assertEqual(Record(), R1)
with Record().append_prefix('another_prefix'):
self.assertEqual(Record()._prefix_stack,['level2','another_prefix'])
with Record() as R2b:
self.assertEqual(Record()._prefix_stack, [])
Record(recorded='just something')
self.assertEqual(Record().entries, {('recorded',): 'just something'})
self.assertEqual(Record()._prefix_stack, ['level2'])
self.assertEqual(Record()._prefix_stack, [])
assumed_record_entries = {('level2', 'level'): 2,
('level2', 'name'): 'R2a',
('level2', 'another_prefix', 'recorded'): 'just something'}
self.assertEqual(Record().entries, assumed_record_entries)
def setUp(self):
Record().clear()
def do_stuff():
with Record() as rec:
foo = Foo("Rom")
foo.do_something("baz", "barz")
foo.bar("baz", "barz")
def do_something(self, baz, barz):
a_dict = {'again_a_key': baz, 'so_creative': barz}
Record(a_dict)
return magical_stuff_happens(baz, barz)
def bar(self, baz, barz):
some_value1, some_value2 = self.do_something(baz, barz)
Record(a_key=some_value1, another_key=some_value2)
return some_value1, some_value2
