def structured_calc(mocker, priceable: Priceable, measure: risk.RiskMeasure):
set_session()
values = {
'$type': 'RiskVector',
'asset': [0.01, 0.015],
'points': [
{'type': 'IR', 'asset': 'USD', 'class_': 'Swap', 'point': '1y'},
{'type': 'IR', 'asset': 'USD', 'class_': 'Swap', 'point': '2y'}
]
}
mocker.return_value = [[[[values]]]]
expected = risk.sort_risk(pd.DataFrame([
{'mkt_type': 'IR', 'mkt_asset': 'USD', 'mkt_class': 'Swap', 'mkt_point': '1y', 'value': 0.01},
{'mkt_type': 'IR', 'mkt_asset': 'USD', 'mkt_class': 'Swap', 'mkt_point': '2y', 'value': 0.015}
]))
current = PricingContext.current
result = priceable.calc(measure)
assert result.raw_value.equals(expected)
risk_requests = (risk.RiskRequest(
positions=(RiskPosition(instrument=priceable, quantity=1),),
measures=(measure,),
pricing_and_market_data_as_of=(PricingDateAndMarketDataAsOf(pricing_date=current.pricing_date,
market=current.market),),
parameters=RiskRequestParameters(raw_results=True),
wait_for_results=True),)
mocker.assert_called_with(risk_requests)
def structured_calc(mocker, priceable: Priceable, measure: risk.RiskMeasure):
set_session()
values = [{
'marketDataType': 'IR',
'assetId': 'USD',
'pointClass': 'Swap',
'point': '1y',
'value': 0.01
}, {
'marketDataType': 'IR',
'assetId': 'USD',
'pointClass': 'Swap',
'point': '2y',
'value': 0.015
}]
mocker.return_value = [[values]]
result = priceable.calc(measure)
expected = risk.sort_risk(pd.DataFrame(values))
assert result.equals(expected)
risk_request = risk.RiskRequest(
positions=(risk.RiskPosition(priceable, 1), ),
measures=(measure, ),
pricingLocation=PricingContext.current.market_data_location,
pricingAndMarketDataAsOf=PricingContext.current.
_pricing_market_data_as_of,
waitForResults=True)
mocker.assert_called_with(risk_request)
def apply_field_values(
field_values: Union[dict, list, tuple, Future],
priceable_inst: Priceable,
resolution_info: dict,
future: Optional[Future] = None
):
if isinstance(field_values, str):
raise RuntimeError(field_values)
if isinstance(field_values, Future):
field_values = field_values.result()
if isinstance(field_values, (list, tuple)):
if len(field_values) == 1:
field_values = field_values[0]
else:
res = {}
for fv in field_values:
date = dt.date.fromtimestamp(fv['date'] / 1e9)
date_resolution_info = {
'pricing_date': date,
'market_data_as_of': fv['date'],
'market_data_location': resolution_info['market_data_location']
}
res[date] = apply_field_values(fv, priceable_inst, date_resolution_info)
future.set_result(res)
return
field_values = {field: value_mappings.get(value, value) for field, value in field_values.items()
if inflection.underscore(field) in priceable_inst.properties() and value not in invalid_defaults}
if in_place and not future:
priceable_inst.unresolved = copy.copy(priceable_inst)
for field, value in field_values.items():
setattr(priceable_inst, field, value)
priceable_inst._resolution_info = resolution_info
else:
new_inst = priceable_inst._from_dict(field_values)
new_inst.unresolved = priceable_inst
new_inst._resolution_info = resolution_info
if future:
future.set_result(new_inst)
else:
return new_inst
def apply_field_values(field_values: Union[dict, list, tuple, Future],
priceable_inst: Priceable,
future: Optional[Future] = None):
if isinstance(field_values, str):
raise RuntimeError(field_values)
if isinstance(field_values, Future):
field_values = field_values.result()
if isinstance(field_values, (list, tuple)):
if len(field_values) == 1:
field_values = field_values[0]
else:
future.set_result({
dt.date.fromtimestamp(fv['date'] / 1e9):
apply_field_values(fv, priceable_inst)
for fv in field_values
})
return
field_values = {
field: value_mappings.get(value, value)
for field, value in field_values.items()
if field in priceable_inst.properties()
and value not in invalid_defaults
}
if in_place and not future:
for field, value in field_values.items():
setattr(priceable_inst, field, value)
priceable_inst._resolved = True
else:
new_inst = priceable_inst._from_dict(field_values)
new_inst._resolved = True
if future:
future.set_result(new_inst)
else:
return new_inst
def price(mocker, priceable: Priceable):
set_session()
mocker.return_value = [[[{'value': 0.01}]]]
result = priceable.dollar_price()
assert result == 0.01
risk_request = risk.RiskRequest(
positions=(risk.RiskPosition(priceable, 1),),
measures=(risk.DollarPrice,),
pricingLocation=PricingContext.current.market_data_location,
pricingAndMarketDataAsOf=PricingContext.current._pricing_market_data_as_of,
waitForResults=True)
mocker.assert_called_with(risk_request)
def scalar_calc(mocker, priceable: Priceable, measure: risk.RiskMeasure):
set_session()
mocker.return_value = [[[{'value': 0.01}]]]
result = priceable.calc(measure)
assert result == 0.01
risk_request = risk.RiskRequest(
positions=(risk.RiskPosition(priceable, 1),),
measures=(measure,),
pricing_location=PricingContext.current.market_data_location,
pricing_and_market_data_as_of=PricingContext.current._pricing_market_data_as_of,
parameters=RiskRequestParameters(),
wait_for_results=True)
mocker.assert_called_with(risk_request)
def scalar_calc(mocker, priceable: Priceable, measure: risk.RiskMeasure):
set_session()
mocker.return_value = [[[[{'$type': 'Risk', 'val': 0.01}]]]]
current = PricingContext.current
result = priceable.calc(measure)
assert result == 0.01
risk_requests = (risk.RiskRequest(
positions=(RiskPosition(instrument=priceable, quantity=1),),
measures=(measure,),
pricing_and_market_data_as_of=(PricingDateAndMarketDataAsOf(pricing_date=current.pricing_date,
market=current.market),),
parameters=RiskRequestParameters(raw_results=True),
wait_for_results=True),)
mocker.assert_called_with(risk_requests)
def price(mocker, priceable: Priceable):
set_session()
mocker.return_value = [[[[{'$type': 'Risk', 'val': 0.01}]]]]
result = priceable.dollar_price()
assert result == 0.01
risk_requests = (risk.RiskRequest(
positions=(risk.RiskPosition(priceable, 1), ),
measures=(risk.DollarPrice, ),
pricing_location=PricingContext.current.market_data_location,
pricing_and_market_data_as_of=PricingContext.current.
_pricing_market_data_as_of,
parameters=RiskRequestParameters(raw_results=True),
wait_for_results=True), )
mocker.assert_called_with(risk_requests)
def calc(self, priceable: Priceable,
risk_measure: RiskMeasure) -> PricingFuture:
futures = []
for date in self.__date_range:
with PricingContext(pricing_date=date,
market=CloseMarket(
location=self.market_data_location,
date=close_market_date(
self.market_data_location, date)),
is_async=True,
csa_term=self.csa_term,
use_cache=self.use_cache,
visible_to_gs=self.visible_to_gs):
futures.append(priceable.calc(risk_measure))
return HistoricalPricingFuture(futures)
def calc(self, priceable: Priceable,
risk_measure: RiskMeasure) -> PricingFuture:
futures = []
provider = priceable.provider()
scenario = self._scenario
parameters = self._parameters
location = self.market.location
for date in self.__date_range:
market = CloseMarket(location=location,
date=close_market_date(location, date))
risk_key = RiskKey(provider, date, market, parameters, scenario,
risk_measure)
futures.append(self._calc(priceable, risk_key))
return HistoricalPricingFuture(futures)
def calc(self, priceable: Priceable, risk_measure: Union[RiskMeasure, Iterable[RiskMeasure]])\
-> Union[list, DataFrameWithInfo, ErrorValue, FloatWithInfo, Future, MultipleRiskMeasureFuture,
SeriesWithInfo]:
"""
Calculate the risk measure for the priceable instrument. Do not use directly, use via instruments
:param priceable: The priceable (e.g. instrument)
:param risk_measure: The measure we wish to calculate
:return: A float, Dataframe, Series or Future (depending on is_async or whether the context is entered)
**Examples**
>>> from gs_quant.instrument import IRSwap
>>> from gs_quant.risk import IRDelta
>>>
>>> swap = IRSwap('Pay', '10y', 'USD', fixed_rate=0.01)
>>> delta = swap.calc(IRDelta)
"""
futures = {}
with self.__active_context.__lock:
for risk_measure in (risk_measure, ) if isinstance(
risk_measure, RiskMeasure) else risk_measure:
risk_key = self.__risk_key(risk_measure, priceable.provider())
future = self.__active_context.__pending.get(
(risk_key, priceable))
cached_result = PricingCache.get(
risk_key, priceable) if self.use_cache else None
if future is None:
future = PricingFuture(self.__active_context)
if cached_result is not None:
future.set_result(cached_result)
else:
self.__active_context.__pending[(risk_key,
priceable)] = future
futures[risk_measure] = future
future = MultipleRiskMeasureFuture(futures, result_future=self._result_future())\
if len(futures) > 1 else futures[risk_measure]
return self._return_calc_result(future)
def calc(self, priceable: Priceable,
risk_measure: RiskMeasure) -> PricingFuture:
"""
Calculate the risk measure for the priceable instrument. Do not use directly, use via instruments
:param priceable: The priceable (e.g. instrument)
:param risk_measure: The measure we wish to calculate
:return: A PricingFuture whose result will be the calculation result
**Examples**
>>> from gs_quant.instrument import IRSwap
>>> from gs_quant.risk import IRDelta
>>>
>>> swap = IRSwap('Pay', '10y', 'USD', fixed_rate=0.01)
>>> delta = swap.calc(IRDelta)
"""
return self._calc(priceable,
self.__risk_key(risk_measure, priceable.provider()))
def calc(self, priceable: Priceable,
risk_measure: RiskMeasure) -> PricingFuture:
"""
Calculate the risk measure for the priceable instrument. Do not use directly, use via instruments
:param priceable: The priceable (e.g. instrument)
:param risk_measure: The measure we wish to calculate
:return: A PricingFuture whose result will be the calculation result
**Examples**
>>> from gs_quant.instrument import IRSwap
>>> from gs_quant.risk import IRDelta
>>>
>>> swap = IRSwap('Pay', '10y', 'USD', fixed_rate=0.01)
>>> delta = swap.calc(IRDelta)
"""
with self.active_context.__lock:
risk_key = self.__risk_key(risk_measure, priceable.provider())
future = self.active_context.__pending.get((risk_key, priceable))
if future is None:
future = PricingFuture()
cached_result = PricingCache.get(
risk_key, priceable) if self.use_cache else None
if cached_result is not None:
future.set_result(cached_result)
else:
self.active_context.__pending[(risk_key,
priceable)] = future
if not (self.is_entered or self.is_async):
self.__calc()
return future
