def test_cross_to_usd_based_cross_for_fx_forecast(mocker):
mocker.patch.object(GsSession.__class__,
'current',
return_value=GsSession.get(Environment.QA, 'client_id',
'secret'))
mocker.patch.object(GsSession.current, '_get', side_effect=mock_request)
mocker.patch.object(GsSession.current, '_post', side_effect=mock_request)
asset_id_list = ["MAYJPCVVF2RWXCES", "MATGYV0J9MPX534Z"]
correct_mapping = ["MATGYV0J9MPX534Z", "MATGYV0J9MPX534Z"]
with tm.PricingContext(dt.date.today()):
for i in range(len(asset_id_list)):
correct_id = tm.cross_to_usd_based_cross(asset_id_list[i])
assert correct_id == correct_mapping[i]
def test_currency_to_default_benchmark_rate(mocker):
mocker.patch.object(GsSession.__class__, 'current',
return_value=GsSession.get(Environment.QA, 'client_id', 'secret'))
mocker.patch.object(GsSession.current, '_get', side_effect=mock_request)
mocker.patch.object(GsAssetApi, 'map_identifiers', side_effect=map_identifiers_default_mocker)
asset_id_list = ["MAZ7RWC904JYHYPS", "MAJNQPFGN1EBDHAE", "MA66CZBQJST05XKG", "MAK1FHKH5P5GJSHH", "MA4J1YB8XZP2BPT8",
"MA4B66MW5E27U8P32SB"]
correct_mapping = ["MAPDB7QNB2TZVQ0E", "MAJNQPFGN1EBDHAE", "MAFYB8Z4R1377A19", "MABMVE27EM8YZK33",
"MA4J1YB8XZP2BPT8", "MA4B66MW5E27U8P32SB"]
with tm.PricingContext(dt.date.today()):
for i in range(len(asset_id_list)):
correct_id = tm.currency_to_default_benchmark_rate(asset_id_list[i])
assert correct_id == correct_mapping[i]
def test_coordinate_last(mocker):
data = {'responses': [
{'data': [
{
'mktType': 'Prime',
'mktAsset': '335320934',
'mktQuotingStyle': 'price',
'price': 1.0141,
'time': '2019-01-20T01:08:00Z'
}
]},
{'data': [
{
'mktType': 'IR',
'mktAsset': 'USD',
'mktClass': 'Swap',
'mktPoint': ('2Y',),
'mktQuotingStyle': 'ATMRate',
'ATMRate': 0.02592,
'time': '2019-01-20T01:09:45Z'
}
]}
]}
expected_result = pd.DataFrame(
data={
'mktType': ['Prime', 'IR'],
'mktAsset': ['335320934', 'USD'],
'mktClass': [None, 'Swap'],
'mktPoint': [None, ('2Y',)],
'mktQuotingStyle': ['price', None],
'value': [1.0141, 0.02592]
}
)
# mock GsSession and data response
mocker.patch.object(GsSession.__class__, 'current',
return_value=GsSession.get(Environment.QA, 'client_id', 'secret'))
GsSession.current._post = mocker.Mock(return_value=data)
result = GsDataApi.coordinates_last(coordinates=test_coordinates, as_of=dt.datetime(2019, 1, 2, 1, 10),
as_dataframe=True)
assert result.equals(expected_result)
result_from_str = GsDataApi.coordinates_last(coordinates=test_str_coordinates, as_of=dt.datetime(2019, 1, 2, 1, 10),
as_dataframe=True)
assert result_from_str.equals(expected_result)
GsSession.current._post.assert_called_with('/data/coordinates/query/last', payload=mocker.ANY)
assert GsSession.current._post.call_count == 2
def test_rdate_datagrid(mocker):
mocker.patch.object(GsSession.__class__, 'default_value',
return_value=GsSession.get(Environment.QA, 'client_id', 'secret'))
name = 'Testing'
SPX = get_test_entity('MA4B66MW5E27U8P32SB')
close = DataCoordinate(
measure=DataMeasure.CLOSE_PRICE,
frequency=DataFrequency.DAILY,
)
last_trade_price = DataCoordinate(
measure=DataMeasure.TRADE_PRICE,
frequency=DataFrequency.REAL_TIME,
)
rows = [
DataRow(SPX),
]
columns = [
DataColumn(name="1d Chg (RT)",
processor=ChangeProcessor(AppendProcessor(close, last_trade_price,
start=RelativeDate("-1d",
base_date=date(2021, 1, 22)))))
]
datagrid = DataGrid(name=name, rows=rows, columns=columns)
start_date = datagrid.columns[0].processor.children['a'].start
assert start_date.base_date == RelativeDate('-1d', base_date=date(2021, 1, 22)).base_date
assert start_date.rule == RelativeDate('-1d').rule
datagrid.initialize()
datagrid.poll()
assert str(datagrid._data_queries[0].query.start) == '2021-01-21'
as_dict = datagrid.as_dict()
start = as_dict['parameters']['columns'][0]['parameters']['a']['parameters']['start']
assert start['type'] == 'relativeDate'
assert start['value'] == {'rule': '-1d', 'baseDate': '2021-01-22'}
# Check that base_date is not persisted when not passed in.
columns = [
DataColumn(name="1d Chg (RT)",
processor=ChangeProcessor(AppendProcessor(close, last_trade_price,
start=RelativeDate("-1d"))))
]
datagrid = DataGrid(name=name, rows=rows, columns=columns)
as_dict = datagrid.as_dict()
start = as_dict['parameters']['columns'][0]['parameters']['a']['parameters']['start']
assert start['type'] == 'relativeDate'
assert start['type'] == 'relativeDate'
assert start['value'] == {'rule': '-1d'}
def get_instruments_by_position_type(
cls, positions_type: str,
positions_id: str) -> Tuple[Instrument, ...]:
root = 'deals' if positions_type == 'ETI' else 'books/' + positions_type
url = '/risk-internal/{}/{}/positions'.format(root, positions_id)
with GsSession.get(Environment.QA) as session:
# TODO Remove this once in prod
results = session._get(url)
return tuple(
Instrument.from_dict(p['instrument'])
for p in results.get('positionSets', ({
'positions': ()
}, ))[0]['positions'])
def test_get_many_defns_api(mocker):
test_defn = DataSetEntity.from_dict(test_defn_dict)
mock_response = {'results': (test_defn,), 'totalResults': 1}
expected_response = (test_defn,)
# mock GsSession
mocker.patch.object(GsSession.__class__, 'default_value',
return_value=GsSession.get(Environment.QA, 'client_id', 'secret'))
mocker.patch.object(GsSession.current, '_get', return_value=mock_response)
# run test
response = GsDataApi.get_many_definitions()
GsSession.current._get.assert_called_with('/data/datasets?limit=100', cls=DataSetEntity)
assert response == expected_response
def test_get_many_coordinates(mocker):
coordinates = [{
'id': 'MC123',
'name': 'A_B_C_D_E.F1'
}, {
'id': 'MC123',
'name': 'A_B_C_D_E.F2'
}]
mocker.patch.object(GsSession.__class__,
'default_value',
return_value=GsSession.get(Environment.QA, 'client_id',
'secret'))
GsSession.current._post = mocker.Mock(
return_value={'results': coordinates})
response = GsDataApi.get_many_coordinates(mkt_type='A', mkt_asset='B')
assert response == ('A_B_C_D_E.F1', 'A_B_C_D_E.F2')
def test_cross_to_basis(mocker):
mocker.patch.object(GsSession.__class__,
'current',
return_value=GsSession.get(Environment.QA, 'client_id',
'secret'))
mocker.patch.object(GsSession.current, '_get', side_effect=mock_request)
mocker.patch.object(GsAssetApi,
'map_identifiers',
side_effect=map_identifiers_cross_basis_mocker)
asset_id_list = ["MAYJPCVVF2RWXCES", "MA4B66MW5E27U8P32SB", "nobbid"]
correct_mapping = ["MA99N6C1KF9078NM", "MA4B66MW5E27U8P32SB", "nobbid"]
with tm.PricingContext(dt.date.today()):
for i in range(len(asset_id_list)):
correct_id = tm.cross_to_basis(asset_id_list[i])
assert correct_id == correct_mapping[i]
def test_data_series_format(mocker):
start = dt.date(2019, 1, 2)
end = dt.datetime(2019, 1, 9)
df = pd.DataFrame(test_data)
index = pd.to_datetime(df.loc[:, 'date'].values)
expected = pd.Series(index=index, data=df.loc[:, 'tradePrice'].values)
expected = expected.rename_axis('date')
# mock GsSession and data response
mocker.patch.object(GsSession.__class__,
'default_value',
return_value=GsSession.get(Environment.QA, 'client_id',
'secret'))
mock_response = {'requestId': 'qwerty', 'data': test_data}
mocker.patch.object(GsSession.current,
'_post',
side_effect=lambda *args, **kwargs: mock_response)
mocker.patch.object(GsDataApi,
'symbol_dimensions',
return_value=('assetId', ))
mocker.patch("gs_quant.api.gs.data.GsDataApi.get_types",
return_value=test_types)
actual = Dataset('TREOD').get_data_series(field='tradePrice',
start=start,
end=end,
assetId='MA4B66MW5E27U8P32SB')
pd.testing.assert_series_equal(actual, expected)
assert len(GsSession.current._post.mock_calls) == 1
name, args, kwargs = GsSession.current._post.mock_calls[0]
assert kwargs['payload'].format == Format.MessagePack
assert kwargs['request_headers'] == {'Accept': 'application/msgpack'}
assert args[0] == '/data/TREOD/query'
GsSession.current._post.reset_mock()
actual = Dataset('TREOD').get_data_series(field='tradePrice',
start=start,
end=end,
assetId='MA4B66MW5E27U8P32SB',
format=Format.Json)
pd.testing.assert_series_equal(actual, expected)
assert len(GsSession.current._post.mock_calls) == 1
name, args, kwargs = GsSession.current._post.mock_calls[0]
assert kwargs['payload'].format == Format.Json
assert 'request_headers' not in kwargs
assert args[0] == '/data/TREOD/query'
def test_currency_to_tdapi_swaption_rate_asset_retuns_asset_id(mocker):
replace = Replacer()
mocker.patch.object(GsSession.__class__,
'current',
return_value=GsSession.get(Environment.QA, 'client_id',
'secret'))
mocker.patch.object(GsSession.current, '_get', side_effect=mock_request)
mocker.patch.object(SecurityMaster, 'get_asset', side_effect=mock_request)
bbid_mock = replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock())
with tm.PricingContext(dt.date.today()):
cur = [{
"currency_assetId": "MAK1FHKH5P5GJSHH",
"currency": "JPY",
"swaption_id": "MATT7CA7PRA4B8YB"
}, {
"currency_assetId": "MA66CZBQJST05XKG",
"currency": "GBP",
"swaption_id": "MAX2SBXZRPYR3NTY"
}, {
"currency_assetId": "MAPSDDS072PHYMVQ",
"currency": "AUD",
"swaption_id": "MAQHSC1PAF4X5H4B"
}, {
"currency_assetId": "MAJNQPFGN1EBDHAE",
"currency": "EUR",
"swaption_id": "MAZB3PAH8JFVVT80"
}, {
"currency_assetId": "MAZ7RWC904JYHYPS",
"currency": "USD",
"swaption_id": "MAY0X3KRD4AN77E2"
}]
for c in cur:
print(c)
asset = Currency(c.get("currency_assetId"), c.get("currency"))
bbid_mock.return_value = c.get("currency")
mqid = _currency_to_tdapi_swaption_rate_asset(asset)
assert mqid == c.get("swaption_id")
bbid_mock.return_value = None
assert _currency_to_tdapi_swaption_rate_asset(asset) == c.get(
"currency_assetId")
replace.restore()
def test_auto_scroll_on_pages(mocker):
response = {
"requestId": "049de678-1480000",
"totalPages": 5,
"data": [{
"date": "2012-01-25",
"assetId": "MADXKSGX6921CFNF",
"value": 1
}]
}
mocker.patch.object(ContextMeta,
'current',
return_value=GsSession(Environment.QA))
mocker.patch.object(ContextMeta.current, '_post', return_value=response)
query = DataQuery(start_date=dt.date(2017, 1, 15),
end_date=dt.date(2017, 1, 18),
where=FieldFilterMap(currency="GBP"))
response = GsDataApi.get_results("test", response, query)
assert len(response) == 5
def test_coordinate_data_series(mocker):
# mock GsSession and data response
mocker.patch.object(GsSession.__class__, 'current',
return_value=GsSession.get(Environment.QA, 'client_id', 'secret'))
mocker.patch.object(GsSession.current, '_post', side_effect=[{'responses': [{'data': bond_data}]},
{'responses': [{'data': swap_data}]},
{'responses': [{'data': bond_data},
{'data': swap_data}]},
{'responses': [{'data': bond_data},
{'data': swap_data}]}
])
bond_expected_series = pd.Series(index=bond_expected_frame.index, data=bond_expected_frame.value.values)
swap_expected_series = pd.Series(index=swap_expected_frame.index, data=swap_expected_frame.value.values)
coord_data_result = GsDataApi.coordinates_data_series(coordinates=test_coordinates[0],
start=dt.datetime(2019, 1, 2, 1, 0),
end=dt.datetime(2019, 1, 2, 1, 10))
assert_series_equal(coord_data_result, bond_expected_series)
str_coord_data_result = GsDataApi.coordinates_data_series(coordinates=test_str_coordinates[1],
start=dt.datetime(2019, 1, 2, 1, 0),
end=dt.datetime(2019, 1, 2, 1, 10))
assert_series_equal(str_coord_data_result, swap_expected_series)
coords_data_result = GsDataApi.coordinates_data_series(coordinates=test_coordinates,
start=dt.datetime(2019, 1, 2, 1, 0),
end=dt.datetime(2019, 1, 2, 1, 10))
assert len(coords_data_result) == 2
assert_series_equal(coords_data_result[0], bond_expected_series)
assert_series_equal(coords_data_result[1], swap_expected_series)
str_coords_data_result = GsDataApi.coordinates_data_series(coordinates=test_str_coordinates,
start=dt.datetime(2019, 1, 2, 1, 0),
end=dt.datetime(2019, 1, 2, 1, 10))
assert len(str_coords_data_result) == 2
assert_series_equal(str_coords_data_result[0], bond_expected_series)
assert_series_equal(str_coords_data_result[1], swap_expected_series)
GsSession.current._post.assert_called_with('/data/coordinates/query', payload=mocker.ANY)
assert GsSession.current._post.call_count == 4
def test_coordinate_data_series(mocker):
start = dt.datetime(2019, 1, 2, 1, 0)
end = dt.datetime(2019, 1, 2, 1, 10)
# mock GsSession and data response
mocker.patch.object(GsSession.__class__, 'default_value',
return_value=GsSession.get(Environment.QA, 'client_id', 'secret'))
mocker.patch.object(GsSession.current, '_post', side_effect=[{'responses': [{'data': bond_data}]},
{'responses': [{'data': swap_data}]},
{'responses': [{'data': bond_data},
{'data': swap_data}]},
{'responses': [{'data': bond_data},
{'data': swap_data}]}
])
bond_expected_series = pd.Series(index=bond_expected_frame.index, data=bond_expected_frame.value.values)
swap_expected_series = pd.Series(index=swap_expected_frame.index, data=swap_expected_frame.value.values)
coord_data_result = GsDataApi.coordinates_data_series(coordinates=test_coordinates[0], start=start, end=end)
assert_series_equal(coord_data_result, bond_expected_series)
str_coord_data_result = GsDataApi.coordinates_data_series(coordinates=test_str_coordinates[1], start=start, end=end)
assert_series_equal(str_coord_data_result, swap_expected_series)
coords_data_result = GsDataApi.coordinates_data_series(coordinates=test_coordinates, start=start, end=end)
assert len(coords_data_result) == 2
assert_series_equal(coords_data_result[0], bond_expected_series)
assert_series_equal(coords_data_result[1], swap_expected_series)
GsSession.current._post.reset_mock()
str_coords_data_result = GsDataApi.coordinates_data_series(coordinates=test_str_coordinates, start=start, end=end)
assert len(str_coords_data_result) == 2
assert_series_equal(str_coords_data_result[0], bond_expected_series)
assert_series_equal(str_coords_data_result[1], swap_expected_series)
GsSession.current._post.assert_called_with('/data/coordinates/query',
payload=MDAPIDataQuery(market_data_coordinates=test_coordinates,
start_time=start,
end_time=end,
vendor=MarketDataVendor.Goldman_Sachs,
format="MessagePack"),
request_headers={'Accept': 'application/msgpack'}
)
def test_currency_to_inflation_benchmark_rate(mocker):
mocker.patch.object(GsSession.__class__,
'current',
return_value=GsSession.get(Environment.QA, 'client_id',
'secret'))
mocker.patch.object(GsSession.current, '_get', side_effect=mock_request)
mocker.patch.object(GsAssetApi,
'map_identifiers',
side_effect=map_identifiers_inflation_mocker)
asset_id_list = [
"MA66CZBQJST05XKG", "MAK1FHKH5P5GJSHH", "MA4J1YB8XZP2BPT8"
]
correct_mapping = [
"MAQ7ND0MBP2AVVQW", "MAK1FHKH5P5GJSHH", "MA4J1YB8XZP2BPT8"
]
with tm.PricingContext(dt.date.today()):
for i in range(len(asset_id_list)):
correct_id = tm.currency_to_inflation_benchmark_rate(
asset_id_list[i])
assert correct_id == correct_mapping[i]
def test_currency_to_tdapi_inflation_swap_rate_asset(mocker):
replace = Replacer()
mocker.patch.object(GsSession.__class__,
'current',
return_value=GsSession.get(Environment.QA, 'client_id',
'secret'))
mocker.patch.object(GsSession.current, '_get', side_effect=mock_request)
mocker.patch.object(SecurityMaster, 'get_asset', side_effect=mock_request)
bbid_mock = replace(
'gs_quant.timeseries.measures_inflation.Asset.get_identifier', Mock())
with tm_rates.PricingContext(dt.date.today()):
cur = [{
"currency_assetId": "MAK1FHKH5P5GJSHH",
"currency": "JPY",
"inflation_id": "MA1CENMCA88VXJ28"
}, {
"currency_assetId": "MA66CZBQJST05XKG",
"currency": "GBP",
"inflation_id": "MAW75DV9777630QN"
}, {
"currency_assetId": "MAJNQPFGN1EBDHAE",
"currency": "EUR",
"inflation_id": "MAJTD8XDA8EJZYRG"
}, {
"currency_assetId": "MAZ7RWC904JYHYPS",
"currency": "USD",
"inflation_id": "MA4016GCT3MDRYVY"
}]
for c in cur:
print(c)
asset = Currency(c.get("currency_assetId"), c.get("currency"))
bbid_mock.return_value = c.get("currency")
mqid = _currency_to_tdapi_inflation_swap_rate_asset(asset)
assert mqid == c.get("inflation_id")
bbid_mock.return_value = None
assert _currency_to_tdapi_inflation_swap_rate_asset(asset) == c.get(
"currency_assetId")
replace.restore()
def test_currencypair_to_tdapi_fxo_asset(mocker):
replace = Replacer()
mocker.patch.object(GsSession.__class__,
'current',
return_value=GsSession.get(Environment.QA, 'client_id',
'secret'))
mocker.patch.object(GsSession.current, '_get', side_effect=mock_request)
mocker.patch.object(SecurityMaster, 'get_asset', side_effect=mock_request)
bbid_mock = replace(
'gs_quant.timeseries.measures_fx_vol.Asset.get_identifier', Mock())
with tm_rates.PricingContext(dt.date.today()):
cur = [
{
"currency_assetId": "MAK1FHKH5P5GJSHH",
"currency": "USDJPY",
"id": "MAW3BZY6KFQ6TP95"
},
{
"currency_assetId": "MA66CZBQJST05XKG",
"currency": "GBPUSD",
"id": "MA7F5P92330NGKAR"
},
{
"currency_assetId": "MAJNQPFGN1EBDHAE",
"currency": "EURUSD",
"id": "MASN9J5N0H418Y6A"
},
]
for c in cur:
print(c)
asset = Currency(c.get("currency_assetId"), c.get("currency"))
bbid_mock.return_value = c.get("currency")
mqid = _currencypair_to_tdapi_fxo_asset(asset)
assert mqid == c.get("id")
bbid_mock.return_value = None
assert _currencypair_to_tdapi_fxo_asset(asset) == c.get(
"currency_assetId")
replace.restore()
def test_get_coverage_api(mocker):
test_coverage_data_1 = {
'results': [{
'gsid': 'gsid1'
}],
'scrollId': 'fake-scroll-id-1',
'totalResults': 1
}
test_coverage_data_2 = {
'results': [],
'scrollId': 'fake-scroll-id-2',
'totalResults': 1
}
mocker.patch.object(ContextMeta,
'current',
return_value=GsSession(Environment.QA))
mock = mocker.patch.object(ContextMeta.current, '_get')
mock.side_effect = [test_coverage_data_1, test_coverage_data_2]
data = GsDataApi.get_coverage('MA_RANK')
assert [{'gsid': 'gsid1'}] == data
def test_coordinates_data(mocker):
start = dt.datetime(2019, 1, 2, 1, 0)
end = dt.datetime(2019, 1, 2, 1, 10)
# mock GsSession and data response
mocker.patch.object(GsSession.__class__, 'default_value',
return_value=GsSession.get(Environment.QA, 'client_id', 'secret'))
mocker.patch.object(GsSession.current, '_post', side_effect=[{'responses': [{'data': bond_data}]},
{'responses': [{'data': swap_data}]},
{'responses': [{'data': bond_data},
{'data': swap_data}]},
{'responses': [{'data': bond_data},
{'data': swap_data}]}
])
coord_data_result = GsDataApi.coordinates_data(coordinates=test_coordinates[0], start=start, end=end)
assert_frame_equal(coord_data_result, bond_expected_frame)
str_coord_data_result = GsDataApi.coordinates_data(coordinates=test_str_coordinates[1], start=start, end=end)
assert_frame_equal(str_coord_data_result, swap_expected_frame)
coords_data_result = GsDataApi.coordinates_data(coordinates=test_coordinates, start=start, end=end,
as_multiple_dataframes=True)
assert len(coords_data_result) == 2
assert_frame_equal(coords_data_result[0], bond_expected_frame)
assert_frame_equal(coords_data_result[1], swap_expected_frame)
GsSession.current._post.reset_mock()
str_coords_data_result = GsDataApi.coordinates_data(coordinates=test_str_coordinates, start=start, end=end,
as_multiple_dataframes=True)
assert len(str_coords_data_result) == 2
assert_frame_equal(str_coords_data_result[0], bond_expected_frame)
assert_frame_equal(str_coords_data_result[1], swap_expected_frame)
GsSession.current._post.assert_called_once_with('/data/coordinates/query',
payload=MDAPIDataQuery(market_data_coordinates=test_coordinates,
start_time=start,
end_time=end,
vendor=MarketDataVendor.Goldman_Sachs,
format="MessagePack")
)
def get_instruments_by_position_type(
cls, positions_type: str,
positions_id: str) -> Tuple[Instrument, ...]:
root = 'deals' if positions_type == 'ETI' else 'books/' + positions_type
url = '/risk-internal/{}/{}/positions'.format(root, positions_id)
with GsSession.get(Environment.QA) as session:
# TODO Remove this once in prod
results = session._get(url)
instruments = []
for position in results.get('positionSets', ({
'positions': ()
}, ))[0]['positions']:
instrument_values = position['instrument']
instrument = Instrument.from_dict(instrument_values)
name = instrument_values.get('name')
if name:
instrument.name = name
instruments.append(instrument)
return tuple(instruments)
def test_currency_to_tdapi_xccy_swap_rate_asset(mocker):
replace = Replacer()
mocker.patch.object(GsSession.__class__, 'current',
return_value=GsSession.get(Environment.QA, 'client_id', 'secret'))
mocker.patch.object(GsSession.current, '_get', side_effect=mock_request)
mocker.patch.object(SecurityMaster, 'get_asset', side_effect=mock_request)
bbid_mock = replace('gs_quant.timeseries.measures_xccy.Asset.get_identifier', Mock())
with tm_rates.PricingContext(dt.date.today()):
cur = [
{
"currency_assetId": "MAK1FHKH5P5GJSHH",
"currency": "JPY",
"xccy_id": "MAFMW4HJC5TDE51H"
},
{
"currency_assetId": "MA66CZBQJST05XKG",
"currency": "GBP",
"xccy_id": "MATDD783JM1C2GGD"
},
{
"currency_assetId": "MAJNQPFGN1EBDHAE",
"currency": "EUR",
"xccy_id": "MAW8SAXPSKYA94E2"
},
]
for c in cur:
print(c)
asset = Currency(c.get("currency_assetId"), c.get("currency"))
bbid_mock.return_value = c.get("currency")
mqid = _currency_to_tdapi_crosscurrency_swap_rate_asset(asset)
assert mqid == c.get("xccy_id")
bbid_mock.return_value = None
assert _currency_to_tdapi_crosscurrency_swap_rate_asset(asset) == c.get("currency_assetId")
replace.restore()
def set_session():
from gs_quant.session import OAuth2Session
OAuth2Session.init = mock.MagicMock(return_value=None)
GsSession.use(Environment.PROD, 'client_id', 'secret')
"""
`Portfolio` supports the same methods as `Instrument` including `resolve()`, `calc()`, and `price()`
Resolving the portfolio resolves each individual instrument within the portfolio.
"""
from gs_quant.common import PayReceive, Currency # import constants
from gs_quant.instrument import IRSwaption # import instruments
from gs_quant.markets.portfolio import Portfolio
from gs_quant.session import Environment, GsSession # import sessions
client_id = None # Supply your application id
client_secret = None # Supply your client secret
scopes = ('run_analytics', )
GsSession.use(Environment.PROD, client_id, client_secret, scopes)
swaption1 = IRSwaption(PayReceive.Pay,
'5y',
Currency.EUR,
expiration_date='3m',
name='EUR-3m5y')
swaption2 = IRSwaption(PayReceive.Pay,
'5y',
Currency.EUR,
expiration_date='6m',
name='EUR-6m5y')
portfolio = Portfolio((swaption1, swaption2))
portfolio.resolve()
print(portfolio.as_dict())
""" BROKEN """
import datetime
from credentials.config import GSConfig
from gs_quant.data import Dataset
from gs_quant.session import GsSession, Environment
GsSession.use(Environment.PROD, GSConfig.client_id, GSConfig.client_secret, ('read_product_data',))
ds = Dataset('COVID19_COUNTRY_DAILY_CDC')
data = ds.get_data(start=datetime.date(2020, 1, 21), countryId="US")
print(data.head()) # peek at first few rows of data
import datetime
from gs_quant.data import Dataset
from gs_quant.session import GsSession, Environment
GsSession.use(
Environment.PROD, '77d7c80dec0b44e9868dfaa3a7e2cb36',
'4edbc70b2249de3ddc9f303bb373575cb06839fb6857570648fdb772ccf8e377',
('read_product_data', ))
ds = Dataset('COVID19_COUNTRY_DAILY_WIKI')
# data = ds.get_data()
# print(data) # peek at first few rows of data
data = ds.get_data(start=datetime.date(2019, 1, 20),
countryId=["US", "GB", "BR", "NZ", "IN"])
print(data)
# data.reset_index(inplace=True)
# data.to_json(r'wiki.json')
def test_coordinates_data(mocker):
bond_data = [{
'mktType': 'Prime',
'mktAsset': '335320934',
'mktQuotingStyle': 'price',
'price': 1.0139,
'time': pd.to_datetime('2019-01-20T01:03:00Z')
}, {
'mktType': 'Prime',
'mktAsset': '335320934',
'mktQuotingStyle': 'price',
'price': 1.0141,
'time': pd.to_datetime('2019-01-20T01:08:00Z')
}]
swap_data = [{
'mktType': 'IR',
'mktAsset': 'USD',
'mktClass': 'Swap',
'mktPoint': ('2Y', ),
'mktQuotingStyle': 'ATMRate',
'ATMRate': 0.02592,
'time': pd.to_datetime('2019-01-20T01:09:45Z')
}]
bond_expected_result = pd.DataFrame(
data={
'time': [
pd.to_datetime('2019-01-20T01:03:00Z'),
pd.to_datetime('2019-01-20T01:08:00Z')
],
'mktType': ['Prime', 'Prime'],
'mktAsset': ['335320934', '335320934'],
'mktQuotingStyle': ['price', 'price'],
'value': [1.0139, 1.0141]
},
index=pd.DatetimeIndex(['2019-01-20T01:03:00', '2019-01-20T01:08:00']),
)
swap_expected_result = pd.DataFrame(
data={
'time': [pd.to_datetime('2019-01-20T01:09:45Z')],
'mktType': ['IR'],
'mktAsset': ['USD'],
'mktClass': ['Swap'],
'mktPoint': [('2Y', )],
'mktQuotingStyle': ['ATMRate'],
'value': [0.02592]
},
index=pd.DatetimeIndex(['2019-01-20T01:09:45']),
)
# mock GsSession
mocker.patch.object(GsSession.__class__,
'current',
return_value=GsSession.get(Environment.QA, 'client_id',
'secret'))
mocker.patch.object(GsSession.current,
'_post',
side_effect=[{
'responses': [{
'data': bond_data
}]
}, {
'responses': [{
'data': swap_data
}]
}, {
'responses': [{
'data': bond_data
}, {
'data': swap_data
}]
}, {
'responses': [{
'data': bond_data
}, {
'data': swap_data
}]
}])
coord_data_result = GsDataApi.coordinates_data(
coordinates=test_coordinates[0],
start=dt.datetime(2019, 1, 2, 1, 0),
end=dt.datetime(2019, 1, 2, 1, 10))
assert_frame_equal(coord_data_result, bond_expected_result)
str_coord_data_result = GsDataApi.coordinates_data(
coordinates=test_str_coordinates[1],
start=dt.datetime(2019, 1, 2, 1, 0),
end=dt.datetime(2019, 1, 2, 1, 10))
assert_frame_equal(str_coord_data_result, swap_expected_result)
coords_data_result = GsDataApi.coordinates_data(
coordinates=test_coordinates,
start=dt.datetime(2019, 1, 2, 1, 0),
end=dt.datetime(2019, 1, 2, 1, 10),
as_multiple_dataframes=True)
assert len(coords_data_result) == 2
assert_frame_equal(coords_data_result[0], bond_expected_result)
assert_frame_equal(coords_data_result[1], swap_expected_result)
str_coords_data_result = GsDataApi.coordinates_data(
coordinates=test_str_coordinates,
start=dt.datetime(2019, 1, 2, 1, 0),
end=dt.datetime(2019, 1, 2, 1, 10),
as_multiple_dataframes=True)
assert len(str_coords_data_result) == 2
assert_frame_equal(str_coords_data_result[0], bond_expected_result)
assert_frame_equal(str_coords_data_result[1], swap_expected_result)
GsSession.current._post.assert_called_with('/data/coordinates/query',
payload=mocker.ANY)
assert GsSession.current._post.call_count == 4
def mock_session(mocker):
""" Mock GsSession helper """
mocker.return_value = GsSession.get(Environment.QA, 'client_id', 'secret')
# test API connectivity
request_url = 'https://api.marquee.gs.com/v1/users/self'
request = session.get(url=request_url)
print(request.text)
'''
from datetime import date
from gs_quant.data import Dataset
from gs_quant.markets.securities import SecurityMaster, AssetIdentifier
from gs_quant.session import GsSession
client_id = ''
client_secret = ''
scopes = GsSession.Scopes.get_default()
GsSession.use(client_id=client_id, client_secret=client_secret, scopes=scopes)
ds = Dataset('USCANFPP_MINI')
print (ds)
gsids = ds.get_coverage()['gsid'].values.tolist()
df = ds.get_data(date(2012, 7, 2), date(2017, 6, 30), gsid=gsids[0:5])
print (df)
for idx, row in df.iterrows():
marqueeAssetId = row['assetId']
asset = SecurityMaster.get_asset(marqueeAssetId, AssetIdentifier.MARQUEE_ID)
df.loc[df['assetId'] == marqueeAssetId, 'assetName'] = asset.name
print (df)
from gs_quant.data import Dataset
from gs_quant.timeseries import percentiles, volatility, last_value
from gs_quant.datetime import business_day_offset
import seaborn as sns
import pandas as pd
import matplotlib.pyplot as plt
import warnings
from datetime import date
import streamlit as st
from gs_quant.session import GsSession
warnings.filterwarnings('ignore')
sns.set(style="darkgrid", color_codes=True)
# external users should substitute their client id and secret; please skip this step if using internal jupyterhub
GsSession.use(client_id=None, client_secret=None, scopes=('run_analytics', ))
def format_df(data_dict):
df = pd.concat(data_dict, axis=1)
df.columns = data_dict.keys()
return df.fillna(method='ffill').dropna()
def volatility_screen(crosses, start_date, end_date, tenor='3m', plot=True):
fxspot_dataset, fxvol_dataset = Dataset('FXSPOT'), Dataset('FXIMPLIEDVOL')
spot_data, impvol_data, spot_fx, data = {}, {}, {}, {}
for cross in crosses:
spot = fxspot_dataset.get_data(start_date, end_date, bbid=cross)[[
'spot'
]].drop_duplicates(keep='last')
#!/usr/bin/env python
# coding: utf-8
# In[5]:
from gs_quant.session import GsSession, Environment
import numpy as np
import matplotlib.pyplot as plt
import pandas as pd
GsSession.use(client_id="id", client_secret="secret")
# In[6]:
from gs_quant.data import Dataset
import datetime
def get_datasets(datasets):
ds_dict = {}
for dataset in datasets:
try:
df = Dataset(dataset).get_data(datetime.date(2020, 6, 24), datetime.datetime.today().date())
keys = [x for x in ['countryId', 'subdivisionId'] if x in df.columns] + ['date']
val_map = {'newConfirmed': 'totalConfirmed', 'newFatalities': 'totalFatalities'}
vals = [x for x in list(val_map.keys()) if x in df.columns]
df_t = df.groupby(keys).sum().groupby(level=0).cumsum().reset_index()[keys + vals].rename(columns=val_map)
def test_get_dataset_fields(mocker):
mock_response = {
"totalResults": 2,
"results": [
{
"id": "FIVCFB4GAWBT61GT",
"name": "strikeReference",
"description": "Reference for strike level (enum: spot, forward).",
"type": "string",
"unique": False,
"fieldJavaType": "StringField",
"parameters": {
"enum": [
"spot",
"forward",
"normalized",
"delta"
]
},
"entitlements": {
"view": [
"internal",
"role:DataServiceAdmin",
"external",
"guid:8b4e2021fd12429885b30f6074037087"
],
"edit": [
"role:DataServiceAdmin",
"guid:8b4e2021fd12429885b30f6074037087"
],
"admin": [
"role:DataServiceAdmin"
]
},
"metadata": {
"createdById": "8b4e2021fd12429885b30f6074037087",
"createdTime": "2021-04-16T21:52:33.563Z",
"lastUpdatedById": "8b4e2021fd12429885b30f6074037087",
"lastUpdatedTime": "2021-04-16T21:52:33.563Z"
}
},
{
"id": "FI4YBC6DS3PRE7W9",
"name": "price",
"description": "Price of instrument.",
"type": "number",
"unique": False,
"fieldJavaType": "DoubleField",
"parameters": {},
"entitlements": {
"view": [
"internal",
"role:DataServiceAdmin",
"external"
],
"edit": [
"role:DataServiceAdmin"
],
"admin": [
"role:DataServiceAdmin"
]
},
"metadata": {
"createdById": "8b4e2021fd12429885b30f6074037087",
"createdTime": "2021-04-16T21:36:11.269Z",
"lastUpdatedById": "8b4e2021fd12429885b30f6074037087",
"lastUpdatedTime": "2021-04-16T22:09:03.697Z"
}
}
]
}
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)
response = GsDataApi.get_dataset_fields(ids=['FIVCFB4GAWBT61GT', 'FI4YBC6DS3PRE7W9'])
assert len(response) == 2
assert response == mock_response['results']
GsSession.current._post.assert_called_once_with('/data/fields/query',
payload={'where': {'id': ['FIVCFB4GAWBT61GT', 'FI4YBC6DS3PRE7W9']},
'limit': 10},
cls=DataSetFieldEntity)