def get_universe_factor_exposure(
self,
start_date: dt.date,
end_date: dt.date = None,
assets: DataAssetsRequest = DataAssetsRequest(UniverseIdentifier.gsid,
[]),
format: ReturnFormat = ReturnFormat.DATA_FRAME
) -> Union[List[Dict], pd.DataFrame]:
""" Retrieve universe factor exposure data for existing risk model
:param start_date: start date for data request
:param end_date: end date for data request
:param assets: DataAssetsRequest object with identifier and list of assets to retrieve for request
:param format: which format to return the results in
:return: factor exposure for assets requested """
results = GsFactorRiskModelApi.get_risk_model_data(
model_id=self.id,
start_date=start_date,
end_date=end_date,
assets=assets,
measures=[
Measure.Universe_Factor_Exposure, Measure.Asset_Universe
],
limit_factors=False).get('results')
universe = assets.universe if assets.universe else results[0].get(
'assetData').get('universe')
factor_exposure = build_asset_data_map(results, universe,
'factorExposure')
if format == ReturnFormat.DATA_FRAME:
factor_exposure = pd.DataFrame.from_dict(
{(i, j): factor_exposure[i][j]
for i in factor_exposure.keys()
for j in factor_exposure[i].keys()},
orient='index')
return factor_exposure
def get_asset_universe(
self,
start_date: dt.date,
end_date: dt.date = None,
assets: DataAssetsRequest = DataAssetsRequest(UniverseIdentifier.gsid,
[]),
format: ReturnFormat = ReturnFormat.DATA_FRAME
) -> Union[List[Dict], pd.DataFrame]:
""" Retrieve asset universe data for existing risk model
:param start_date: start date for data request
:param end_date: end date for data request
:param assets: DataAssetsRequest object with identifier and list of assets to retrieve for request
:param format: which format to return the results in
:return: risk model universe """
if not assets.universe and not end_date:
end_date = start_date
results = GsFactorRiskModelApi.get_risk_model_data(
model_id=self.id,
start_date=start_date,
end_date=end_date,
assets=assets,
measures=[Measure.Asset_Universe],
limit_factors=False).get('results')
dates = [
dt.datetime.strptime((data.get('date')), '%Y-%m-%d').date()
for data in results
]
universe = [data.get('assetData').get('universe') for data in results]
dates_to_universe = dict(zip(dates, universe))
if format == ReturnFormat.DATA_FRAME:
dates_to_universe = pd.DataFrame(dates_to_universe)
return dates_to_universe
def get_residual_variance(
self,
start_date: dt.date,
end_date: dt.date = None,
assets: DataAssetsRequest = DataAssetsRequest(UniverseIdentifier.gsid,
[]),
format: ReturnFormat = ReturnFormat.DATA_FRAME
) -> Union[List[Dict], pd.DataFrame]:
""" Retrieve residual variance data for existing risk model
:param start_date: start date for data request
:param end_date: end date for data request
:param assets: DataAssetsRequest object with identifier and list of assets to retrieve for request
:param format: which format to return the results in
:return: residual variance for assets requested """
results = GsFactorRiskModelApi.get_risk_model_data(
model_id=self.id,
start_date=start_date,
end_date=end_date,
assets=assets,
measures=[Measure.Residual_Variance, Measure.Asset_Universe],
limit_factors=False).get('results')
universe = assets.universe if assets.universe else results[0].get(
'assetData').get('universe')
residual_variance = build_asset_data_map(results, universe,
'residualVariance')
if format == ReturnFormat.DATA_FRAME:
residual_variance = pd.DataFrame(residual_variance)
return residual_variance
def get_factor_portfolios(
self,
start_date: dt.date,
end_date: dt.date = None,
assets: DataAssetsRequest = DataAssetsRequest(
RiskModelUniverseIdentifierRequest.gsid, []),
format: ReturnFormat = ReturnFormat.DATA_FRAME
) -> Union[Dict, pd.DataFrame]:
""" Get factor portfolios data for existing risk model
:param start_date: start date for data request
:param end_date: end date for data request
:param assets: DataAssetsRequest object with identifier and list of assets to retrieve for request
:param format: which format to return the results in
:return: factor portfolios data
"""
results = GsFactorRiskModelApi.get_risk_model_data(
model_id=self.id,
start_date=start_date,
end_date=end_date,
assets=assets,
measures=[Measure.Factor_Portfolios],
limit_factors=False).get('results')
pfp_data = results if format == ReturnFormat.JSON else build_pfp_data_dataframe(
results)
return pfp_data
def get_data(self,
measures: List[Measure],
start_date: dt.date,
end_date: dt.date = None,
assets: DataAssetsRequest = DataAssetsRequest(
RiskModelUniverseIdentifierRequest.gsid, []),
limit_factors: bool = True) -> Dict:
""" Get data for multiple measures for existing risk model
:param measures: list of measures for general risk model data request
:param start_date: start date for data request
:param end_date: end date for data request
:param assets: DataAssetsRequest object with identifier and list of assets to retrieve for request
:param limit_factors: limit factors included in factorData and covariance matrix to only include factors
which the input universe has non-zero exposure to
:return: factor portfolios data
"""
return GsFactorRiskModelApi.get_risk_model_data(
model_id=self.id,
start_date=start_date,
end_date=end_date,
assets=assets,
measures=measures,
limit_factors=limit_factors)
def get_issuer_specific_covariance(
self,
start_date: dt.date,
end_date: dt.date = None,
assets: DataAssetsRequest = DataAssetsRequest(
RiskModelUniverseIdentifierRequest.gsid, []),
format: ReturnFormat = ReturnFormat.DATA_FRAME
) -> Union[Dict, pd.DataFrame]:
""" Get issuer specific covariance data for existing risk model
:param start_date: start date for data request
:param end_date: end date for data request
:param assets: DataAssetsRequest object with identifier and list of assets to retrieve for request
:param format: which format to return the results in
:return: issuer specific covariance matrix (covariance of assets with the same issuer)
"""
isc = GsFactorRiskModelApi.get_risk_model_data(
model_id=self.id,
start_date=start_date,
end_date=end_date,
assets=assets,
measures=[Measure.Issuer_Specific_Covariance],
limit_factors=False).get('results')
isc_data = isc if format == ReturnFormat.JSON else get_isc_dataframe(
isc)
return isc_data
def get_covariance_matrix(
self,
start_date: dt.date,
end_date: dt.date = None,
format: ReturnFormat = ReturnFormat.DATA_FRAME
) -> Union[Dict, pd.DataFrame]:
""" Get covariance matrix data for existing risk model
:param start_date: start date for data request
:param end_date: end date for data request
:param format: which format to return the results in
:return: covariance matrix of daily factor returns
"""
results = GsFactorRiskModelApi.get_risk_model_data(
model_id=self.id,
start_date=start_date,
end_date=end_date,
assets=None,
measures=[
Measure.Covariance_Matrix, Measure.Factor_Name,
Measure.Factor_Id
],
limit_factors=False).get('results')
covariance_data = results if format == ReturnFormat.JSON else get_covariance_matrix_dataframe(
results)
return covariance_data
def get_factor_returns_by_id(
self,
start_date: dt.date,
end_date: dt.date = None,
format: ReturnFormat = ReturnFormat.DATA_FRAME
) -> Union[Dict, pd.DataFrame]:
""" Get factor return data for existing risk model keyed by factor id
:param start_date: start date for data request
:param end_date: end date for data request
:param format: which format to return the results in
:return: factor returns by factor id
"""
results = GsFactorRiskModelApi.get_risk_model_data(
model_id=self.id,
start_date=start_date,
end_date=end_date,
assets=None,
measures=[
Measure.Factor_Return, Measure.Factor_Name, Measure.Factor_Id
],
limit_factors=False).get('results')
factor_data = build_factor_data_dataframe(results, 'id') if format == ReturnFormat.DATA_FRAME else \
build_factor_data_map(results, 'id')
return factor_data
def get_covariance_matrix(
self,
start_date: dt.date,
end_date: dt.date = None,
assets: DataAssetsRequest = None,
format: ReturnFormat = ReturnFormat.DATA_FRAME
) -> Union[Dict, pd.DataFrame]:
""" Get covariance matrix data for existing risk model
:param start_date: start date for data request
:param end_date: end date for data request
:param assets: DataAssetsRequest object with identifier and list of assets to limit the covariance matrix by
:param format: which format to return the results in
:return: covariance matrix of daily factor returns
"""
limit_factors = True if assets else False
measures = [
Measure.Covariance_Matrix, Measure.Factor_Name, Measure.Factor_Id
]
if assets:
measures.append(Measure.Universe_Factor_Exposure)
results = GsFactorRiskModelApi.get_risk_model_data(
model_id=self.id,
start_date=start_date,
end_date=end_date,
assets=assets,
measures=measures,
limit_factors=limit_factors).get('results')
covariance_data = results if format == ReturnFormat.JSON else get_covariance_matrix_dataframe(
results)
return covariance_data
def get_factor_returns_by_id(
self,
start_date: dt.date,
end_date: dt.date = None,
assets: DataAssetsRequest = None,
format: ReturnFormat = ReturnFormat.DATA_FRAME
) -> Union[Dict, pd.DataFrame]:
""" Get factor return data for existing risk model keyed by factor id
:param start_date: start date for data request
:param end_date: end date for data request
:param assets: DataAssetsRequest object with identifier and list of assets to limit the factors by
:param format: which format to return the results in
:return: factor returns by factor id
"""
limit_factors = True if assets else False
measures = [
Measure.Factor_Return, Measure.Factor_Name, Measure.Factor_Id
]
if assets:
measures.append(Measure.Universe_Factor_Exposure)
results = GsFactorRiskModelApi.get_risk_model_data(
model_id=self.id,
start_date=start_date,
end_date=end_date,
assets=assets,
measures=measures,
limit_factors=limit_factors).get('results')
factor_data = build_factor_data_dataframe(results, 'id') if format == ReturnFormat.DATA_FRAME else \
build_factor_data_map(results, 'id')
return factor_data
def test_get_risk_model_data(mocker):
query = {'startDate': '2020-01-01', 'endDate': '2020-03-03'}
results = {
'results': [{
'date':
'2020-02-05',
'assetData': {
'universe': ['2407966', '2046251', 'USD'],
'specificRisk': [12.09, 45.12, 3.09],
'factorExposure': [{
'1': 0.23,
'2': 0.023
}],
'historicalBeta': [0.12, 0.45, 1.2]
},
'factorData': [{
'factorId': '1',
'factorName': 'USD',
'factorCategory': 'Currency',
'factorCategoryId': 'CUR'
}],
'covarianceMatrix': [[0.089, 0.0123, 0.345]],
'issuerSpecificCovariance': {
'universeId1': ['2407966'],
'universeId2': ['2046251'],
'covariance': [0.03754]
},
'factorPortfolios': {
'universe': ['2407966', '2046251'],
'portfolio': [{
'factorId': 2,
'weights': [0.25, 0.75]
}]
}
}],
'totalResults':
1,
'missingDates': []
}
# 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=results)
# run test
response = GsFactorRiskModelApi.get_risk_model_data(
model_id='id',
start_date=dt.date(2020, 1, 1),
end_date=dt.date(2020, 3, 3))
GsSession.current._post.assert_called_with(
'/risk/models/data/{id}/query'.format(id='id'), query)
assert response == results
