def test_basket_price():
with pytest.raises(MqValueError):
Basket(['AAPL UW'], [0.1, 0.9], RebalFreq.MONTHLY)
dates = pd.DatetimeIndex([
date(2021, 1, 1),
date(2021, 1, 2),
date(2021, 1, 3),
date(2021, 1, 4),
date(2021, 1, 5),
date(2021, 1, 6)
])
dates_feb = pd.DatetimeIndex([
date(2021, 2, 1),
date(2021, 2, 2),
date(2021, 2, 3),
date(2021, 2, 4),
date(2021, 2, 5),
date(2021, 2, 6)
])
replace = Replacer()
mock_data = replace(
'gs_quant.timeseries.measures.GsDataApi.get_market_data', Mock())
mock_data.side_effect = [_mock_spot_data(), _mock_spot_data_feb()]
mock_asset = replace(
'gs_quant.timeseries.backtesting.GsAssetApi.get_many_assets_data',
Mock())
mock_asset.return_value = [{
'id': 'MA4B66MW5E27U9VBB94'
}, {
'id': 'MA4B66MW5E27UAL9SUX'
}]
a_basket = Basket(['AAPL UW', 'MSFT UW'], [0.1, 0.9], RebalFreq.MONTHLY)
expected = pd.Series(
[100.0, 100.1, 100.302, 100.09596, 100.09596, 100.297879], index=dates)
with DataContext('2021-01-01', '2021-01-06'):
actual = a_basket.price()
assert_series_equal(actual, expected)
expected = pd.Series([100.00, 101.50, 100.62, 98.30, 96.30, 94.80],
index=dates_feb)
with DataContext('2021-02-01', '2021-02-06'):
actual = a_basket.price()
assert_series_equal(actual, expected)
mock_asset = replace(
'gs_quant.timeseries.backtesting.GsAssetApi.get_many_assets_data',
Mock())
mock_asset.return_value = [{'id': 'MA4B66MW5E27U9VBB94'}]
with pytest.raises(MqValueError):
Basket(['AAPL UW', 'ABC'], [0.1, 0.9], RebalFreq.MONTHLY).price()
with pytest.raises(NotImplementedError):
a_basket.price(real_time=True)
replace.restore()
def test_calls_different(self):
m1 =Mock()
m2 =Mock()
m1.foo(1, 2, x=3, y=4)
m2.bar(1, 3, x=7, y=4)
self.check_raises(
m1.mock_calls,
m2.mock_calls,
"sequence not as expected:\n"
"\n"
"same:\n"
"[]\n"
"\n"
"first:\n"
"[call.foo(1, 2, x=3, y=4)]\n"
"\n"
"second:\n"
"[call.bar(1, 3, x=7, y=4)]"
"\n\n"
'While comparing [0]: \n'
"'call.foo(1, 2, x=3, y=4)'\n"
'!=\n'
"'call.bar(1, 3, x=7, y=4)'"
)
def test_normalized_performance_short():
idx = pd.date_range('2020-01-02', freq='D', periods=3)
replace = Replacer()
expected = {"Short": pd.Series(data=[1, 1 / 2, 1 / 3], index=idx,
name='normalizedPerformance', dtype='float64'),
"Long": pd.Series(data=[1, 2, 3], index=idx,
name='normalizedPerformance', dtype='float64'),
None: pd.Series(data=[1, (2 + 1 / 2) / 2, (3 + 1 / 3) / 2], index=idx,
name='normalizedPerformance', dtype='float64')}
mock = replace('gs_quant.api.gs.portfolios.GsPortfolioApi.get_reports', Mock())
mock.return_value = [
Report.from_dict({'id': 'RP1', 'positionSourceType': 'Portfolio', 'positionSourceId': 'MP1',
'type': 'Portfolio Performance Analytics',
'parameters': {'transactionCostModel': 'FIXED'}})]
# mock PerformanceReport.get_portfolio_constituents()
mock = replace('gs_quant.markets.report.PerformanceReport.get_portfolio_constituents', Mock())
mock.return_value = MarketDataResponseFrame(data=constituents_data_l_s, dtype="float64")
# mock PerformanceReport.get()
mock = replace('gs_quant.markets.report.PerformanceReport.get', Mock())
mock.return_value = PerformanceReport(report_id='RP1',
position_source_type='Portfolio',
position_source_id='MP1',
report_type='Portfolio Performance Analytics',
parameters=ReportParameters(transaction_cost_model='FIXED'))
for k, v in expected.items():
with DataContext(datetime.date(2020, 1, 1), datetime.date(2019, 1, 3)):
actual = mr.normalized_performance('MP1', k)
assert all((actual.values - v.values) < 0.01)
replace.restore()
def test_vol_swap_strike_matches_no_assets_when_expiry_tenor_is_not_none():
with pytest.raises(MqValueError):
replace = Replacer()
base = Cross('MA667', 'EURUSD')
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock())
xrefs.return_value = 'EURUSD'
mock_asset_1 = GsAsset(asset_class='FX',
id='MA123',
type_='VolatilitySwap',
name='Test_asset',
parameters={"lastFixingDate": "1y"})
mock_asset_2 = GsAsset(asset_class='FX',
id='MA123',
type_='VolatilitySwap',
name='Test_asset',
parameters={"lastFixingDate": "1y"})
assets = replace(
'gs_quant.timeseries.measures.GsAssetApi.get_many_assets', Mock())
assets.return_value = [mock_asset_1, mock_asset_2]
tm_fxo.vol_swap_strike(base,
"10m",
location=PricingLocation.LDN,
real_time=False)
def test_swaption_vol():
replace = Replacer()
mock_usd = Currency('MA890', 'USD')
xrefs = replace('gs_quant.timeseries.measures.GsAssetApi.get_asset_xrefs',
Mock())
xrefs.return_value = [
GsTemporalXRef(dt.date(2019, 1, 1), dt.date(2952, 12, 31),
XRef(bbid='USD', ))
]
identifiers = replace(
'gs_quant.timeseries.measures.GsAssetApi.map_identifiers', Mock())
identifiers.return_value = {'USD-LIBOR-BBA': 'MA123'}
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data',
mock_curr)
actual = tm.swaption_vol(mock_usd, '3m', '1y', 0)
assert_series_equal(
pd.Series([1, 2, 3], index=_index * 3, name='swaptionVol'), actual)
actual = tm.swaption_vol(mock_usd, '3m', '1y', 50)
assert_series_equal(
pd.Series([1, 2, 3], index=_index * 3, name='swaptionVol'), actual)
actual = tm.swaption_vol(mock_usd, '3m', '1y', -50)
assert_series_equal(
pd.Series([1, 2, 3], index=_index * 3, name='swaptionVol'), actual)
with pytest.raises(NotImplementedError):
tm.swaption_vol(..., '3m', '1y', 50, real_time=True)
replace.restore()
def test_thematic_beta():
replace = Replacer()
# mock getting PTA report
mock = replace('gs_quant.markets.report.ThematicReport.get', Mock())
mock.return_value = ThematicReport(id='report_id')
# mock getting thematic exposure
mock = replace('gs_quant.markets.report.ThematicReport.get_thematic_betas',
Mock())
mock.return_value = pd.DataFrame(thematic_data)
# mock getting asset
mock = Stock('MAA0NE9QX2ABETG6', 'Test Asset')
xrefs = replace('gs_quant.timeseries.measures.GsAssetApi.get_asset_xrefs',
Mock())
xrefs.return_value = [
GsTemporalXRef(datetime.date(2019, 1, 1), datetime.date(2952, 12, 31),
XRef(ticker='basket_ticker', ))
]
replace('gs_quant.markets.securities.SecurityMaster.get_asset',
Mock()).return_value = mock
with DataContext(datetime.date(2020, 7, 12), datetime.date(2020, 7, 15)):
actual = mr.thematic_beta('report_id', 'basket_ticker')
assert all(actual.values == [1, 1, 1, 1])
replace.restore()
def test_factor_volatility():
replace = Replacer()
# mock getting risk model factor entity
mock = replace('gs_quant.api.gs.risk_models.GsFactorRiskModelApi.get_risk_model_data', Mock())
mock.return_value = mock_risk_model_data
# mock getting risk model factor entity
mock = replace('gs_quant.api.gs.risk_models.GsFactorRiskModelApi.get_risk_model_factor_data', Mock())
mock.return_value = mock_risk_model_factor_data
# mock getting risk model entity()
mock = replace('gs_quant.api.gs.risk_models.GsRiskModelApi.get_risk_model', Mock())
mock.return_value = mock_risk_model_obj
# mock getting risk model dates
mock = replace('gs_quant.api.gs.risk_models.GsRiskModelApi.get_risk_model_dates', Mock())
mock.return_value = ['2020-01-01', '2020-01-02', '2020-01-03']
# mock getting covariances
mock = replace('gs_quant.markets.factor.Factor.variance', Mock())
mock.return_value = mock_covariance_curve
with DataContext(datetime.date(2020, 1, 1), datetime.date(2020, 1, 3)):
actual = mrm.factor_volatility(mock_risk_model(), 'Factor Name')
assert all(actual.values == [sqrt(1.01) * 100, sqrt(1.02) * 100, sqrt(1.03) * 100])
with pytest.raises(MqValueError):
mrm.covariance(mock_risk_model(), 'Wrong Factor Name', 'Factor Name')
replace.restore()
def _vol_term_typical(reference, value):
from gs_quant.target.common import FieldFilterMap
assert DataContext.current_is_set
data = {
'tenor': ['1w', '2w', '1y', '2y'],
'impliedVolatility': [1, 2, 3, 4]
}
out = pd.DataFrame(data=data, index=pd.DatetimeIndex(['2018-01-01'] * 4))
replace = Replacer()
market_mock = replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', Mock())
market_mock.return_value = out
ffm_mock = replace('gs_quant.timeseries.measures.FieldFilterMap', Mock(spec=FieldFilterMap))
actual = tm.vol_term(Index('MA123', AssetClass.Equity, '123'), reference, value)
idx = pd.DatetimeIndex(['2018-01-08', '2018-01-15', '2019-01-01', '2020-01-01'], name='expirationDate')
expected = pd.Series([1, 2, 3, 4], name='impliedVolatility', index=idx)
expected = expected.loc[DataContext.current.start_date: DataContext.current.end_date]
if expected.empty:
assert actual.empty
else:
assert_series_equal(expected, actual)
market_mock.assert_called_once()
ffm_mock.assert_called_once_with(relativeStrike=value if reference == tm.SkewReference.NORMALIZED else value / 100,
strikeReference=unittest.mock.ANY)
replace.restore()
return actual
def test_factor_correlation():
replace = Replacer()
# mock getting risk model factor entity
mock = replace(
'gs_quant.api.gs.risk_models.GsFactorRiskModelApi.get_risk_model_data',
Mock())
mock.return_value = mock_risk_model_data
# mock getting risk model factor entity
mock = replace(
'gs_quant.api.gs.risk_models.GsFactorRiskModelApi.get_risk_model_factor_data',
Mock())
mock.return_value = mock_risk_model_factor_data
# mock getting risk model entity()
mock = replace('gs_quant.api.gs.risk_models.GsRiskModelApi.get_risk_model',
Mock())
mock.return_value = mock_risk_model_obj
# mock getting risk model dates
mock = replace(
'gs_quant.api.gs.risk_models.GsRiskModelApi.get_risk_model_dates',
Mock())
mock.return_value = ['2020-01-01', '2020-01-02', '2020-01-03']
# mock getting covariances
mock = replace('gs_quant.markets.factor.Factor.covariance', Mock())
mock.return_value = mock_covariance_curve
with DataContext(datetime.date(2020, 1, 1), datetime.date(2020, 1, 3)):
actual = mrm.factor_correlation(mock_risk_model(), 'Factor Name',
'Factor Name')
assert all(actual.values == [1.0000000000000002, 1, 1])
replace.restore()
def _var_term_fwd():
idx = pd.date_range('2018-01-01', periods=2, freq='D')
def mock_var_swap(_asset, tenor, _forward_start_date, **_kwargs):
if tenor == '1m':
return pd.Series([1, 2], idx, name='varSwap')
if tenor == '2m':
return pd.Series([3, 4], idx, name='varSwap')
return pd.Series()
replace = Replacer()
market_mock = replace('gs_quant.timeseries.measures.var_swap', Mock())
market_mock.side_effect = mock_var_swap
tenors_mock = replace('gs_quant.timeseries.measures._var_swap_tenors',
Mock())
tenors_mock.return_value = ['1m', '2m', '3m']
actual = tm.var_term(Index('MA123', AssetClass.Equity, '123'),
forward_start_date='1m')
idx = pd.DatetimeIndex(['2018-02-02', '2018-03-02'], name='varSwap')
expected = pd.Series([2, 4], name='varSwap', index=idx)
expected = expected.loc[DataContext.current.start_date:DataContext.current.
end_date]
if expected.empty:
assert actual.empty
else:
assert_series_equal(expected, actual, check_names=False)
market_mock.assert_called()
replace.restore()
return actual
def test_basket_average_realized_vol():
replace = Replacer()
dates = pd.date_range(start='2021-01-01', periods=6)
mock_data = replace(
'gs_quant.timeseries.measures.GsDataApi.get_market_data', Mock())
mock_data.return_value = _mock_spot_data()
mock_asset = replace(
'gs_quant.timeseries.backtesting.GsAssetApi.get_many_assets_data',
Mock())
mock_asset.return_value = [{
'id': 'MA4B66MW5E27U9VBB94'
}, {
'id': 'MA4B66MW5E27UAL9SUX'
}]
a_basket = Basket(['AAPL UW', 'MSFT UW'], [0.1, 0.9], RebalFreq.DAILY)
expected = pd.Series(
[np.nan, np.nan, 1.122497, 4.489989, 2.244994, 2.244994], index=dates)
actual = a_basket.average_realized_volatility('2d')
assert_series_equal(actual, expected)
with pytest.raises(NotImplementedError):
a_basket.average_realized_volatility('2d', real_time=True)
replace.restore()
def test_cross_stored_direction_for_fx_vol():
replace = Replacer()
mock_gbp = Cross('MA26QSMPX9990G66', 'GBPUSD')
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock())
xrefs.return_value = 'GBPUSD'
assert "MAEHA6WVHJ2S3JY9" == tm_fxo.cross_stored_direction_for_fx_vol(
mock_gbp)
replace.restore()
mock_gbp_reversed = Cross('MA26QSMPX9990G67', 'USDGBP')
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock())
xrefs.side_effect = ['USDGBP', 'GBPUSD']
assets = replace('gs_quant.markets.securities.SecurityMaster.get_asset',
Mock())
assets.return_value = mock_gbp
assert "MAEHA6WVHJ2S3JY9" == tm_fxo.cross_stored_direction_for_fx_vol(
mock_gbp_reversed)
replace.restore()
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier',
Mock())
xrefs.side_effect = [mock_gbp, 'GBPUSD']
assets = replace('gs_quant.markets.securities.SecurityMaster.get_asset',
Mock())
assets.return_value = mock_gbp
assert "MAEHA6WVHJ2S3JY9" == tm_fxo.cross_stored_direction_for_fx_vol(
mock_gbp)
replace.restore()
def test_financial_conditions_index():
data = {
'pnl': [
101,
102,
103
],
'date': [
'2020-01-01',
'2020-01-02',
'2020-01-03'
]
}
idx = pd.date_range('2020-01-01', freq='D', periods=3)
df = MarketDataResponseFrame(data=data, index=idx)
df.dataset_ids = ('PNL',)
replace = Replacer()
# mock PerformanceReport.get_pnl()
mock = replace('gs_quant.markets.report.PerformanceReport.get_pnl', Mock())
mock.return_value = df
# mock GsPortfolioApi.get_reports()
mock = replace('gs_quant.api.gs.portfolios.GsPortfolioApi.get_reports', Mock())
mock.return_value = [Report.from_dict({'id': 'RP1', 'positionSourceType': 'Portfolio', 'positionSourceId': 'MP1',
'type': 'Portfolio Performance Analytics',
'parameters': {'transactionCostModel': 'FIXED'}})]
with DataContext(datetime.date(2020, 1, 1), datetime.date(2019, 1, 3)):
actual = mp.pnl('MP1')
assert actual.index.equals(idx)
assert all(actual.values == data['pnl'])
replace.restore()
def test_basket_average_realized_vol():
replace = Replacer()
dates = pd.DatetimeIndex([
date(2021, 1, 1),
date(2021, 1, 2),
date(2021, 1, 3),
date(2021, 1, 4),
date(2021, 1, 5),
date(2021, 1, 6)
])
dates_feb = pd.DatetimeIndex([
date(2021, 2, 1),
date(2021, 2, 2),
date(2021, 2, 3),
date(2021, 2, 4),
date(2021, 2, 5),
date(2021, 2, 6)
])
mock_data = replace(
'gs_quant.timeseries.measures.GsDataApi.get_market_data', Mock())
mock_data.side_effect = [_mock_spot_data(), _mock_spot_data_feb()]
mock_asset = replace(
'gs_quant.timeseries.backtesting.GsAssetApi.get_many_assets_data',
Mock())
mock_asset.return_value = [{
'id': 'MA4B66MW5E27U9VBB94'
}, {
'id': 'MA4B66MW5E27UAL9SUX'
}]
a_basket = Basket(['AAPL UW', 'MSFT UW'], [0.1, 0.9], RebalFreq.DAILY)
expected = pd.Series([np.nan, np.nan, 1.1225, 4.49, 2.245, 2.245],
index=dates)
with DataContext('2021-01-01', '2021-01-06'):
actual = a_basket.average_realized_volatility('2d')
assert_series_equal(actual, expected)
expected = pd.Series(
[np.nan, np.nan, np.nan, 3.304542, 3.174902, 3.174902], index=dates)
with DataContext('2021-01-01', '2021-01-06'):
actual = a_basket.average_realized_volatility('3d')
assert_series_equal(actual, expected)
mock_data.assert_called_once()
expected = pd.Series(
[np.nan, np.nan, np.nan, 34.698082, 19.719302, 18.860533],
index=dates_feb)
with DataContext('2021-02-01', '2021-02-06'):
actual = a_basket.average_realized_volatility('3d')
assert_series_equal(actual, expected)
with pytest.raises(NotImplementedError):
a_basket.average_realized_volatility('2d', real_time=True)
replace.restore()
def test_register_more_specific(self):
class_ = namedtuple('Test', 'x')
with ShouldAssert('compare class_'):
compare(class_(1), class_(2),
comparers={
tuple: Mock(return_value='compare tuple'),
class_: Mock(return_value='compare class_')
})
def test_get_tdapi_inflation_rates_assets(mocker):
mock_asset_1 = GsAsset(asset_class='Rate',
id='MA26QSMPX9990G66',
type_='InflationSwap',
name='Test_asset')
mock_asset_2 = GsAsset(asset_class='Rate',
id='MA44SBCHF192S6FR',
type_='InflationSwap',
name='Test_asset')
replace = Replacer()
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets',
Mock())
assets.return_value = [mock_asset_1]
assert 'MA26QSMPX9990G66' == tm._get_tdapi_inflation_rates_assets()
replace.restore()
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets',
Mock())
assets.return_value = [mock_asset_1, mock_asset_2]
kwargs = dict(asset_parameters_termination_date='5y',
asset_parameters_effective_date='0b')
with pytest.raises(MqValueError):
tm._get_tdapi_inflation_rates_assets(**kwargs)
replace.restore()
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets',
Mock())
assets.return_value = []
kwargs = dict(asset_parameters_clearing_house='NONE',
pricing_location='LDN')
with pytest.raises(MqValueError):
tm._get_tdapi_inflation_rates_assets(**kwargs)
replace.restore()
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets',
Mock())
assets.return_value = [mock_asset_1, mock_asset_2]
kwargs = dict()
assert ['MA26QSMPX9990G66', 'MA44SBCHF192S6FR'
] == tm._get_tdapi_inflation_rates_assets(**kwargs)
replace.restore()
# test case will test matching sofr maturity with libor leg and flipping legs to get right asset
kwargs = dict(type='InflationSwap',
asset_parameters_termination_date='5y',
asset_parameters_index=tm.InflationIndexType.UKRPI,
asset_parameters_clearing_house='None',
asset_parameters_effective_date='5y',
asset_parameters_notional_currency='GBP',
pricing_location='LDN')
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets',
Mock())
assets.return_value = [mock_asset_1]
assert 'MA26QSMPX9990G66' == tm._get_tdapi_inflation_rates_assets(**kwargs)
replace.restore()
def test_aggregate_factor_support():
replace = Replacer()
# mock getting risk model entity()
mock = replace('gs_quant.api.gs.risk_models.GsRiskModelApi.get_risk_model', Mock())
mock.return_value = risk_model
mock = replace('gs_quant.api.gs.reports.GsReportApi.get_report', Mock())
mock.return_value = factor_risk_report
# mock getting report factor data
mock = replace('gs_quant.api.gs.reports.GsReportApi.get_factor_risk_report_results', Mock())
mock.return_value = aggregate_factor_data
# mock getting risk model dates
mock = replace('gs_quant.api.gs.risk_models.GsRiskModelApi.get_risk_model_dates', Mock())
mock.return_value = ['2010-01-01']
# mock getting risk model factor category
mock = replace('gs_quant.api.gs.risk_models.GsFactorRiskModelApi.get_risk_model_data', Mock())
mock.return_value = {
'results': [{
'factorData': [{
'factorId': 'factor_id',
'factorCategory': 'Factor Name'
}]}
]}
# mock getting risk model factor entity
mock = replace('gs_quant.api.gs.risk_models.GsFactorRiskModelApi.get_risk_model_factor_data', Mock())
mock.return_value = [{
'identifier': 'factor_id',
'type': 'Factor',
'name': 'Factor Name',
'factorCategory': 'Factor Name'
}]
with DataContext(datetime.date(2020, 11, 23), datetime.date(2020, 11, 25)):
actual = mr.factor_proportion_of_risk('report_id', 'Factor')
assert all(actual.values == [1, 2, 3])
with DataContext(datetime.date(2020, 11, 23), datetime.date(2020, 11, 25)):
actual = mr.daily_risk('report_id', 'Factor')
assert all(actual.values == [1, 2, 3])
with DataContext(datetime.date(2020, 11, 23), datetime.date(2020, 11, 25)):
actual = mr.annual_risk('report_id', 'Factor')
assert all(actual.values == [1, 2, 3])
with pytest.raises(MqValueError):
mr.daily_risk('report_id', 'Factor Name')
with pytest.raises(MqValueError):
mr.annual_risk('report_id', 'Factor Name')
replace.restore()
def test_vol_swap_strike_matches_multiple_assets():
with pytest.raises(MqValueError):
replace = Replacer()
base = Cross('MA667', 'EURUSD')
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier', Mock())
xrefs.return_value = 'EURUSD'
mock_asset_1 = GsAsset(asset_class='FX', id='MA123', type_='VolatilitySwap', name='Test_asset')
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets', Mock())
assets.return_value = [mock_asset_1, mock_asset_1]
tm_fxo.vol_swap_strike(base, None, location=PricingLocation.LDN, real_time=False)
replace.restore()
def test_vol_swap_strike_matches_no_assets():
with pytest.raises(MqValueError):
replace = Replacer()
base = Cross('MA667', 'EURUSD')
xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier', Mock())
xrefs.return_value = 'EURUSD'
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets', Mock())
assets.return_value = []
tm_fxo.vol_swap_strike(base, None, location=PricingLocation.LDN, real_time=False)
replace .restore()
def test_normalized_performance_default_aum():
idx = pd.date_range('2020-01-02', freq='D', periods=3)
expected = pd.Series(data=[1, 1 / 0.8, 1 / 0.6],
index=idx,
name='normalizedPerformance',
dtype='float64')
with DataContext(datetime.date(2020, 1, 1), datetime.date(2019, 1, 3)):
df = MarketDataResponseFrame(data=ppa_data, dtype="float64")
replace = Replacer()
# mock GsPortfolioApi.get_reports()
mock = replace('gs_quant.api.gs.portfolios.GsPortfolioApi.get_reports',
Mock())
mock.return_value = [
Report.from_dict({
'id': 'RP1',
'positionSourceType': 'Portfolio',
'positionSourceId': 'MP1',
'type': 'Portfolio Performance Analytics',
'parameters': {
'transactionCostModel': 'FIXED'
}
})
]
# mock PerformanceReport.get_many_measures()
mock = replace(
'gs_quant.markets.report.PerformanceReport.get_many_measures',
Mock())
mock.return_value = df
# mock PerformanceReport.get_custom_aum()
mock = replace(
'gs_quant.api.gs.portfolios.GsPortfolioApi.get_custom_aum', Mock())
mock.return_value = aum
# mock PerformanceReport.get()
mock = replace('gs_quant.markets.report.PerformanceReport.get', Mock())
mock.return_value = PerformanceReport(
report_id='RP1',
position_source_type='Portfolio',
position_source_id='MP1',
report_type='Portfolio Performance Analytics',
parameters=ReportParameters(transaction_cost_model='FIXED'))
mock = replace(
'gs_quant.api.gs.portfolios.GsPortfolioApi.get_portfolio', Mock())
mock.return_value = Portfolio('USD', 'P1', id_='MP1')
actual = mr.normalized_performance('MP1', None)
assert all(actual.values == expected.values)
replace.restore()
def test_get_tdapi_crosscurrency_rates_assets(mocker):
mock_asset_1 = GsAsset(asset_class='Rate', id='MAW8SAXPSKYA94E2', type_='XccySwapMTM', name='Test_asset')
mock_asset_2 = GsAsset(asset_class='Rate', id='MATDD783JM1C2GGD', type_='XccySwapMTM', name='Test_asset')
replace = Replacer()
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets', Mock())
assets.return_value = [mock_asset_1]
assert 'MAW8SAXPSKYA94E2' == tm._get_tdapi_crosscurrency_rates_assets()
replace.restore()
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets', Mock())
assets.return_value = [mock_asset_1, mock_asset_2]
kwargs = dict(asset_parameters_termination_date='5y', asset_parameters_effective_date='0b')
with pytest.raises(MqValueError):
tm._get_tdapi_crosscurrency_rates_assets(**kwargs)
replace.restore()
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets', Mock())
assets.return_value = []
kwargs = dict(asset_parameters_clearing_house='NONE',
asset_parameters_payer_rate_option="EUR-EURIBOR-TELERATE",
asset_parameters_payer_currency='EUR',
asset_parameters_payer_designated_maturity='3m',
asset_parameters_receiver_rate_option="USD-LIBOR-BBA",
asset_parameters_receiver_currency='USD',
asset_parameters_receiver_designated_maturity='3m',
pricing_location='LDN')
with pytest.raises(MqValueError):
tm._get_tdapi_crosscurrency_rates_assets(**kwargs)
replace.restore()
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets', Mock())
assets.return_value = [mock_asset_1, mock_asset_2]
kwargs = dict()
assert ['MAW8SAXPSKYA94E2', 'MATDD783JM1C2GGD'] == tm._get_tdapi_crosscurrency_rates_assets(**kwargs)
replace.restore()
# test case will test matching sofr maturity with libor leg and flipping legs to get right asset
kwargs = dict(type='XccySwapMTM', asset_parameters_termination_date='5y',
asset_parameters_payer_rate_option="EUR-EURIBOR-TELERATE",
asset_parameters_payer_currency="EUR",
asset_parameters_payer_designated_maturity='3m',
asset_parameters_receiver_rate_option="USD-LIBOR-BBA",
asset_parameters_receiver_currency="USD",
asset_parameters_receiver_designated_maturity='3m',
asset_parameters_clearing_house='None', asset_parameters_effective_date='5y',
pricing_location='LDN')
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets', Mock())
assets.return_value = [mock_asset_1]
assert 'MAW8SAXPSKYA94E2' == tm._get_tdapi_crosscurrency_rates_assets(**kwargs)
replace.restore()
def test_basket_constructor():
with pytest.raises(MqValueError):
Basket(['AAPL UW'], [0.1, 0.9], RebalFreq.MONTHLY)
replace = Replacer()
dates = [
datetime.datetime(2021, 1, 1),
datetime.datetime(2021, 1, 2),
datetime.datetime(2021, 1, 3),
datetime.datetime(2021, 1, 4),
datetime.datetime(2021, 1, 5),
datetime.datetime(2021, 1, 6),
]
x = pd.DataFrame(
{'spot': [100.0, 101, 103.02, 100.9596, 100.9596, 102.978792]},
index=dates)
x['assetId'] = 'MA4B66MW5E27U9VBB94'
y = pd.DataFrame({'spot': [100.0, 100, 100, 100, 100, 100]}, index=dates)
y['assetId'] = 'MA4B66MW5E27UAL9SUX'
spot = x.append(y)
mock_data = replace(
'gs_quant.timeseries.measures.GsDataApi.get_market_data', Mock())
mock_data.return_value = spot
mock_asset = replace(
'gs_quant.timeseries.backtesting.GsAssetApi.get_many_assets_data',
Mock())
mock_asset.return_value = [{
'id': 'MA4B66MW5E27U9VBB94'
}, {
'id': 'MA4B66MW5E27UAL9SUX'
}]
a_basket = Basket(['AAPL UW', 'MSFT UW'], [0.1, 0.9], RebalFreq.MONTHLY)
expected = pd.Series(
[100.0, 100.1, 100.302, 100.09596, 100.09596, 100.297879], index=dates)
actual = a_basket.price()
assert_series_equal(actual, expected)
mock_asset = replace(
'gs_quant.timeseries.backtesting.GsAssetApi.get_many_assets_data',
Mock())
mock_asset.return_value = [{'id': 'MA4B66MW5E27U9VBB94'}]
with pytest.raises(MqValueError):
Basket(['AAPL UW', 'ABC'], [0.1, 0.9], RebalFreq.MONTHLY).price()
with pytest.raises(NotImplementedError):
a_basket.price(real_time=True)
replace.restore()
def test_basket_average_implied_vol():
replace = Replacer()
dates = pd.DatetimeIndex([
date(2021, 1, 1),
date(2021, 1, 2),
date(2021, 1, 3),
date(2021, 1, 4),
date(2021, 1, 5),
date(2021, 1, 6)
])
x = pd.DataFrame(
{'impliedVolatility': [30.0, 30.2, 29.8, 30.6, 30.1, 30.0]},
index=dates)
x['assetId'] = 'MA4B66MW5E27U9VBB94'
y = pd.DataFrame(
{'impliedVolatility': [20.0, 20.2, 20.3, 20.6, 21.1, 20.0]},
index=dates)
y['assetId'] = 'MA4B66MW5E27UAL9SUX'
implied_vol = x.append(y)
implied_vol.index.name = 'date'
mock_data = replace(
'gs_quant.timeseries.measures.GsDataApi.get_market_data', Mock())
mock_data.side_effect = [implied_vol, _mock_spot_data()]
mock_asset = replace(
'gs_quant.timeseries.backtesting.GsAssetApi.get_many_assets_data',
Mock())
mock_asset.return_value = [{
'id': 'MA4B66MW5E27U9VBB94',
'bbid': 'AAPL UW'
}, {
'id': 'MA4B66MW5E27UAL9SUX',
'bbid': 'MSFT UW'
}]
a_basket = Basket(['AAPL UW', 'MSFT UW'], [0.1, 0.9], RebalFreq.DAILY)
expected = pd.Series([21.0, 21.2, 21.25, 21.6, 22.0, 21.0], index=dates)
actual = a_basket.average_implied_volatility('6m',
EdrDataReference.DELTA_CALL,
50)
assert_series_equal(actual, expected)
with pytest.raises(NotImplementedError):
a_basket.average_implied_volatility('6m',
EdrDataReference.DELTA_CALL,
50,
real_time=True)
replace.restore()
def test_zc_inflation_swap_rate():
replace = Replacer()
mock_gbp = Currency('MA890', 'GBP')
xrefs = replace('gs_quant.timeseries.measures.GsAssetApi.get_asset_xrefs', Mock())
xrefs.return_value = [GsTemporalXRef(dt.date(2019, 1, 1), dt.date(2952, 12, 31), XRef(bbid='GBP', ))]
identifiers = replace('gs_quant.timeseries.measures.GsAssetApi.map_identifiers', Mock())
identifiers.return_value = {'CPI-UKRPI': 'MA123'}
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', mock_curr)
actual = tm.zc_inflation_swap_rate(mock_gbp, '1y')
assert_series_equal(pd.Series([1, 2, 3], index=_index * 3, name='inflationSwapRate'), actual)
with pytest.raises(NotImplementedError):
tm.zc_inflation_swap_rate(..., '1y', real_time=True)
replace.restore()
def test_basis():
replace = Replacer()
mock_jpyusd = Cross('MA890', 'USD/JPY')
xrefs = replace('gs_quant.timeseries.measures.GsAssetApi.get_asset_xrefs', Mock())
xrefs.return_value = [GsTemporalXRef(dt.date(2019, 1, 1), dt.date(2952, 12, 31), XRef(bbid='JPYUSD', ))]
identifiers = replace('gs_quant.timeseries.measures.GsAssetApi.map_identifiers', Mock())
identifiers.return_value = {'USD-3m/JPY-3m': 'MA123'}
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', mock_cross)
actual = tm.basis(mock_jpyusd, '1y')
assert_series_equal(pd.Series([1, 2, 3], index=_index * 3, name='basis'), actual)
with pytest.raises(NotImplementedError):
tm.basis(..., '1y', real_time=True)
replace.restore()
def test_normalized_performance_no_custom_aum():
with DataContext(datetime.date(2020, 1, 1), datetime.date(2019, 1, 3)):
df = MarketDataResponseFrame(data=ppa_data, dtype="float64")
replace = Replacer()
# mock GsPortfolioApi.get_reports()
mock = replace('gs_quant.api.gs.portfolios.GsPortfolioApi.get_reports',
Mock())
mock.return_value = [
Report.from_dict({
'id': 'RP1',
'positionSourceType': 'Portfolio',
'positionSourceId': 'MP1',
'type': 'Portfolio Performance Analytics',
'parameters': {
'transactionCostModel': 'FIXED'
}
})
]
# mock PerformanceReport.get_many_measures()
mock = replace(
'gs_quant.markets.report.PerformanceReport.get_many_measures',
Mock())
mock.return_value = df
# mock PerformanceReport.get_portfolio_constituents()
mock = replace(
'gs_quant.markets.report.PerformanceReport.get_portfolio_constituents',
Mock())
mock.return_value = MarketDataResponseFrame(data=constituents_data,
dtype="float64")
# mock PerformanceReport.get_custom_aum()
mock = replace(
'gs_quant.api.gs.portfolios.GsPortfolioApi.get_custom_aum', Mock())
mock.return_value = pd.DataFrame({})
# mock PerformanceReport.get()
mock = replace('gs_quant.markets.report.PerformanceReport.get', Mock())
mock.return_value = PerformanceReport(
report_id='RP1',
position_source_type='Portfolio',
position_source_id='MP1',
report_type='Portfolio Performance Analytics',
parameters=ReportParameters(transaction_cost_model='FIXED'))
with pytest.raises(MqError):
mr.normalized_performance('MP1', 'Custom AUM')
replace.restore()
def test_save_create():
group = TargetGroup.from_dict({
'name': 'fakeGroup',
'id': 'groupId',
'tags': []
})
replace = Replacer()
mock = replace('gs_quant.api.gs.groups.GsGroupsApi.create_group', Mock())
mock.return_value = group
mock = replace('gs_quant.entities.entitlements.Group._group_exists', Mock())
mock.return_value = False
g = Group(group_id='groupId', name='fakeGroup', tags=[])
assert g.save().name == 'fakeGroup'
replace.restore()
def test_covariance():
risk_model = RiskModel(coverage=CoverageType.Country, id_='model_id', name='Fake Risk Model',
term=Term.Long, universe_identifier=UniverseIdentifier.gsid, vendor='GS',
version=1.0)
covariances = [
{
'date': '2020-01-01',
'covariance': 1.01
},
{
'date': '2020-01-02',
'covariance': 1.02
},
{
'date': '2020-01-03',
'covariance': 1.03
},
]
replace = Replacer()
# mock getting risk model factor entity
mock = replace('gs_quant.api.gs.risk_models.GsRiskModelApi.get_risk_model_factor_data', Mock())
mock.return_value = [{
'identifier': 'factor_id',
'type': 'Factor',
'name': "Factor Name"
}]
# mock getting risk model entity()
mock = replace('gs_quant.api.gs.risk_models.GsRiskModelApi.get_risk_model', Mock())
mock.return_value = risk_model
# mock getting risk model dates
mock = replace('gs_quant.api.gs.risk_models.GsRiskModelApi.get_risk_model_dates', Mock())
mock.return_value = ['2020-01-01', '2020-01-02', '2020-01-03']
# mock getting covariances
mock = replace('gs_quant.markets.factor.Factor.get_covariance', Mock())
mock.return_value = covariances
with DataContext(datetime.date(2020, 1, 1), datetime.date(2020, 1, 3)):
actual = mrm.covariance(mock_risk_model(), 'Factor Name', 'Factor Name')
assert all(actual.values == [1.01, 1.02, 1.03])
with pytest.raises(MqValueError):
mrm.covariance(mock_risk_model(), 'Wrong Factor Name', 'Factor Name')
replace.restore()
def test_get_tdapi_fxo_assets():
mock_asset_1 = GsAsset(asset_class='FX', id='MAW8SAXPSKYA94E2', type_='Option', name='Test_asset')
mock_asset_2 = GsAsset(asset_class='FX', id='MATDD783JM1C2GGD', type_='Option', name='Test_asset')
replace = Replacer()
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets', Mock())
assets.return_value = [mock_asset_1]
assert 'MAW8SAXPSKYA94E2' == tm_fxo._get_tdapi_fxo_assets()
replace.restore()
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets', Mock())
assets.return_value = [mock_asset_1, mock_asset_2]
kwargs = dict(asset_parameters_expiration_date='5y', asset_parameters_call_currency='USD',
asset_parameters_put_currency='EUR')
with pytest.raises(MqValueError):
tm_fxo._get_tdapi_fxo_assets(**kwargs)
replace.restore()
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets', Mock())
assets.return_value = []
kwargs = dict(asset_parameters_expiration_date='5y', asset_parameters_call_currency='USD',
asset_parameters_put_currency='EUR')
with pytest.raises(MqValueError):
tm_fxo._get_tdapi_fxo_assets(**kwargs)
replace.restore()
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets', Mock())
assets.return_value = [mock_asset_1, mock_asset_2]
kwargs = dict()
assert ['MAW8SAXPSKYA94E2', 'MATDD783JM1C2GGD'] == tm._get_tdapi_crosscurrency_rates_assets(**kwargs)
replace.restore()
# test case will test matching sofr maturity with libor leg and flipping legs to get right asset
kwargs = dict(Asset_class='FX',
type='Option',
asset_parameters_call_currency='USD',
asset_parameters_put_currency='EUR',
asset_parameters_expiration_date='1m',
asset_parameters_expiration_time='NYC',
asset_parameters_option_type='Put',
asset_parameters_premium_payment_date='Fwd Settle',
asset_parameters_strike_price_relative='10d',
pricing_location='NYC')
assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets', Mock())
assets.return_value = [mock_asset_1]
assert 'MAW8SAXPSKYA94E2' == tm_fxo._get_tdapi_fxo_assets(**kwargs)
replace.restore()
def test_atexit(self):
# http://bugs.python.org/issue25532
from testfixtures.mock import call
m = Mock()
with Replacer() as r:
# make sure the marker is false, other tests will
# probably have set it
r.replace('testfixtures.TempDirectory.atexit_setup', False)
r.replace('atexit.register', m.register)
d = TempDirectory()
expected = [call.register(d.atexit)]
compare(expected, m.mock_calls)
with catch_warnings(record=True) as w:
d.atexit()
self.assertTrue(len(w), 1)
compare(str(w[0].message), ( # pragma: no branch
"TempDirectory instances not cleaned up by shutdown:\n" +
d.path
))
d.cleanup()
compare(set(), TempDirectory.instances)
# check re-running has no ill effects
d.atexit()
