Gs Quant release 0.9.102

gs_quant/analytics/processors/__init__.py

@@ -19,7 +19,8 @@
  ReturnsProcessor, BetaProcessor, FXImpliedCorrProcessor
 from .special_processors import EntityProcessor, CoordinateProcessor
 from .statistics_processors import PercentilesProcessor, PercentileProcessor, StdMoveProcessor, \
- CovarianceProcessor, ZscoresProcessor, MeanProcessor, VarianceProcessor, SumProcessor, StdDevProcessor
+ CovarianceProcessor, ZscoresProcessor, MeanProcessor, VarianceProcessor, SumProcessor, StdDevProcessor, \
+ CompoundGrowthRate
 from .utility_processors import LastProcessor, AppendProcessor, AdditionProcessor, SubtractionProcessor, \
  MultiplicationProcessor, DivisionProcessor, MinProcessor, MaxProcessor, NthLastProcessor, OneDayProcessor
 from .scale_processors import ScaleProcessor, BarMarkerProcessor, SpotMarkerProcessor, ScaleShape

gs_quant/backtests/triggers.py

@@ -20,8 +20,10 @@
 from gs_quant.backtests.actions import Action, AddTradeAction, AddTradeActionInfo
 from gs_quant.backtests.backtest_objects import BackTest, PredefinedAssetBacktest
 from gs_quant.backtests.backtest_utils import make_list, CalcType
-from gs_quant.datetime.relative_date import RelativeDateSchedule
 from gs_quant.backtests.data_sources import *
+from gs_quant.datetime.relative_date import RelativeDateSchedule
+from gs_quant.risk.transform import Transformer
+from gs_quant.risk import RiskMeasure
 
 
 class TriggerDirection(Enum):
@@ -41,7 +43,8 @@ def __init__(self):
 
 
 class PeriodicTriggerRequirements(TriggerRequirements):
- def __init__(self, start_date=None, end_date=None, frequency=None, calendar=None):
+ def __init__(self, start_date: dt.date = None, end_date: dt.date = None, frequency: str = None,
+ calendar: str = None):
  super().__init__()
  self.start_date = start_date
  self.end_date = end_date
