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)