def calc(self, priceable: Priceable,
risk_measure: RiskMeasure) -> PricingFuture:
futures = []
provider = priceable.provider
base_scenario = self._scenario
parameters = self._parameters
location = self.market.location
base_market = self.market
for date in self.__date_range:
if date > self.pricing_date:
scenario = MarketDataScenario(
CarryScenario(
int(
business_day_count(dt.datetime.today().date(),
date)), self._roll_to_fwds))
risk_key = RiskKey(provider, date, base_market, parameters,
scenario, risk_measure)
futures.append(self._calc(priceable, risk_key))
else:
market = CloseMarket(location=location,
date=close_market_date(location, date))
risk_key = RiskKey(provider, date, market, parameters,
base_scenario, risk_measure)
futures.append(self._calc(priceable, risk_key))
return HistoricalPricingFuture(futures)
def _handle_results(cls, request: RiskRequest,
results: Union[Iterable, Exception]) -> dict:
formatted_results = {}
if isinstance(results, Exception):
date_results = [{
'$type': 'Error',
'errorString': str(results)
}] * len(request.pricing_and_market_data_as_of)
position_results = [date_results] * len(request.positions)
results = [position_results] * len(request.measures)
for risk_measure, position_results in zip(request.measures, results):
for position, date_results in zip(request.positions,
position_results):
for as_of, date_result in zip(
request.pricing_and_market_data_as_of, date_results):
handler = result_handlers.get(date_result.get('$type'))
risk_key = RiskKey(cls, as_of.pricing_date, as_of.market,
request.parameters, request.scenario,
risk_measure)
try:
result = handler(
date_result, risk_key,
position.instrument) if handler else date_result
except Exception as e:
result = ErrorValue(risk_key, str(e))
_logger.error(result)
formatted_results[(risk_key, position.instrument)] = result
return formatted_results
def _value_for_date(result: Union[DataFrameWithInfo, SeriesWithInfo], date: Union[Iterable, dt.date]) -> \
Union[DataFrameWithInfo, ErrorValue, FloatWithInfo]:
from gs_quant.markets import CloseMarket
raw_value = result.loc[date]
key = result.risk_key
risk_key = RiskKey(
key.provider, date if isinstance(date, dt.date) else tuple(date),
CloseMarket(date=date,
location=key.market.location if isinstance(
key.market, CloseMarket) else None), key.params,
key.scenario, key.risk_measure)
if isinstance(raw_value, ErrorValue):
return raw_value
elif isinstance(raw_value, DataFrameWithInfo):
raw_df = raw_value.raw_value.set_index('dates')
return DataFrameWithInfo(raw_df.reset_index(
drop=True) if isinstance(date, dt.date) else raw_df,
risk_key=risk_key,
unit=result.unit,
error=result.error)
elif isinstance(raw_value, SeriesWithInfo):
return SeriesWithInfo(raw_value.raw_value,
risk_key=risk_key,
unit=result.unit,
error=result.error)
else:
return FloatWithInfo(
risk_key,
raw_value,
unit=result.unit.get(date, '') if result.unit else None,
error=result.error)
def _handle_results(cls, request: RiskRequest, results: Iterable) -> dict:
formatted_results = {}
for risk_measure, position_results in zip(request.measures, results):
for position, date_results in zip(request.positions,
position_results):
for as_of, date_result in zip(
request.pricing_and_market_data_as_of, date_results):
handler = result_handlers.get(date_result.get('$type'))
# TODO Handle this better
market = LiveMarket(request.pricing_location) if isinstance(as_of.market_data_as_of, dt.datetime)\
else ClosingMarket(request.pricing_location, as_of.market_data_as_of)
risk_key = RiskKey(cls, as_of.pricing_date, market,
request.parameters, request.scenario,
risk_measure)
try:
result = handler(
date_result, risk_key,
position.instrument) if handler else date_result
except Exception as e:
result = ErrorValue(risk_key, str(e))
_logger.error(result)
formatted_results[(risk_key, position.instrument)] = result
return formatted_results
def calc(self, instrument: InstrumentBase, risk_measure: RiskMeasure) -> PricingFuture:
futures = []
provider = instrument.provider
base_scenario = self._scenario
parameters = self._parameters
location = self.market.location
base_market = self.market
for date in self.__date_range:
if date > self.pricing_date:
scenario = MarketDataScenario(CarryScenario(date=date, roll_to_fwds=self._roll_to_fwds))
risk_key = RiskKey(provider, date, base_market, parameters, scenario, risk_measure)
futures.append(self._calc(instrument, risk_key))
else:
market = CloseMarket(location=location, date=close_market_date(location, date))
risk_key = RiskKey(provider, date, market, parameters, base_scenario, risk_measure)
futures.append(self._calc(instrument, risk_key))
return HistoricalPricingFuture(futures)
def combine_risk_key(key_1: RiskKey, key_2: RiskKey) -> RiskKey:
"""
Combine two risk keys (key_1, key_2) into a new RiskKey
:type key_1: RiskKey
:type key_2: RiskKey
"""
def get_field_value(field_name: str): getattr(key_1, field_name) \
if getattr(key_1, field_name) == getattr(key_2, field_name) else None
return RiskKey(get_field_value("provider"), get_field_value("date"), get_field_value("market"),
get_field_value("params"), get_field_value("scenario"), get_field_value("risk_measure"))
def calc(self, instrument: InstrumentBase, risk_measure: RiskMeasure) -> PricingFuture:
futures = []
provider = instrument.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(instrument, risk_key))
return HistoricalPricingFuture(futures)
def __risk_key(self, risk_measure: RiskMeasure, provider: type) -> RiskKey:
return RiskKey(provider, self.__pricing_date, self.__market, self._parameters, self._scenario, risk_measure)
def historical_risk_key(risk_key: RiskKey) -> RiskKey:
market = LocationOnlyMarket(risk_key.market.location)
return RiskKey(risk_key.provider, None, market, risk_key.params,
risk_key.scenario, risk_key.risk_measure)
