def _get_tdapi_inflation_rates_assets(allow_many=False,
**kwargs) -> Union[str, list]:
# sanitize input for asset query.
if "pricing_location" in kwargs:
del kwargs["pricing_location"]
assets = GsAssetApi.get_many_assets(**kwargs)
if len(assets) == 0 and ('asset_parameters_clearing_house'
in kwargs): # test without the clearing house
if kwargs[
'asset_parameters_clearing_house'] == tm_rates._ClearingHouse.NONE.value:
del kwargs['asset_parameters_clearing_house']
assets = GsAssetApi.get_many_assets(**kwargs)
if len(assets) > 1:
# term structure measures need multiple assets
if ('asset_parameters_termination_date'
not in kwargs) or ('asset_parameters_effective_date'
not in kwargs) or allow_many:
return [asset.id for asset in assets]
else:
raise MqValueError('Specified arguments match multiple assets')
elif len(assets) == 0:
raise MqValueError(
'Specified arguments did not match any asset in the dataset' +
str(kwargs))
else:
return assets[0].id
def _get_mdapi_rates_assets(**kwargs) -> Union[str, list]:
assets = GsAssetApi.get_many_assets(**kwargs)
# change order of basis swap legs and check if swap in dataset
if len(assets) == 0 and ('asset_parameters_payer_rate_option'
in kwargs): # flip legs
kwargs['asset_parameters_payer_rate_option'], kwargs['asset_parameters_receiver_rate_option'] = \
kwargs['asset_parameters_receiver_rate_option'], kwargs['asset_parameters_payer_rate_option']
kwargs['asset_parameters_payer_designated_maturity'], kwargs['asset_parameters_receiver_designated_maturity'] =\
kwargs['asset_parameters_receiver_designated_maturity'], \
kwargs['asset_parameters_payer_designated_maturity']
assets = GsAssetApi.get_many_assets(**kwargs)
if len(assets) > 1:
# term structure measures need multiple assets
if ('asset_parameters_termination_date'
not in kwargs) or ('asset_parameters_effective_date'
not in kwargs):
return [asset.id for asset in assets]
else:
raise MqValueError('Specified arguments match multiple assets')
elif len(assets) == 0:
raise MqValueError(
'Specified arguments did not match any asset in the dataset')
else:
return assets[0].id
def test_get_many_assets(mocker, monkeypatch):
marquee_id_1 = 'MQA1234567890'
marquee_id_2 = 'MQA4567890123'
query = {'id': [marquee_id_1, marquee_id_2]}
as_of = dt.datetime.utcnow()
inputs = EntityQuery(where=FieldFilterMap(**query),
fields=None,
asOfTime=as_of,
limit=100)
mock_response = {
'results': (GsAsset.from_dict({
'id': marquee_id_1,
'assetClass': 'Equity',
'type': 'Single Stock',
'name': 'Test 1'
}),
GsAsset.from_dict({
'id': marquee_id_2,
'assetClass': 'Equity',
'type': 'Single Stock',
'name': 'Test 2'
}))
}
expected_response = (GsAsset(id=marquee_id_1,
assetClass='Equity',
type='Single Stock',
name='Test 1'),
GsAsset(id=marquee_id_2,
assetClass='Equity',
type='Single Stock',
name='Test 2'))
# mock GsSession
mocker.patch.object(GsSession.__class__,
'default_value',
return_value=GsSession.get(Environment.QA, 'client_id',
'secret'))
mocker.patch.object(GsSession.current, '_post', return_value=mock_response)
# run test
monkeypatch.delenv(ENABLE_ASSET_CACHING, raising=False)
response = GsAssetApi.get_many_assets(id=[marquee_id_1, marquee_id_2],
as_of=as_of)
GsSession.current._post.assert_called_with('/assets/query',
cls=GsAsset,
payload=inputs)
assert response == expected_response
monkeypatch.setenv(ENABLE_ASSET_CACHING, 1) # run 2x with cache on
response = GsAssetApi.get_many_assets(id=[marquee_id_1, marquee_id_2],
as_of=as_of)
assert response == expected_response
response = GsAssetApi.get_many_assets(id=[marquee_id_1, marquee_id_2],
as_of=as_of)
assert response == expected_response
def _get_tdapi_crosscurrency_rates_assets(allow_many=False,
**kwargs) -> Union[str, list]:
# sanitize input for asset query.
if "pricing_location" in kwargs:
del kwargs["pricing_location"]
assets = GsAssetApi.get_many_assets(**kwargs)
# change order of basis swap legs and check if swap in dataset
if len(assets) == 0 and ('asset_parameters_payer_rate_option'
in kwargs): # flip legs
kwargs['asset_parameters_payer_rate_option'], kwargs['asset_parameters_receiver_rate_option'] = \
kwargs['asset_parameters_receiver_rate_option'], kwargs['asset_parameters_payer_rate_option']
if 'asset_parameters_payer_designated_maturity' in kwargs:
kwargs['asset_parameters_payer_designated_maturity'], kwargs[
'asset_parameters_receiver_designated_maturity'] = \
kwargs['asset_parameters_receiver_designated_maturity'], kwargs[
'asset_parameters_payer_designated_maturity']
if 'asset_parameters_payer_currency' in kwargs:
kwargs['asset_parameters_payer_currency'], kwargs['asset_parameters_receiver_currency'] = \
kwargs['asset_parameters_receiver_currency'], kwargs['asset_parameters_payer_currency']
assets = GsAssetApi.get_many_assets(**kwargs)
if len(assets) == 0 and ('asset_parameters_clearing_house'
in kwargs): # test without the clearing house
if kwargs[
'asset_parameters_clearing_house'] == tm_rates._ClearingHouse.NONE.value:
del kwargs['asset_parameters_clearing_house']
assets = GsAssetApi.get_many_assets(**kwargs)
# change order of basis swap legs and check if swap in dataset
if len(assets) == 0 and ('asset_parameters_payer_rate_option'
in kwargs): # flip legs
kwargs['asset_parameters_payer_rate_option'], kwargs['asset_parameters_receiver_rate_option'] = \
kwargs['asset_parameters_receiver_rate_option'], kwargs['asset_parameters_payer_rate_option']
if 'asset_parameters_payer_designated_maturity' in kwargs:
kwargs['asset_parameters_payer_designated_maturity'], kwargs[
'asset_parameters_receiver_designated_maturity'] = \
kwargs['asset_parameters_receiver_designated_maturity'], kwargs[
'asset_parameters_payer_designated_maturity']
if 'asset_parameters_payer_currency' in kwargs:
kwargs['asset_parameters_payer_currency'], kwargs['asset_parameters_receiver_currency'] = \
kwargs['asset_parameters_receiver_currency'], kwargs['asset_parameters_payer_currency']
assets = GsAssetApi.get_many_assets(**kwargs)
if len(assets) > 1:
# term structure measures need multiple assets
if ('asset_parameters_termination_date'
not in kwargs) or ('asset_parameters_effective_date'
not in kwargs) or allow_many:
return [asset.id for asset in assets]
else:
raise MqValueError('Specified arguments match multiple assets')
elif len(assets) == 0:
raise MqValueError(
'Specified arguments did not match any asset in the dataset' +
str(kwargs))
else:
return assets[0].id
def _get_tdapi_fxo_assets_vol_swaps(**kwargs) -> Union[str, list]:
# sanitize input for asset query.
expiry_tenor = kwargs.get("expiry_tenor")
ignore_list = ["expiry_tenor", "pricing_location"]
inputs = {k: v for k, v in kwargs.items() if k not in ignore_list}
assets = GsAssetApi.get_many_assets(**inputs)
# For vol swaps we are not restricting assets using a filter
# as asset service isn't setup for the parameters we pass in
# instead query all assets and apply the filter in code here
if len(assets) == 0:
raise MqValueError('No assets found matching search criteria' +
str(kwargs))
if expiry_tenor is not None:
for asset in assets:
if asset.parameters["lastFixingDate"].lower(
) == expiry_tenor.lower():
return asset.id
raise MqValueError(
'Specified arguments did not match any asset in the dataset' +
str(kwargs))
def _convert_asset_for_mdapi_swap_rates(**kwargs) -> str:
assets = GsAssetApi.get_many_assets(**kwargs)
if len(assets) > 1:
raise MqValueError('Specified arguments match multiple assets')
elif len(assets) == 0:
raise MqValueError('Specified arguments did not match any asset in the dataset')
else:
return assets[0].id
def build_tree(self, dataset, underlier_column):
"""
Build the full tree and return the root node
"""
query = self.__get_direct_underliers(self.id, dataset)
if len(query) > 0:
all_ids = query[underlier_column].tolist()
all_assets = GsAssetApi.get_many_assets(id=all_ids)
asset_lookup = {mq_id: asset_obj for mq_id, asset_obj in zip(all_ids, all_assets)}
for i_, row in query.iterrows():
child_node = AssetTreeNode(row[underlier_column], self.depth + 1, self.date,
asset_lookup[row[underlier_column]])
child_node.build_tree(dataset, underlier_column)
self.direct_underlier_assets_as_nodes.append(child_node)
def _get_tdapi_fxo_assets(**kwargs) -> Union[str, list]:
# sanitize input for asset query.
if "pricing_location" in kwargs:
del kwargs["pricing_location"]
assets = GsAssetApi.get_many_assets(**kwargs)
if len(assets) > 1:
raise MqValueError('Specified arguments match multiple assets' +
str(kwargs))
elif len(assets) == 0:
raise MqValueError(
'Specified arguments did not match any asset in the dataset' +
str(kwargs))
else:
return assets[0].id
def get_asset(cls,
id_value: str,
id_type: AssetIdentifier,
as_of: Union[dt.date, dt.datetime] = None,
exchange_code: ExchangeCode = None,
asset_type: AssetType = None,
sort_by_rank: bool = False) -> Asset:
"""
Get an asset by identifier and identifier type
:param id_value: identifier value
:param id_type: identifier type
:param exchange_code: exchange code
:param asset_type: asset type
:param as_of: As of date for query
:param sort_by_rank: whether to sort assets by rank.
:return: Asset object or None
**Usage**
Get asset object using a specified identifier and identifier type. Where the identifiers are temporal (and can
change over time), will use the current MarketContext to evaluate based on the specified date.
**Examples**
Get asset by bloomberg id:
>>> gs = SecurityMaster.get_asset("GS UN", AssetIdentifier.BLOOMBERG_ID)
Get asset by ticker and exchange code:
>>> gs = SecurityMaster.get_asset("GS", AssetIdentifier.TICKER, exchange_code=ExchangeCode.NYSE)
Get asset by ticker and asset type:
>>> spx = SecurityMaster.get_asset("SPX", AssetIdentifier.TICKER, asset_type=AssetType.INDEX)
**See also**
:class:`AssetIdentifier`
:func:`get_many_assets`
"""
if not as_of:
as_of = PricingContext.current.pricing_date
if isinstance(as_of, dt.date):
as_of = dt.datetime.combine(as_of, dt.time(0, 0), pytz.utc)
if id_type is AssetIdentifier.MARQUEE_ID:
gs_asset = GsAssetApi.get_asset(id_value)
return cls.__gs_asset_to_asset(gs_asset)
query = {id_type.value.lower(): id_value}
if exchange_code is not None:
query['exchange'] = exchange_code.value
if asset_type is not None:
query['type'] = [
t.value for t in cls.__asset_type_to_gs_types(asset_type)
]
if sort_by_rank:
results = GsAssetApi.get_many_assets(as_of=as_of,
return_type=dict,
order_by=['>rank'],
**query)
result = get(results, '0')
if result:
result = GsAsset.from_dict(result)
else:
results = GsAssetApi.get_many_assets(as_of=as_of, **query)
result = next(iter(results), None)
if result:
return cls.__gs_asset_to_asset(result)
def get_asset(cls,
id_value: str,
id_type: AssetIdentifier,
as_of: Union[dt.date, dt.datetime] = None,
exchange_code: ExchangeCode = None,
asset_type: AssetType = None,
key: Optional[Callable] = None) -> Asset:
"""
Get an asset by identifier and identifier type
:param id_value: identifier value
:param id_type: identifier type
:param exchange_code: exchange code
:param asset_type: asset type
:param as_of: As of date for query
:param key: key function to sort assets
:return: Asset object or None
**Usage**
Get asset object using a specified identifier and identifier type. Where the identifiers are temporal (and can
change over time), will use the current MarketContext to evaluate based on the specified date. If multiple
assets are found, the first one is returned (caller can provide a key function to sort them).
**Examples**
Get asset by bloomberg id:
>>> gs = SecurityMaster.get_asset("GS UN", AssetIdentifier.BLOOMBERG_ID)
Get asset by ticker and exchange code:
>>> gs = SecurityMaster.get_asset("GS", AssetIdentifier.TICKER, exchange_code=ExchangeCode.NYSE)
Get asset by ticker and asset type:
>>> spx = SecurityMaster.get_asset("SPX", AssetIdentifier.TICKER, asset_type=AssetType.INDEX)
**See also**
:class:`AssetIdentifier`
:func:`get_many_assets`
"""
if not as_of:
as_of = PricingContext.current.pricing_date
if isinstance(as_of, dt.date):
as_of = dt.datetime.combine(as_of, dt.time(0, 0), pytz.utc)
if id_type is AssetIdentifier.MARQUEE_ID:
gs_asset = GsAssetApi.get_asset(id_value)
return cls.__gs_asset_to_asset(gs_asset)
query = {id_type.value.lower(): id_value}
if exchange_code is not None:
query['exchange'] = exchange_code.value
if asset_type is not None:
query['type'] = [t.value for t in cls.__asset_type_to_gs_types(asset_type)]
results = GsAssetApi.get_many_assets(as_of=as_of, **query)
if key is not None:
results = sorted(results, key=key)
result = next(iter(results), None)
if result:
return cls.__gs_asset_to_asset(result)
def basis_swap_term_structure(asset: Asset, spread_benchmark_type: BenchmarkType = None, spread_tenor: str = None,
reference_benchmark_type: BenchmarkType = None, reference_tenor: str = None,
forward_tenor: Optional[GENERIC_DATE] = None,
clearing_house: _ClearingHouse = None,
pricing_date: Optional[GENERIC_DATE] = None,
*, source: str = None, real_time: bool = False, ) -> Series:
"""
GS end-of-day Floating-Floating interest rate swap (IRS) term structure across major currencies.
:param asset: asset object loaded from security master
:param spread_benchmark_type: benchmark type of spread leg on which basis spread is added e.g. LIBOR
:param spread_tenor: relative date representation of expiration date of spread leg e.g. 1m
:param reference_benchmark_type: benchmark type of reference leg e.g. LIBOR
:param reference_tenor: relative date representation of expiration date of reference leg e.g. 1m
:param forward_tenor: absolute / relative date representation of forward starting point eg: '1y' or 'Spot' for
spot starting swaps, 'imm1' or 'frb1'
:param clearing_house: Example - "LCH", "EUREX", "JSCC", "CME"
:param pricing_date: YYYY-MM-DD or relative date
:param source: name of function caller
:param real_time: whether to retrieve intraday data instead of EOD
:return: swap rate curve
"""
if real_time:
raise NotImplementedError('realtime basis_swap_rate not implemented')
currency = CurrencyEnum(asset.get_identifier(AssetIdentifier.BLOOMBERG_ID))
if currency.value not in ['JPY', 'EUR', 'USD', 'GBP']:
raise NotImplementedError('Data not available for {} basis swap rates'.format(currency.value))
clearing_house = _check_clearing_house(clearing_house)
for benchmark_type in [spread_benchmark_type, reference_benchmark_type]:
_check_benchmark_type(currency, benchmark_type)
# default benchmark types
legs_w_defaults = dict()
legs_w_defaults['spread'] = _get_swap_leg_defaults(currency, spread_benchmark_type, spread_tenor)
legs_w_defaults['reference'] = _get_swap_leg_defaults(currency, reference_benchmark_type, reference_tenor)
for key, leg in legs_w_defaults.items():
if not re.fullmatch('(\\d+)([bdwmy])', leg['floating_rate_tenor']):
raise MqValueError('invalid floating rate tenor ' + leg['floating_rate_tenor'] + ' index: ' +
leg['benchmark_type'])
forward_tenor = check_forward_tenor(forward_tenor)
calendar = legs_w_defaults['spread']['pricing_location'].value
if pricing_date is not None and pricing_date in list(GsCalendar.get(calendar).holidays):
raise MqValueError('Specified pricing date is a holiday in {} calendar'.format(calendar))
csaTerms = currency.value + '-1'
kwargs = dict(type='BasisSwap', asset_parameters_payer_rate_option=legs_w_defaults['spread']['benchmark_type'],
asset_parameters_payer_designated_maturity=legs_w_defaults['spread']['floating_rate_tenor'],
asset_parameters_receiver_rate_option=legs_w_defaults['reference']['benchmark_type'],
asset_parameters_receiver_designated_maturity=legs_w_defaults['reference']['floating_rate_tenor'],
asset_parameters_clearing_house=clearing_house.value, asset_parameters_effective_date=forward_tenor,
asset_parameters_notional_currency=currency.name,
pricing_location=legs_w_defaults['spread']['pricing_location'].value)
assets = GsAssetApi.get_many_assets(**kwargs)
if len(assets) == 0:
raise MqValueError('Specified arguments did not match any asset in the dataset')
else:
rate_mqids = [asset.id for asset in assets]
asset_string = ''
for mqid in rate_mqids:
asset_string = asset_string + ',' + mqid
_logger.debug('assets returned %s', asset_string)
_logger.debug('where spread_benchmark_type=%s, spread_tenor=%s, reference_benchmark_type=%s, '
'reference_tenor=%s, forward_tenor=%s, pricing_location=%s ',
legs_w_defaults['spread']['benchmark_type'], legs_w_defaults['spread']['floating_rate_tenor'],
legs_w_defaults['reference']['benchmark_type'], legs_w_defaults['reference']['floating_rate_tenor'],
forward_tenor, legs_w_defaults['spread']['pricing_location'].value)
start, end = _range_from_pricing_date(calendar, pricing_date)
with DataContext(start, end):
where = dict(csaTerms=csaTerms)
q = GsDataApi.build_market_data_query(rate_mqids, QueryType.BASIS_SWAP_RATE, where=where,
source=source, real_time=real_time)
_logger.debug('q %s', q)
df = _market_data_timed(q)
if df.empty:
series = ExtendedSeries()
else:
latest = df.index.max()
_logger.info('selected pricing date %s', latest)
df = df.loc[latest]
business_day = _get_custom_bd(calendar)
df = df.assign(expirationDate=df.index + df['terminationTenor'].map(_to_offset) + business_day - business_day)
df = df.set_index('expirationDate')
df.sort_index(inplace=True)
df = df.loc[DataContext.current.start_date: DataContext.current.end_date]
series = ExtendedSeries() if df.empty else ExtendedSeries(df['basisSwapRate'])
series.dataset_ids = getattr(df, 'dataset_ids', ())
return series
def basis_swap_term_structure(
asset: Asset,
spread_benchmark_type: BenchmarkType = None,
spread_tenor: str = None,
reference_benchmark_type: BenchmarkType = None,
reference_tenor: str = None,
forward_tenor: str = 'Spot',
pricing_date: Optional[GENERIC_DATE] = None,
*,
source: str = None,
real_time: bool = False,
) -> Series:
"""
GS end-of-day Floating-Floating interest rate swap (IRS) term structure across major currencies.
:param asset: asset object loaded from security master
:param spread_benchmark_type: benchmark type of spread leg on which basis spread is added e.g. LIBOR
:param spread_tenor: relative date representation of expiration date of spread leg e.g. 1m
:param reference_benchmark_type: benchmark type of reference leg e.g. LIBOR
:param reference_tenor: relative date representation of expiration date of reference leg e.g. 1m
:param forward_tenor: relative date representation of forward starting point eg: '1y' or 'Spot' for spot
starting swaps
:param pricing_date: YYYY-MM-DD or relative date
:param source: name of function caller
:param real_time: whether to retrieve intraday data instead of EOD
:return: swap rate curve
"""
if real_time:
raise NotImplementedError('realtime basis_swap_rate not implemented')
currency = CurrencyEnum(asset.get_identifier(AssetIdentifier.BLOOMBERG_ID))
if currency.value not in ['JPY', 'EUR', 'USD', 'GBP']:
raise NotImplementedError(
'Data not available for {} basis swap rates'.format(
currency.value))
for benchmark_type in [spread_benchmark_type, reference_benchmark_type]:
if benchmark_type is not None and \
benchmark_type.value not in CURRENCY_TO_SWAP_RATE_BENCHMARK[currency.value].keys():
raise MqValueError('%s is not supported for %s', benchmark_type,
currency.value)
for floating_rate_tenor in [spread_tenor, reference_tenor]:
if not re.fullmatch('(\\d+)([bdwmy])', floating_rate_tenor):
raise MqValueError('invalid floating rate tenor ' +
floating_rate_tenor)
if forward_tenor == '0b' or forward_tenor is None or forward_tenor == 'Spot':
forward_tenor = '0d'
elif not re.fullmatch('(\\d+)([bdwmy])', forward_tenor):
raise MqValueError('invalid forward tenor ' + forward_tenor)
# default benchmark types
legs_w_defaults = dict()
legs_w_defaults['spread'] = _get_swap_leg_defaults(currency,
spread_benchmark_type,
spread_tenor)
legs_w_defaults['reference'] = _get_swap_leg_defaults(
currency, reference_benchmark_type, reference_tenor)
csaTerms = currency.value + '-1'
clearing_house = 'LCH'
kwargs = dict(
type='BasisSwap',
asset_parameters_payer_rate_option=legs_w_defaults['spread']
['benchmark_type'],
asset_parameters_payer_designated_maturity=legs_w_defaults['spread']
['floating_rate_tenor'],
asset_parameters_receiver_rate_option=legs_w_defaults['reference']
['benchmark_type'],
asset_parameters_receiver_designated_maturity=legs_w_defaults[
'reference']['floating_rate_tenor'],
asset_parameters_clearing_house=clearing_house,
asset_parameters_effective_date=forward_tenor,
asset_parameters_notional_currency=currency.name,
pricing_location=legs_w_defaults['spread']['pricing_location'])
assets = GsAssetApi.get_many_assets(**kwargs)
if len(assets) == 0:
raise MqValueError(
'Specified arguments did not match any asset in the dataset')
else:
rate_mqids = [asset.id for asset in assets]
_logger.debug(
'where spread_benchmark_type=%s, spread_tenor=%s, reference_benchmark_type=%s, '
'reference_tenor=%s, forward_tenor=%s, pricing_location=%s ',
legs_w_defaults['spread']['benchmark_type'],
legs_w_defaults['spread']['floating_rate_tenor'],
legs_w_defaults['reference']['benchmark_type'],
legs_w_defaults['reference']['floating_rate_tenor'], forward_tenor,
legs_w_defaults['spread']['pricing_location'])
start, end = _range_from_pricing_date(assets[0].exchange, pricing_date)
with DataContext(start, end):
where = FieldFilterMap(csaTerms=csaTerms)
q = GsDataApi.build_market_data_query(rate_mqids,
QueryType.BASIS_SWAP_RATE,
where=where,
source=source,
real_time=real_time)
_logger.debug('q %s', q)
df = _market_data_timed(q)
if df.empty:
return pd.Series()
latest = df.index.max()
_logger.info('selected pricing date %s', latest)
df = df.loc[latest]
business_day = _get_custom_bd(asset.exchange)
df = df.assign(expirationDate=df.index +
df['terminationTenor'].map(_to_offset) + business_day -
business_day)
df = df.set_index('expirationDate')
df.sort_index(inplace=True)
df = df.loc[DataContext.current.start_date:DataContext.current.end_date]
return df['basisSwapRate'] if not df.empty else pd.Series()
def swap_term_structure(asset: Asset,
benchmark_type: BenchmarkType = None,
floating_rate_tenor: str = None,
forward_tenor: Optional[GENERIC_DATE] = None,
pricing_date: Optional[GENERIC_DATE] = None,
*,
source: str = None,
real_time: bool = False) -> Series:
"""
GS end-of-day Fixed-Floating interest rate swap (IRS) term structure across major currencies.
:param asset: asset object loaded from security master
:param benchmark_type: benchmark type e.g. LIBOR
:param floating_rate_tenor: floating index rate
:param forward_tenor: absolute / relative date representation of forward starting point eg: '1y' or 'Spot' for
spot starting swaps, 'imm1' or 'frb1'
:param pricing_date: YYYY-MM-DD or relative date
:param source: name of function caller
:param real_time: whether to retrieve intraday data instead of EOD
:return: swap rate term structure
"""
if real_time:
raise NotImplementedError('realtime swap_rate not implemented')
currency = asset.get_identifier(AssetIdentifier.BLOOMBERG_ID)
currency = CurrencyEnum(currency)
if currency.value not in ['JPY', 'EUR', 'USD', 'GBP', 'CHF', 'SEK']:
raise NotImplementedError(
'Data not available for {} swap rates'.format(currency.value))
clearing_house = 'LCH'
_check_benchmark_type(currency, benchmark_type)
forward_tenor = check_forward_tenor(forward_tenor)
defaults = _get_swap_leg_defaults(currency, benchmark_type,
floating_rate_tenor)
if not re.fullmatch('(\\d+)([bdwmy])', defaults['floating_rate_tenor']):
raise MqValueError('invalid floating rate tenor ' +
defaults['floating_rate_tenor'] + ' for index: ' +
defaults['benchmark_type'])
calendar = defaults['pricing_location'].value
if pricing_date is not None and pricing_date in list(
GsCalendar.get(calendar).holidays):
raise MqValueError(
'Specified pricing date is a holiday in {} calendar'.format(
calendar))
csaTerms = currency.value + '-1'
fixed_rate = 'ATM'
kwargs = dict(
type='Swap',
asset_parameters_floating_rate_option=defaults['benchmark_type'],
asset_parameters_fixed_rate=fixed_rate,
asset_parameters_clearing_house=clearing_house,
asset_parameters_floating_rate_designated_maturity=defaults[
'floating_rate_tenor'],
asset_parameters_effective_date=forward_tenor,
asset_parameters_notional_currency=currency.name,
pricing_location=defaults['pricing_location'].value)
assets = GsAssetApi.get_many_assets(**kwargs)
if len(assets) == 0:
raise MqValueError(
'Specified arguments did not match any asset in the dataset')
else:
rate_mqids = [asset.id for asset in assets]
asset_string = ''
for mqid in rate_mqids:
asset_string = asset_string + ',' + mqid
_logger.debug('assets returned %s', asset_string)
_logger.debug(
'where benchmark_type=%s, floating_rate_tenor=%s, forward_tenor=%s, '
'pricing_location=%s', defaults['benchmark_type'],
defaults['floating_rate_tenor'], forward_tenor,
defaults['pricing_location'].value)
start, end = _range_from_pricing_date(calendar, pricing_date)
with DataContext(start, end):
where = FieldFilterMap(csaTerms=csaTerms)
q = GsDataApi.build_market_data_query(rate_mqids,
QueryType.SWAP_RATE,
where=where,
source=source,
real_time=real_time)
_logger.debug('q %s', q)
df = _market_data_timed(q)
if df.empty:
return pd.Series()
latest = df.index.max()
_logger.info('selected pricing date %s', latest)
df = df.loc[latest]
business_day = _get_custom_bd(calendar)
df = df.assign(expirationDate=df.index +
df['terminationTenor'].map(_to_offset) + business_day -
business_day)
df = df.set_index('expirationDate')
df.sort_index(inplace=True)
df = df.loc[DataContext.current.start_date:DataContext.current.end_date]
return df['swapRate'] if not df.empty else pd.Series()