def test_var_swap_tenors():
session = GsSession.get(Environment.DEV, token='faux')
replace = Replacer()
get_mock = replace('gs_quant.session.GsSession._get', Mock())
get_mock.return_value = {
'data': [{
'dataField':
'varSwap',
'filteredFields': [{
'field': 'tenor',
'values': ['abc', 'xyc']
}]
}]
}
with session:
actual = tm._var_swap_tenors(Index('MAXXX', AssetClass.Equity, 'XXX'))
assert actual == ['abc', 'xyc']
get_mock.return_value = {'data': []}
with pytest.raises(MqError):
with session:
tm._var_swap_tenors(Index('MAXXX', AssetClass.Equity, 'XXX'))
replace.restore()
def _fwd_term_typical():
assert DataContext.current_is_set
data = {'tenor': ['1w', '2w', '1y', '2y'], 'forward': [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
actual = tm.fwd_term(Index('MA123', AssetClass.Equity, '123'))
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='forward', 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()
replace.restore()
return actual
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 _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_skew():
replace = Replacer()
mock_spx = Index('MA890', AssetClass.Equity, 'SPX')
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', mock_eq)
actual = tm.skew(mock_spx, '1m', tm.SkewReference.DELTA, 25)
assert_series_equal(pd.Series([2.0], index=_index, name='impliedVolatility'), actual)
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', mock_eq_norm)
actual = tm.skew(mock_spx, '1m', tm.SkewReference.NORMALIZED, 4)
assert_series_equal(pd.Series([2.0], index=_index, name='impliedVolatility'), actual)
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', mock_eq_spot)
actual = tm.skew(mock_spx, '1m', tm.SkewReference.SPOT, 25)
assert_series_equal(pd.Series([2.0], index=_index, name='impliedVolatility'), actual)
mock = replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', Mock())
mock.return_value = pd.DataFrame()
assert tm.skew(mock_spx, '1m', tm.SkewReference.SPOT, 25).empty
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', mock_inc)
with pytest.raises(MqError):
tm.skew(mock_spx, '1m', tm.SkewReference.DELTA, 25)
replace.restore()
with pytest.raises(MqError):
tm.skew(mock_spx, '1m', None, 25)
with pytest.raises(MqError):
tm.skew(mock_spx, '1m', tm.SkewReference.SPOT, 25, real_time=True)
def test_var_swap_fwd():
# bad input
with pytest.raises(MqError):
tm.var_swap(Index('MA123', AssetClass.Equity, '123'), '1m', 500)
# regular
idx = pd.date_range(start="2019-01-01", periods=4, freq="D")
d1 = {
'varSwap': [1, 2, 3, 4],
'tenor': ['1y'] * 4
}
d2 = {
'varSwap': [1.5, 2.5, 3.5, 4.5],
'tenor': ['13m'] * 4
}
df1 = pd.DataFrame(data=d1, index=idx)
df2 = pd.DataFrame(data=d2, index=idx)
out = pd.concat([df1, df2])
replace = Replacer()
market_mock = replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', Mock())
market_mock.return_value = out
tenors_mock = replace('gs_quant.timeseries.measures._var_swap_tenors', Mock())
tenors_mock.return_value = ['1m', '1y', '13m']
expected = pd.Series([7.5, 8.5, 9.5, 10.5], name='varSwap', index=idx)
actual = tm.var_swap(Index('MA123', AssetClass.Equity, '123'), '1m', '1y')
assert_series_equal(expected, actual)
market_mock.assert_called_once()
# no data
market_mock.return_value = pd.DataFrame()
assert tm.var_swap(Index('MA123', AssetClass.Equity, '123'), '1m', '1y').empty
# no data for a tenor
market_mock.return_value = pd.DataFrame(data=d1, index=idx)
assert tm.var_swap(Index('MA123', AssetClass.Equity, '123'), '1m', '1y').empty
# no such tenors
tenors_mock.return_value = []
assert tm.var_swap(Index('MA123', AssetClass.Equity, '123'), '1m', '1y').empty
# finish
replace.restore()
def _fwd_term_empty():
replace = Replacer()
market_mock = replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', Mock())
market_mock.return_value = pd.DataFrame()
actual = tm.fwd_term(Index('MAXYZ', AssetClass.Equity, 'XYZ'))
assert actual.empty
market_mock.assert_called_once()
replace.restore()
def test_var_swap():
idx = pd.date_range(start="2019-01-01", periods=4, freq="D")
data = {'varSwap': [1, 2, 3, 4]}
out = pd.DataFrame(data=data, index=idx)
replace = Replacer()
market_mock = replace(
'gs_quant.timeseries.measures.GsDataApi.get_market_data', Mock())
market_mock.return_value = out
expected = pd.Series([1, 2, 3, 4], name='varSwap', index=idx)
actual = tm.var_swap(Index('MA123', AssetClass.Equity, '123'), '1m')
assert_series_equal(expected, actual)
market_mock.assert_called_once()
market_mock.reset_mock()
market_mock.return_value = pd.DataFrame()
actual = tm.var_swap(Index('MA123', AssetClass.Equity, '123'), '1m')
assert actual.empty
replace.restore()
def test_avg_impl_var():
replace = Replacer()
mock_spx = Index('MA890', AssetClass.Equity, 'SPX')
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', mock_eq)
actual = tm.average_implied_variance(mock_spx, '1m', tm.EdrDataReference.DELTA_CALL, 25)
assert_series_equal(pd.Series([5, 1, 2], index=_index * 3, name='averageImpliedVariance'), actual)
actual = tm.average_implied_variance(mock_spx, '1m', tm.EdrDataReference.DELTA_PUT, 75)
assert_series_equal(pd.Series([5, 1, 2], index=_index * 3, name='averageImpliedVariance'), actual)
with pytest.raises(NotImplementedError):
tm.average_implied_variance(..., '1m', tm.EdrDataReference.DELTA_PUT, 75, real_time=True)
replace.restore()
def test_cds_implied_vol():
replace = Replacer()
mock_cds = Index('MA890', AssetClass.Equity, 'CDS')
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', mock_eq)
actual = tm.cds_implied_volatility(mock_cds, '1m', '5y', tm.CdsVolReference.DELTA_CALL, 10)
assert_series_equal(pd.Series([5, 1, 2], index=_index * 3, name='impliedVolatilityByDeltaStrike'), actual)
actual = tm.cds_implied_volatility(mock_cds, '1m', '5y', tm.CdsVolReference.FORWARD, 100)
assert_series_equal(pd.Series([5, 1, 2], index=_index * 3, name='impliedVolatilityByDeltaStrike'), actual)
with pytest.raises(NotImplementedError):
tm.cds_implied_volatility(..., '1m', '5y', tm.CdsVolReference.DELTA_PUT, 75, real_time=True)
replace.restore()
def test_vol():
replace = Replacer()
mock_spx = Index('MA890', AssetClass.Equity, 'SPX')
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', mock_eq)
actual = tm.implied_volatility(mock_spx, '1m', tm.VolReference.DELTA_CALL, 25)
assert_series_equal(pd.Series([5, 1, 2], index=_index * 3, name='impliedVolatility'), actual)
actual = tm.implied_volatility(mock_spx, '1m', tm.VolReference.DELTA_PUT, 75)
assert_series_equal(pd.Series([5, 1, 2], index=_index * 3, name='impliedVolatility'), actual)
with pytest.raises(NotImplementedError):
tm.implied_volatility(mock_spx, '1m', tm.VolReference.DELTA_NEUTRAL)
replace.restore()
def test_vol_smile():
replace = Replacer()
mock_spx = Index('MA890', AssetClass.Equity, 'SPX')
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', mock_eq)
actual = tm.vol_smile(mock_spx, '1m', tm.VolSmileReference.FORWARD, '5d')
assert_series_equal(pd.Series([5, 1, 2], index=[0.75, 0.25, 0.5]), actual)
actual = tm.vol_smile(mock_spx, '1m', tm.VolSmileReference.SPOT, '5d')
assert_series_equal(pd.Series([5, 1, 2], index=[0.75, 0.25, 0.5]), actual)
market_mock = replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', Mock())
market_mock.return_value = pd.DataFrame()
actual = tm.vol_smile(mock_spx, '1m', tm.VolSmileReference.SPOT, '1d')
assert actual.empty
market_mock.assert_called_once()
with pytest.raises(NotImplementedError):
tm.vol_smile(mock_spx, '1m', tm.VolSmileReference.SPOT, '1d', real_time=True)
replace.restore()
def test_bucketize_price():
target = {
'7x24': [27.323461],
'offpeak': [26.004816],
'peak': [27.982783],
'7x8': [26.004816],
'2x16h': [],
'monthly': [],
'CAISO 7x24': [26.518563]
}
replace = Replacer()
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data',
mock_commod)
mock_pjm = Index('MA001', AssetClass.Commod, 'PJM')
mock_caiso = Index('MA001', AssetClass.Commod, 'CAISO')
mock_miso = Index('MA001', AssetClass.Commod, 'MISO')
with DataContext(datetime.date(2019, 5, 1), datetime.date(2019, 5, 1)):
bbid_mock = replace(
'gs_quant.timeseries.measures.Asset.get_identifier', Mock())
bbid_mock.return_value = 'CAISO'
actual = tm.bucketize_price(mock_caiso,
'LMP',
'totalPrice',
bucket='7x24')
assert_series_equal(
pd.Series(target['CAISO 7x24'],
index=[datetime.date(2019, 5, 1)],
name='price'), actual)
bbid_mock.return_value = 'PJM'
actual = tm.bucketize_price(mock_pjm,
'LMP',
'totalPrice',
bucket='7x24')
assert_series_equal(
pd.Series(target['7x24'],
index=[datetime.date(2019, 5, 1)],
name='price'), actual)
actual = tm.bucketize_price(mock_pjm,
'LMP',
'totalPrice',
bucket='offpeak')
assert_series_equal(
pd.Series(target['offpeak'],
index=[datetime.date(2019, 5, 1)],
name='price'), actual)
actual = tm.bucketize_price(mock_pjm,
'LMP',
'totalPrice',
bucket='peak')
assert_series_equal(
pd.Series(target['peak'],
index=[datetime.date(2019, 5, 1)],
name='price'), actual)
actual = tm.bucketize_price(mock_pjm,
'LMP',
'totalPrice',
bucket='7x8')
assert_series_equal(
pd.Series(target['7x8'],
index=[datetime.date(2019, 5, 1)],
name='price'), actual)
actual = tm.bucketize_price(mock_pjm,
'LMP',
'totalPrice',
bucket='2x16h')
assert_series_equal(pd.Series(target['2x16h'], index=[], name='price'),
actual)
actual = tm.bucketize_price(mock_pjm,
'LMP',
'totalPrice',
granularity='m',
bucket='7X24')
assert_series_equal(
pd.Series(target['monthly'], index=[], name='price'), actual)
with pytest.raises(ValueError):
tm.bucketize_price(mock_pjm, 'LMP', 'totalPrice', bucket='weekday')
with pytest.raises(ValueError):
tm.bucketize_price(mock_pjm,
'LMP',
'totalPrice',
granularity='yearly')
replace.restore()
def test_fundamental_metrics():
replace = Replacer()
mock_spx = Index('MA890', AssetClass.Equity, 'SPX')
replace('gs_quant.timeseries.measures.GsDataApi.get_market_data', mock_eq)
period = tm.FundamentalMetricPeriod.ONE_YEAR
direction = tm.FundamentalMetricPeriodDirection.FORWARD
actual = tm.dividend_yield(mock_spx, period, direction)
assert_series_equal(pd.Series([5, 1, 2], index=_index * 3, name='fundamentalMetric'), actual)
with pytest.raises(NotImplementedError):
tm.dividend_yield(..., period, direction, real_time=True)
actual = tm.earnings_per_share(mock_spx, period, direction)
assert_series_equal(pd.Series([5, 1, 2], index=_index * 3, name='fundamentalMetric'), actual)
with pytest.raises(NotImplementedError):
tm.earnings_per_share(..., period, direction, real_time=True)
actual = tm.earnings_per_share_positive(mock_spx, period, direction)
assert_series_equal(pd.Series([5, 1, 2], index=_index * 3, name='fundamentalMetric'), actual)
with pytest.raises(NotImplementedError):
tm.earnings_per_share_positive(..., period, direction, real_time=True)
actual = tm.net_debt_to_ebitda(mock_spx, period, direction)
assert_series_equal(pd.Series([5, 1, 2], index=_index * 3, name='fundamentalMetric'), actual)
with pytest.raises(NotImplementedError):
tm.net_debt_to_ebitda(..., period, direction, real_time=True)
actual = tm.price_to_book(mock_spx, period, direction)
assert_series_equal(pd.Series([5, 1, 2], index=_index * 3, name='fundamentalMetric'), actual)
with pytest.raises(NotImplementedError):
tm.price_to_book(..., period, direction, real_time=True)
actual = tm.price_to_cash(mock_spx, period, direction)
assert_series_equal(pd.Series([5, 1, 2], index=_index * 3, name='fundamentalMetric'), actual)
with pytest.raises(NotImplementedError):
tm.price_to_cash(..., period, direction, real_time=True)
actual = tm.price_to_earnings(mock_spx, period, direction)
assert_series_equal(pd.Series([5, 1, 2], index=_index * 3, name='fundamentalMetric'), actual)
with pytest.raises(NotImplementedError):
tm.price_to_earnings(..., period, direction, real_time=True)
actual = tm.price_to_earnings_positive(mock_spx, period, direction)
assert_series_equal(pd.Series([5, 1, 2], index=_index * 3, name='fundamentalMetric'), actual)
with pytest.raises(NotImplementedError):
tm.price_to_earnings_positive(..., period, direction, real_time=True)
actual = tm.price_to_sales(mock_spx, period, direction)
assert_series_equal(pd.Series([5, 1, 2], index=_index * 3, name='fundamentalMetric'), actual)
with pytest.raises(NotImplementedError):
tm.price_to_sales(..., period, direction, real_time=True)
actual = tm.return_on_equity(mock_spx, period, direction)
assert_series_equal(pd.Series([5, 1, 2], index=_index * 3, name='fundamentalMetric'), actual)
with pytest.raises(NotImplementedError):
tm.return_on_equity(..., period, direction, real_time=True)
actual = tm.sales_per_share(mock_spx, period, direction)
assert_series_equal(pd.Series([5, 1, 2], index=_index * 3, name='fundamentalMetric'), actual)
with pytest.raises(NotImplementedError):
tm.sales_per_share(..., period, direction, real_time=True)
replace.restore()