def _pricing_market_data_as_of(
self) -> Tuple[PricingDateAndMarketDataAsOf, ...]:
return tuple(
PricingDateAndMarketDataAsOf(
d,
business_day_offset(d, -1, roll='preceding') if d ==
dt.date.today() else d)
for d in (self.__calc_dates if self.
__calc_dates is not None else self.__date_range))
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.equals(expected)
risk_requests = (risk.RiskRequest(
positions=(risk.RiskPosition(instrument=priceable, quantity=1), ),
measures=(measure, ),
pricing_location=current.market_data_location,
pricing_and_market_data_as_of=(PricingDateAndMarketDataAsOf(
pricing_date=current.pricing_date,
market_data_as_of=current.market.as_of), ),
parameters=RiskRequestParameters(raw_results=True),
wait_for_results=True), )
mocker.assert_called_with(risk_requests)
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=(risk.RiskPosition(instrument=priceable, quantity=1), ),
measures=(measure, ),
pricing_location=current.market_data_location,
pricing_and_market_data_as_of=(PricingDateAndMarketDataAsOf(
pricing_date=current.pricing_date,
market_data_as_of=current.market.as_of), ),
parameters=RiskRequestParameters(raw_results=True),
wait_for_results=True), )
mocker.assert_called_with(risk_requests)
def _pricing_market_data_as_of(self) -> Tuple[PricingDateAndMarketDataAsOf, ...]:
return PricingDateAndMarketDataAsOf(self.pricing_date, self.market_data_as_of),
def __calc(self):
session = GsSession.current
requests_by_provider = {}
def run_requests(requests_: Iterable[RiskRequest], provider_):
results = {}
try:
with session:
results = provider_.calc_multi(requests_)
if self.__is_batch:
results = provider_.get_results(
dict(zip(results, requests_)),
self.__poll_for_batch_results,
timeout=self.__batch_results_timeout).values()
except Exception as e:
results = ({k: e for k in self.__pending.keys()}, )
finally:
with self.__lock:
for result in results:
for (risk_key,
result_priceable), value in result.items():
if self.__use_cache:
PricingCache.put(risk_key, result_priceable,
value)
self.__pending.pop(
(risk_key, result_priceable)).set_result(value)
with self.__lock:
# Group requests optimally
for (key, priceable) in self.__pending.keys():
risk_measures, markets_dates = requests_by_provider.setdefault(key.provider, {})\
.setdefault((key.params, key.scenario, key.market.location, type(key.market)), {})\
.setdefault(priceable, (set(), set()))
risk_measures.add(key.risk_measure)
markets_dates.add((key.date, key.market))
if requests_by_provider:
num_providers = len(requests_by_provider)
request_pool = ThreadPoolExecutor(
num_providers
) if num_providers > 1 or self.__is_async else None
for provider, by_params_scenario in requests_by_provider.items():
requests_for_provider = {}
for (
params, scenario, location, _
), positions_by_market_measures in by_params_scenario.items():
for priceable, (risk_measures, markets_dates
) in positions_by_market_measures.items():
requests_for_provider.setdefault(
(params, scenario, location,
tuple(sorted(risk_measures)),
tuple(sorted(markets_dates))),
[]).append(priceable)
requests = [
RiskRequest(tuple(
RiskPosition(instrument=p, quantity=p.get_quantity())
for p in priceables),
risk_measures,
parameters=self.__parameters,
wait_for_results=not self.__is_batch,
pricing_location=location,
scenario=scenario,
pricing_and_market_data_as_of=tuple(
PricingDateAndMarketDataAsOf(
pricing_date=d,
market_data_as_of=m.as_of)
for d, m in markets_dates),
request_visible_to_gs=self.__visible_to_gs)
for (params, scenario, location, risk_measures,
markets_dates
), priceables in requests_for_provider.items()
]
if request_pool:
request_pool.submit(run_requests, requests, provider)
else:
run_requests(requests, provider)
if request_pool:
request_pool.shutdown(wait=not self.__is_async)