@@ -50,27 +53,29 @@ def __init__(self, start_date=None, end_date=None, frequency=None, calendar=None
 
 
 class IntradayTriggerRequirements(TriggerRequirements):
- def __init__(self, start_time, end_time, frequency):
+ def __init__(self, start_time: dt.datetime, end_time: dt.datetime, frequency: str):
  super().__init__()
  self.start_time = start_time
  self.end_time = end_time
  self.frequency = frequency
 
 
 class MktTriggerRequirements(TriggerRequirements):
- def __init__(self, data_source, trigger_level, direction):
+ def __init__(self, data_source: DataSource, trigger_level: float, direction: TriggerDirection):
  super().__init__()
  self.data_source = data_source
  self.trigger_level = trigger_level
  self.direction = direction
 
 
 class RiskTriggerRequirements(TriggerRequirements):
- def __init__(self, risk, trigger_level, direction):
+ def __init__(self, risk: RiskMeasure, trigger_level: float, direction: TriggerDirection,
+ risk_transformation: Optional[Transformer] = None):
  super().__init__()
  self.risk = risk
  self.trigger_level = trigger_level
  self.direction = direction
+ self.risk_transformation = risk_transformation
 
 
 class AggregateTriggerRequirements(TriggerRequirements):
@@ -258,7 +263,12 @@ def __init__(self,
  self._risks += [trigger_requirements.risk]
 
  def has_triggered(self, state: dt.date, backtest: BackTest = None) -> TriggerInfo:
- risk_value = backtest.results[state][self._trigger_requirements.risk].aggregate()
+ if self.trigger_requirements.risk_transformation is None:
+ risk_value = backtest.results[state][self._trigger_requirements.risk].aggregate()
+ else:
+ risk_value = backtest.results[state][self._trigger_requirements.risk].transform(
+ risk_transformation=self.trigger_requirements.risk_transformation).aggregate(
+ allow_mismatch_risk_keys=True)
  if self._trigger_requirements.direction == TriggerDirection.ABOVE:
  if risk_value > self._trigger_requirements.trigger_level:
  return TriggerInfo(True)

gs_quant/models/risk_model_utils.py

@@ -205,44 +205,28 @@ def batch_and_upload_partial_data(model_id: str, data: dict, max_asset_size: int
  date = data.get('date')
  _upload_factor_data_if_present(model_id, data, date)
  sleep(2)
- _repeat_try_catch_request(_batch_data_v2, model_id=model_id, data=data, max_asset_size=max_asset_size, date=date)
-
-
-def _batch_data_v2(model_id: str, data: dict, max_asset_size: int, date: Union[str, dt.date]):
- if data.get('assetData'):
- asset_data_list, target_size = _batch_input_data({'assetData': data.get('assetData')}, max_asset_size)
- for i in range(len(asset_data_list)):
- final_upload = True if i == len(asset_data_list) - 1 else False
+ for risk_model_data_type in ["assetData", "issuerSpecificCovariance", "factorPortfolios"]:
+ _repeat_try_catch_request(_batch_data_v2, model_id=model_id, data=data.get(risk_model_data_type),
+ data_type=risk_model_data_type, max_asset_size=max_asset_size, date=date)
+ sleep(2)
+
+
+def _batch_data_v2(model_id: str, data: dict, data_type: str, max_asset_size: int, date: Union[str, dt.date]):
+ if data:
+ if data_type in ["issuerSpecificCovariance", "factorPortfolios"]:
+ max_asset_size //= 2
+ data_list, _ = _batch_input_data({data_type: data}, max_asset_size)
+ for i in range(len(data_list)):
+ final_upload = True if i == len(data_list) - 1 else False
  try:
  res = GsFactorRiskModelApi.upload_risk_model_data(model_id=model_id,
- model_data={'assetData': asset_data_list[i],
- 'date': date},
+ model_data={data_type: data_list[i], 'date': date},
  partial_upload=True,
  final_upload=final_upload)
  logging.info(res)
  except (MqRequestError, Exception) as e:
  raise e
 
- if 'issuerSpecificCovariance' in data.keys() or 'factorPortfolios' in data.keys():
- for optional_input_key in ['issuerSpecificCovariance', 'factorPortfolios']:
- if data.get(optional_input_key):
- optional_data = data.get(optional_input_key)
- optional_data_list, target_size = _batch_input_data({optional_input_key: optional_data},
- max_asset_size // 2)
- logging.info(f'{optional_input_key} being uploaded for {date}...')
- for i in range(len(optional_data_list)):
- final_upload = True if i == len(optional_data_list) - 1 else False
- try:
- res = GsFactorRiskModelApi.upload_risk_model_data(model_id=model_id,
- model_data={
- optional_input_key: optional_data_list[i],
- 'date': date},
- partial_upload=True,
- final_upload=final_upload)
- logging.info(res)
- except (MqRequestError, Exception) as e:
- raise e
-
 
 def batch_and_upload_coverage_data(date: dt.date, gsid_list: list, model_id: str):
  update_time = dt.datetime.today().strftime("%Y-%m-%dT%H:%M:%SZ")

gs_quant/test/models/test_risk_model.py

@@ -18,12 +18,11 @@
 
 from gs_quant.models.risk_model import FactorRiskModel, MacroRiskModel, ReturnFormat, Unit
 from gs_quant.session import *
-from gs_quant.target.risk_models import RiskModel as Risk_Model, RiskModelCoverage, RiskModelTerm,\
+from gs_quant.target.risk_models import RiskModel as Risk_Model, RiskModelCoverage, RiskModelTerm, \
  RiskModelUniverseIdentifier, RiskModelType, RiskModelDataAssetsRequest as DataAssetsRequest, \
  RiskModelDataMeasure as Measure, RiskModelUniverseIdentifierRequest as UniverseIdentifier
 import datetime as dt
 
-
 empty_entitlements = {
  "execute": [],
  "edit": [],
@@ -677,5 +676,125 @@ def test_get_specific_return(mocker):
  assert response == specific_return_response
 
 
+def test_upload_risk_model_data(mocker):
+ model = mock_risk_model(mocker)
+ risk_model_data = {
+ 'date': '2023-04-14',
+ 'assetData': {
+ 'universe': ['2407966', '2046251', 'USD'],
+ 'specificRisk': [12.09, 45.12, 3.09],
+ 'factorExposure': [
+ {'1': 0.23, '2': 0.023},
+ {'1': 0.23},
+ {'3': 0.23, '2': 0.023}
+ ],
+ 'totalRisk': [0.12, 0.45, 1.2]
+ },
+ 'factorData': [
+ {
+ 'factorId': '1',
+ 'factorName': 'USD',
+ 'factorCategory': 'Currency',
+ 'factorCategoryId': 'CUR'
+ },
+ {
+ 'factorId': '2',
+ 'factorName': 'ST',
+ 'factorCategory': 'ST',
+ 'factorCategoryId': 'ST'
+ },
+ {
+ 'factorId': '3',
+ 'factorName': 'IND',
+ 'factorCategory': 'IND',
+ 'factorCategoryId': 'IND'
+ }
+ ],
+ 'covarianceMatrix': [[0.089, 0.0123, 0.345],
+ [0.0123, 3.45, 0.345],
+ [0.345, 0.345, 1.23]],
+ 'issuerSpecificCovariance': {
+ 'universeId1': ['2407966'],
+ 'universeId2': ['2046251'],
+ 'covariance': [0.03754]
+ },
+ 'factorPortfolios': {
+ 'universe': ['2407966', '2046251'],
+ 'portfolio': [{'factorId': 1, 'weights': [0.25, 0.75]},
+ {'factorId': 2, 'weights': [0.25, 0.75]},
+ {'factorId': 3, 'weights': [0.25, 0.75]}]
+ }
+ }
+
+ base_url = f"/risk/models/data/{model.id}?partialUpload=true"
+ date = risk_model_data.get("date")
+ max_asset_batch_size = 2
+
+ batched_asset_data = [
+ {"assetData": {key: value[i:i + max_asset_batch_size] for key, value in
+ risk_model_data.get("assetData").items()}, "date": date,
+ } for i in range(0, len(risk_model_data.get("assetData").get("universe")), max_asset_batch_size)
+ ]
+
+ max_asset_batch_size //= 2
+ batched_factor_portfolios = [
+ {"factorPortfolios":
+ {key: (value[i:i + max_asset_batch_size] if key in "universe" else
+ [{"factorId": factor_weights.get("factorId"),
+ "weights": factor_weights.get("weights")[i:i + max_asset_batch_size]} for factor_weights in value])
+ for key, value in risk_model_data.get("factorPortfolios").items()},
+ "date": date
+ } for i in range(0, len(risk_model_data.get("factorPortfolios").get("universe")), max_asset_batch_size)
+ ]
+
+ expected_factor_data_calls = [
+ mock.call(base_url, {"date": date, "factorData": risk_model_data.get("factorData"),
+ "covarianceMatrix": risk_model_data.get("covarianceMatrix")}, timeout=200)
+ ]
+
+ expected_asset_data_calls = []
+ for batch_num, batch_asset_payload in enumerate(batched_asset_data):
+ final_upload_flag = 'true' if batch_num == len(batched_asset_data) - 1 else 'false'
+ expected_asset_data_calls.append(
+ mock.call(f"{base_url}&finalUpload={final_upload_flag}", batch_asset_payload, timeout=200)
+ )
+
+ expected_factor_portfolios_data_calls = []
+ for batch_num, batched_fp_payload in enumerate(batched_factor_portfolios):
+ final_upload_flag = 'true' if batch_num == len(batched_factor_portfolios) - 1 else 'false'
+ expected_factor_portfolios_data_calls.append(
+ mock.call(f"{base_url}&finalUpload={final_upload_flag}", batched_fp_payload, timeout=200)
+ )
+
+ expected_isc_data_calls = [
+ mock.call(f"{base_url}&finalUpload=true",
+ {"issuerSpecificCovariance": risk_model_data.get("issuerSpecificCovariance"), "date": date},
+ timeout=200)
+ ]
+
+ expected_calls = expected_factor_data_calls + expected_asset_data_calls + \
+ expected_isc_data_calls + expected_factor_portfolios_data_calls
+
+ # mock GsSession
+ mocker.patch.object(
+ GsSession.__class__,
+ 'default_value',
+ return_value=GsSession.get(
+ Environment.QA,
+ 'client_id',
+ 'secret'))
+ mocker.patch.object(GsSession.current, '_post', return_value='Upload Successful')
+
+ max_asset_batch_size = 2
+ model.upload_data(risk_model_data, max_asset_batch_size=max_asset_batch_size)
+
+ call_args_list = GsSession.current._post.call_args_list
+
+ assert len(call_args_list) == len(expected_calls)
+ assert call_args_list == expected_calls
+
+ GsSession.current._post.assert_has_calls(expected_calls, any_order=False)
+
+
 if __name__ == "__main__":
  pytest.main([__file__])

gs_quant/test/timeseries/test_backtesting.py

@@ -70,6 +70,36 @@ def test_basket_series():
  index=dates)
  assert_series_equal(mreb, basket_series([mreb], [1], rebal_freq=RebalFreq.MONTHLY))
 
+ dates = [
+ datetime.datetime(2019, 1, 1),
+ datetime.datetime(2019, 1, 2),
+ datetime.datetime(2019, 1, 3),
+ datetime.datetime(2019, 1, 4),
+ datetime.datetime(2019, 1, 5),
+ datetime.datetime(2019, 1, 8),
+ datetime.datetime(2019, 1, 9),
+ datetime.datetime(2019, 1, 10),
+ datetime.datetime(2019, 1, 11),
+ datetime.datetime(2019, 1, 12),
+ datetime.datetime(2019, 1, 13)
+ ]
+ wreb = pd.Series(
+ [100.0, 105, 110, 115, 120, 125,
+ 130, 135, 140, 145, 150],
+ index=dates)
+
+ wreb_2 = pd.Series(
+ [100.0, 105, 110, 115, 120, 125,
+ 130, 135, 140, 145, 150],
+ index=dates)
+
+ ret_wreb = pd.Series(
+ [100.0, 110.0, 120.0, 130.0, 140.0, 150.0,
+ 162.0, 174.0, 186.0, 198.0, 210.0],
+ index=dates)
+
+ assert_series_equal(ret_wreb, basket_series([wreb, wreb_2], [1, 1], rebal_freq=RebalFreq.WEEKLY))
+
 
 def _mock_spot_data():
  dates = pd.date_range(start='2021-01-01', periods=6)

gs_quant/test/timeseries/test_measures_fx_vol.py

@@ -40,7 +40,13 @@
 
 def test_currencypair_to_tdapi_fxfwd_asset():
  mock_eur = Cross('MA8RY265Q34P7TWZ', 'EURUSD')
+ replace = Replacer()
+ xrefs = replace('gs_quant.timeseries.measures_fx_vol._get_tdapi_fxo_assets', Mock())
+ xrefs.return_value = 'MA8RY265Q34P7TWZ'
+ bbid_mock = replace('gs_quant.timeseries.measures_fx_vol.Asset.get_identifier', Mock())
+ bbid_mock.return_value = {'EURUSD'}
  assert _currencypair_to_tdapi_fxfwd_asset(mock_eur) == "MA8RY265Q34P7TWZ"
+ replace.restore()
 
 
 def test_currencypair_to_tdapi_fxo_asset(mocker):
@@ -153,7 +159,9 @@ def test_get_tdapi_fxo_assets():
  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()
+ kwargs = dict(asset_parameters_expiration_date='5y', asset_parameters_call_currency='USD',
+ asset_parameters_put_currency='EUR')
+ assert 'MAW8SAXPSKYA94E2' == tm_fxo._get_tdapi_fxo_assets(**kwargs)
  replace.restore()
 
  assets = replace('gs_quant.timeseries.measures.GsAssetApi.get_many_assets', Mock())
@@ -199,7 +207,8 @@ def test_get_tdapi_fxo_assets():
 def mock_curr(_cls, _q):
  d = {
  'impliedVolatility': [1, 2, 3],
- 'fwdPoints': [4, 5, 6]
+ 'fwdPoints': [4, 5, 6],
+ 'forwardPoint': [7, 8, 9]
  }
  df = MarketDataResponseFrame(data=d, index=_index * 3)
  df.dataset_ids = _test_datasets
@@ -295,8 +304,16 @@ def test_fwd_points(mocker):
  args['settlement_date'] = '6m'
 
  args['real_time'] = True
- with pytest.raises(NotImplementedError):
- tm_fxo.fwd_points(**args)
+ xrefs = replace('gs_quant.timeseries.measures.Asset.get_identifier', Mock())
+ xrefs.return_value = 'EURUSD'
+ identifiers = replace('gs_quant.timeseries.measures_fx_vol._get_tdapi_fxo_assets', Mock())
+ identifiers.return_value = {'MAGZMXVM0J282ZTR'}
+ mocker.patch.object(GsDataApi, 'get_market_data', return_value=mock_curr(None, None))
+ actual = tm_fxo.fwd_points(**args)
+ expected = tm.ExtendedSeries([7, 8, 9], index=_index * 3, name='forwardPoint')
+ expected.dataset_ids = _test_datasets
+ assert_series_equal(expected, actual)
+ assert actual.dataset_ids == _test_datasets
  args['real_time'] = False
 
  args['asset'] = Cross('MAGZMXVM0J282ZTR', 'EURUSD')

gs_quant/test/utils/mock_request.py

@@ -20,6 +20,7 @@
 from typing import List
 from unittest import mock
 
+from gs_quant.errors import MqUninitialisedError
 from gs_quant.session import GsSession, Environment
 
 
@@ -45,9 +46,12 @@ def __enter__(self):
  self.mocker.patch.object(self.api, self.method, side_effect=self.mock_calc_create_new_files if str(
  self.save_files).casefold() == 'new' else self.mock_calc_create_files)
  else:
- from gs_quant.session import OAuth2Session
- OAuth2Session.init = mock.MagicMock(return_value=None)
- GsSession.use(Environment.PROD, 'fake_client_id', 'fake_secret', application=self.application)
+ try:
+ _ = GsSession.current
+ except MqUninitialisedError:
+ from gs_quant.session import OAuth2Session
+ OAuth2Session._authenticate = mock.MagicMock(return_value=None)
+ GsSession.use(Environment.PROD, 'fake_client_id', 'fake_secret', application=self.application)
  self.mocker.patch.object(self.api, self.method, side_effect=self.mock_calc)
 
  def mock_calc(self, *args, **kwargs):