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 = [[[{'value': 0.01}]]]
result = priceable.dollar_price()
assert result == 0.01
risk_request = 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(),
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}]]]]
result = priceable.calc(measure)
assert result == 0.01
risk_requests = (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(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 = {
'$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,),
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 _parameters(self) -> RiskRequestParameters:
return RiskRequestParameters(csa_term=self.__csa_term, raw_results=True)
def _calc(self):
def run_request(request: RiskRequest, session: GsSession):
calc_result = {}
try:
with session:
calc_result = provider.calc(request)
except Exception as e:
for risk_measure in request.measures:
measure_results = {}
for result_position in risk_request.positions:
measure_results[result_position] = str(e)
calc_result[risk_measure] = measure_results
finally:
self._handle_results(calc_result)
from gs_quant.api.risk import RiskApi
def get_batch_results(request: RiskRequest, session: GsSession,
batch_provider: RiskApi, batch_result_id: str):
with session:
results = batch_provider.get_results(request, batch_result_id)
self._handle_results(results)
batch_results = []
pool = ThreadPoolExecutor(len(self.__risk_measures_by_provider_and_position)) if self.__is_async else None
while self.__risk_measures_by_provider_and_position:
provider, risk_measures_by_position = self.__risk_measures_by_provider_and_position.popitem()
positions_by_risk_measures = {}
for position, risk_measures in risk_measures_by_position.items():
positions_by_risk_measures.setdefault(tuple(risk_measures), []).append(position)
for risk_measures, positions in positions_by_risk_measures.items():
risk_request = RiskRequest(
tuple(positions),
tuple(sorted(risk_measures, key=lambda m: m.name or m.measure_type.value)),
parameters=RiskRequestParameters(self.__csa_term),
wait_for_results=not self.__is_batch,
pricing_location=self.market_data_location,
scenario=MarketDataScenario(scenario=Scenario.current) if Scenario.current_is_set else None,
pricing_and_market_data_as_of=self._pricing_market_data_as_of,
request_visible_to_gs=self.__visible_to_gs
)
if self.__is_batch:
batch_results.append((provider, risk_request, provider.calc(risk_request)))
elif pool:
pool.submit(run_request, risk_request, GsSession.current)
else:
run_request(risk_request, GsSession.current)
for provider, risk_request, result_id in batch_results:
if pool:
pool.submit(get_batch_results, risk_request, GsSession.current, provider, result_id)
else:
get_batch_results(risk_request, GsSession.current, provider, result_id)
if pool:
pool.shutdown(wait=not self.__is_async)
def __parameters(self) -> RiskRequestParameters:
return RiskRequestParameters(self.__csa_term)
def _parameters(self) -> RiskRequestParameters:
return RiskRequestParameters(csa_term=self.__csa_term, raw_results=True, \
market_behaviour=self.__market_behaviour)
