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')