def batch_and_upload_partial_data(model_id: str, data: dict):
""" Takes in total risk model data for one day and batches requests according to
asset data size, returns a list of messages from resulting post calls"""
date = data.get('date')
target_universe_size = len(data.get('assetData').get('universe'))
factor_data = {
'date': date,
'factorData': data.get('factorData'),
'covarianceMatrix': data.get('covarianceMatrix')
}
print('Uploading factor data')
print(
GsFactorRiskModelApi.upload_risk_model_data(model_id,
factor_data,
partial_upload=True))
split_num = math.ceil(target_universe_size /
20000) if math.ceil(target_universe_size /
20000) else 1
split_idx = math.ceil(target_universe_size / split_num)
for i in range(split_num):
end_idx = (
i +
1) * split_idx if split_num != i + 1 else target_universe_size + 1
asset_data_subset = {
'universe':
data.get('assetData').get('universe')[i * split_idx:end_idx],
'specificRisk':
data.get('assetData').get('specificRisk')[i * split_idx:end_idx],
'factorExposure':
data.get('assetData').get('factorExposure')[i * split_idx:end_idx]
}
optional_asset_inputs = ['totalRisk', 'historicalBeta']
for optional_input in optional_asset_inputs:
if data.get('assetData').get(optional_input):
asset_data_subset[optional_input] = data.get('assetData').get(
optional_input)[i * split_idx:end_idx]
asset_data_request = {'date': date, 'assetData': asset_data_subset}
print(
GsFactorRiskModelApi.upload_risk_model_data(
model_id,
asset_data_request,
partial_upload=True,
target_universe_size=target_universe_size))
if 'issuerSpecificCovariance' in data.keys(
) or 'factorPortfolios' in data.keys():
optional_data = {}
for optional_input in ['issuerSpecificCovariance', 'factorPortfolios']:
if data.get(optional_input):
optional_data[optional_input] = data.get(optional_input)
print(f'{list(optional_data.keys())} being uploaded for {date}...')
optional_data['date'] = date
print(
GsFactorRiskModelApi.upload_risk_model_data(
model_id,
optional_data,
partial_upload=True,
target_universe_size=target_universe_size))
def save_factor_metadata(self, factor_metadata: RiskModelFactor):
""" Add metadata to a factor in a risk model
:param factor_metadata: factor metadata object
"""
try:
GsFactorRiskModelApi.update_risk_model_factor(
self.id, factor_metadata)
except MqRequestError:
GsFactorRiskModelApi.create_risk_model_factor(
self.id, factor_metadata)
def batch_and_upload_partial_data(model_id: str, data: dict) -> list:
""" Takes in total risk model data for one day and batches requests according to
asset data size, returns a list of messages from resulting post calls"""
posting_result_messages = []
target_universe_size = len(data.get('assetData').get('universe'))
factor_data = RiskModelData(data.get('date'),
factor_data=data.get('factorData'),
covariance_matrix=data.get('covarianceMatrix'))
posting_result_messages.append(
GsFactorRiskModelApi.upload_risk_model_data(model_id,
factor_data,
partial_upload=True))
split_num = int(target_universe_size / 15000) if int(target_universe_size /
15000) else 1
split_idx = int(target_universe_size / split_num)
for i in range(split_num):
end_idx = (
i +
1) * split_idx if split_num != i + 1 else target_universe_size + 1
asset_data_subset = {
'universe':
data.get('assetData').get('universe')[i * split_idx:end_idx],
'specificRisk':
data.get('assetData').get('specificRisk')[i * split_idx:end_idx],
'factorExposure':
data.get('assetData').get('factorExposure')[i * split_idx:end_idx]
}
optional_asset_inputs = ['totalRisk', 'historicalBeta']
for optional_input in optional_asset_inputs:
if data.get('assetData').get(optional_input):
asset_data_subset[optional_input] = data.get('assetData').get(
optional_input)[i * split_idx:end_idx]
asset_data_request = RiskModelData(data.get('date'),
asset_data=asset_data_subset)
posting_result_messages.append(
GsFactorRiskModelApi.upload_risk_model_data(
model_id,
asset_data_request,
partial_upload=True,
target_universe_size=target_universe_size))
optional_inputs = ['issuerSpecificCovariance', 'factorPortfolios']
optional_data = {'date': data.get('date')}
for optional_input in optional_inputs:
if data.get(optional_input):
optional_data[optional_input] = data.get(optional_input)
posting_result_messages.append(
GsFactorRiskModelApi.upload_risk_model_data(
model_id,
optional_data,
partial_upload=True,
target_universe_size=target_universe_size))
return posting_result_messages
def batch_and_upload_partial_data(model_id: str, data: dict, max_asset_size):
""" Takes in total risk model data for one day and batches requests according to
asset data size, returns a list of messages from resulting post calls"""
date = data.get('date')
if data.get('factorData'):
factor_data = {
'date': date,
'factorData': data.get('factorData'),
'covarianceMatrix': data.get('covarianceMatrix')
}
print('Uploading factor data')
print(
GsFactorRiskModelApi.upload_risk_model_data(model_id,
factor_data,
partial_upload=True))
if data.get('assetData'):
asset_data_list, target_size = _batch_input_data(
{'assetData': data.get('assetData')}, max_asset_size)
for asset_data_batch in asset_data_list:
print(
GsFactorRiskModelApi.upload_risk_model_data(
model_id, {
'assetData': asset_data_batch,
'date': date
},
partial_upload=True,
target_universe_size=target_size))
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)
print(f'{optional_input_key} being uploaded for {date}...')
for optional_data_batch in optional_data_list:
print(
GsFactorRiskModelApi.upload_risk_model_data(
model_id, {
optional_input_key: optional_data_batch,
'date': date
},
partial_upload=True,
target_universe_size=target_size))
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 test_get_risk_model_factors(mocker):
factors = {
'results': [
RiskModelFactor.from_dict({
"type": "Factor",
"identifier": "Factor1"
}),
RiskModelFactor.from_dict({
"type": "Category",
"identifier": "Factor2"
})
],
'totalResults':
2
}
expected_response = [
RiskModelFactor(identifier='Factor1', type='Factor'),
RiskModelFactor(identifier='Factor2', type='Category')
]
# 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=factors)
# run test
response = GsFactorRiskModelApi.get_risk_model_factors(model_id='id')
GsSession.current._get.assert_called_with('/risk/models/id/factors',
cls=RiskModelFactor)
assert response == expected_response
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_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 test_get_risk_model_coverage(mocker):
results = {
"results": [
RiskModelFactor.from_dict({
"model": "AXUS4S",
"businessDate": "2020-11-02"
}),
RiskModelFactor.from_dict({
"model": "AXAU4M",
"businessDate": "2020-11-03"
})
]
}
# 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_coverage()
GsSession.current._post.assert_called_with('/risk/models/coverage', {})
assert response == results['results']
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_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_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 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 update_factor(self, factor_id: str,
factor: RiskModelFactor) -> RiskModelFactor:
""" Update existing risk model factor
:param factor_id: factor identifier associated with risk model to update
:param factor: factor object associated with risk model
:return: Risk Model Factor object """
return GsFactorRiskModelApi.update_risk_model_factor(
self.id, factor_id, factor)
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
def upload_partial_data(self, data: RiskModelData, target_universe_size: float = None):
""" Upload partial risk model data to existing risk model in Marquee
:param data: partial risk model data for uploading on given date
:param target_universe_size: the size of the complete universe on date
The models factorData and covarianceMatrix must be uploaded first on given date if repeats in partial
upload, newer posted data will replace existing data on upload day """
print(GsFactorRiskModelApi.upload_risk_model_data(
self.id,
data,
partial_upload=True,
target_universe_size=target_universe_size)
)
def test_upload_risk_model_data(mocker):
risk_model_data = {
'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]
}]
}
}
# 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='Successfully uploaded')
# run test
response = GsFactorRiskModelApi.upload_risk_model_data(
model_id='id', model_data=risk_model_data)
GsSession.current._post.assert_called_with(
'/risk/models/data/{id}'.format(id='id'), risk_model_data)
assert response == 'Successfully uploaded'
def upload_data(self, data: Union[RiskModelData, Dict]):
""" Upload risk model data to existing risk model
:param data: complete risk model data for uploading on given date
includes: date, factorData, assetData, covarianceMatrix with optional inputs:
issuerSpecificCovariance and factorPortfolios
If upload universe is over 20000 assets, will batch and upload data in chunks of 20000 assets """
data = data.to_json() if type(data) == RiskModelData else data
target_universe_size = len(data.get('assetData').get('universe'))
if target_universe_size > 20000:
print('Batching uploads due to universe size')
batch_and_upload_partial_data(self.id, data)
else:
print(GsFactorRiskModelApi.upload_risk_model_data(self.id, data))
def get_factor_data(
self,
start_date: dt.date = None,
end_date: dt.date = None,
identifiers: List[str] = None,
include_performance_curve: bool = False,
category_filter: List[str] = None,
factor_type: FactorType = None,
format: ReturnFormat = ReturnFormat.DATA_FRAME
) -> Union[List[Dict], pd.DataFrame]:
""" Get factor data for existing risk model
:param start_date: start date for data request
:param end_date: end date for data request
:param identifiers: list of factor ids associated with risk model
:param include_performance_curve: request to include the performance curve of the factors
:param category_filter: filter the results to those having one of the specified categories. \
Default is to return all results
:param factor_type:
:param format: which format to return the results in
:return: risk model factor data
"""
factor_data = GsFactorRiskModelApi.get_risk_model_factor_data(
self.id, start_date, end_date, identifiers,
include_performance_curve)
if factor_type:
factor_data = [
factor for factor in factor_data
if factor['type'] == factor_type.value
]
if category_filter:
if factor_type == FactorType.Category:
print(
'Category Filter is not applicable for the Category FactorType'
)
else:
factor_data = [
factor for factor in factor_data
if factor['factorCategory'] in category_filter
]
if format == ReturnFormat.DATA_FRAME:
factor_data = pd.DataFrame(factor_data)
return factor_data
def test_update_risk_model_factor(mocker):
factor = Factor.from_dict({"identifier": "factor", "type": "Factor"})
# mock GsSession
mocker.patch.object(GsSession.__class__,
'default_value',
return_value=GsSession.get(Environment.QA, 'client_id',
'secret'))
mocker.patch.object(GsSession.current, '_put', return_value=factor)
# run test
response = GsFactorRiskModelApi.update_risk_model_factor(model_id='id',
factor=factor)
GsSession.current._put.assert_called_with(
'/risk/models/{id}/factors/{identifier}'.format(id='id',
identifier='factor'),
factor,
cls=Factor)
assert response == factor
def test_create_risk_model_factor(mocker):
factor = Factor.from_dict({"identifier": "Factor1", "type": "Factor"})
expected_response = Factor(identifier='Factor1', type='Factor')
# 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=factor)
# run test
response = GsFactorRiskModelApi.create_risk_model_factor(model_id='id',
factor=factor)
GsSession.current._post.assert_called_with('/risk/models/id/factors',
factor,
cls=Factor)
assert response == expected_response
def get_factor_data(
self,
start_date: dt.date = None,
end_date: dt.date = None,
identifiers: List[str] = None,
include_performance_curve: bool = False,
format: ReturnFormat = ReturnFormat.DATA_FRAME
) -> Union[List[Dict], pd.DataFrame]:
""" Retrieve factor data for existing risk model
:param start_date: start date for data request
:param end_date: end date for data request
:param identifiers: list of factor ids associated with risk model
:param include_performance_curve: request to include the performance curve of the factors
:param format: which format to return the results in
:return: risk model factor data """
factor_data = GsFactorRiskModelApi.get_risk_model_factor_data(
self.id, start_date, end_date, identifiers,
include_performance_curve)
if format == ReturnFormat.DATA_FRAME:
factor_data = pd.DataFrame(factor_data)
return factor_data
def upload_data(self,
data: Union[RiskModelData, Dict],
max_asset_batch_size: int = 20000):
""" Upload risk model data to existing risk model in Marquee
:param data: complete risk model data for uploading on given date
includes: date, factorData, assetData, covarianceMatrix with optional inputs:
issuerSpecificCovariance and factorPortfolios
:param max_asset_batch_size: size of payload to batch with. Defaults to 20000 assets
If upload universe is over 20000 max_asset_batch_size, will batch and upload data in chunks of 20000 assets
"""
data = risk_model_data_to_json(data) if type(
data) == RiskModelData else data
target_universe_size = get_universe_size(data)
if target_universe_size > max_asset_batch_size:
print('Batching uploads due to universe size')
batch_and_upload_partial_data(self.id, data, max_asset_batch_size)
else:
print(GsFactorRiskModelApi.upload_risk_model_data(self.id, data))
def create_factor(self, factor: RiskModelFactor) -> RiskModelFactor:
""" Create a new risk model factor
:param factor: factor object
:return: Risk Model Factor object """
return GsFactorRiskModelApi.create_risk_model_factor(self.id, factor)
def delete_factor(self, factor_id: str):
""" Delete a risk model factor
:param factor_id: factor identifier associated with risk model to delete """
GsFactorRiskModelApi.delete_risk_model_factor(self.id, factor_id)
def get_factor(self, factor_id: str) -> RiskModelFactor:
""" Retrieve risk model factor from model and factor ids
:param factor_id: factor identifier associated with risk model
:return: Risk Model Factor object """
return GsFactorRiskModelApi.get_risk_model_factor(self.id, factor_id)
def get_most_recent_date_from_calendar(risk_model_id: str):
calendar = GsFactorRiskModelApi.get_risk_model_calendar(
risk_model_id).business_dates
return dt.datetime.strptime(
calendar[get_closest_date_index(dt.date.today() - dt.timedelta(days=1),
calendar, "before")], "%Y/%m/%d")
