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 factor_zscore(asset: Asset, risk_model_id: str, factor_name: str, *,
source: str = None, real_time: bool = False, request_id: Optional[str] = None) -> pd.Series:
"""
Asset factor exposure (in the form of z-scores) for a factor using specified risk model
:param asset: asset object loaded from security master
:param risk_model_id: requested risk model id
:param factor_name: requested factor name
:param source: name of function caller
:param real_time: whether to retrieve intraday data instead of EOD
:param request_id: service request id, if any
:return: Time-series of asset factor exposure across available risk model dates
"""
model = FactorRiskModel.get(risk_model_id)
factor = model.get_factor(factor_name)
gsid = asset.get_identifier('GSID')
# Query risk model data
query_results = model.get_data(
measures=[Measure.Factor_Name, Measure.Universe_Factor_Exposure, Measure.Asset_Universe],
start_date=DataContext.current.start_time,
end_date=DataContext.current.end_time,
assets=DataAssetsRequest(identifier=RiskModelUniverseIdentifierRequest.gsid, universe=[gsid])
).get('results', [])
# Get the factor data from query results
z_scores = {}
for result in query_results:
exposures = result.get('assetData', {}).get('factorExposure', [])
if exposures:
z_scores[result['date']] = exposures[0].get(factor.id)
return __format_plot_measure_results(z_scores, QueryType.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_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 upload_asset_coverage_data(self, date: dt.date = None):
""" Upload to the coverage dataset for given risk model and date
:param date: date to upload coverage data for, default date is last date from risk model calendar
Posting to the coverage dataset within in the last 5 days will enable the risk model to be seen in the
Marquee UI dropdown for users with "execute" capabilities
"""
if not date:
date = self.get_dates()[-1]
update_time = dt.datetime.today().strftime("%Y-%m-%dT%H:%M:%SZ")
gsid_list = self.get_asset_universe(date,
assets=DataAssetsRequest(
'gsid', []),
format=ReturnFormat.JSON).get(date)
request_array = [{
'date': date.strftime('%Y-%m-%d'),
'gsid': gsid,
'riskModel': self.id,
'updateTime': update_time
} for gsid in set(gsid_list)]
list_of_requests = list(divide_request(request_array, 1000))
for request_set in list_of_requests:
print(
GsDataApi.upload_data('RISK_MODEL_ASSET_COVERAGE',
request_set))
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_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 factor_exposure(asset: Asset,
risk_model_id: str,
factor_name: str,
*,
source: str = None,
real_time: bool = False,
request_id: Optional[str] = None) -> pd.Series:
"""
Asset factor Exposure (in the form of z-scores) for a factor using specified risk model
:param asset: asset object loaded from security master
:param risk_model_id: requested risk model id
:param factor_name: requested factor name
:param source: name of function caller
:param real_time: whether to retrieve intraday data instead of EOD
:param request_id: service request id, if any
:return: Timeseries of asset factor exposure across available risk model dates
"""
risk_model = RiskModel(risk_model_id)
factor = Factor(risk_model_id, factor_name)
if factor.factor is None or risk_model_id != factor.risk_model_id:
raise MqValueError(
'Requested factor not available in requested risk model')
asset_gsid = asset.get_identifiers().get('GSID')
# Establish date interval for data query
dates = risk_model.get_dates()
start_date = dt.datetime.strptime(min(dates),
"%Y-%m-%d").date() if dates else None
end_date = dt.datetime.strptime(max(dates),
"%Y-%m-%d").date() if dates else None
# Query data and append pull requested factor exposure
all_exposures = []
query_results = risk_model.get_data(
measures=[
Measure.Factor_Name, Measure.Universe_Factor_Exposure,
Measure.Asset_Universe
],
start_date=start_date,
end_date=end_date,
assets=DataAssetsRequest(identifier=AssetUniverseIdentifier.gsid,
universe=[asset_gsid])).get('results', [])
for result in query_results:
if result.get('date') in dates:
exposures = result.get('assetData', {}).get('factorExposure', [])
if exposures:
all_exposures.append({
'date':
result['date'],
'factorExposure':
exposures[0].get(factor.factor.identifier)
})
# Create and return timeseries
df = pd.DataFrame(all_exposures)
df.set_index('date', inplace=True)
df.index = pd.to_datetime(df.index)
return _extract_series_from_df(df, QueryType.FACTOR_EXPOSURE)
def get_universe_factor_exposure(
self,
start_date: dt.date,
end_date: dt.date = None,
assets: DataAssetsRequest = DataAssetsRequest(
RiskModelUniverseIdentifierRequest.gsid, []),
format: ReturnFormat = ReturnFormat.DATA_FRAME
) -> Union[List[Dict], pd.DataFrame]:
""" Get 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
"""
return super().get_universe_exposure(start_date, end_date, assets,
format)
def get_residual_variance(self,
start_date: dt.date,
end_date: dt.date = None,
assets: DataAssetsRequest = None,
data_format: Format = None) -> Dict:
""" Retrieve residual variance data for existing risk model """
if not assets:
assets = DataAssetsRequest(UniverseIdentifier.gsid, [])
if assets.identifier != UniverseIdentifier.gsid:
raise ValueError(
'Cannot query residual variance by identifiers other than gsid'
)
results = GsRiskModelApi.get_risk_model_data(
model_id=self.model.id,
start_date=start_date,
end_date=end_date,
assets=assets,
measures=[Measure.Residual_Variance, Measure.Asset_Universe],
limit_factors=False,
data_format=data_format).get('results')
return _build_asset_data_map(results, assets, 'residualVariance')
