def __query_indicative_levels_dataset(self, start=None, end=None): where = dict(assetId=self.id) if start is None: query = DataQuery(where=where) else: query = DataQuery(where=where, start_date=start, end_date=end) response = GsDataApi.query_data( query=query, dataset_id=IndicesDatasets.STS_INDICATIVE_LEVELS.value) return response
def get_corporate_actions(self, start: dt.date = DateLimit.LOW_LIMIT.value, end: dt.date = dt.date.today() + dt.timedelta(days=10), ca_type: [CorporateActionType] = CorporateActionType.to_list()) -> pd.DataFrame: """ Retrieve corporate actions for a basket across a date range :param start: start date (default minimum date value) :param end: end date (default is maximum date value) :param ca_type: list of corporate action types (default is all) :return: dataframe with corporate actions information **Usage** Retrieve corporate actions for a basket across a date range **Examples** Retrieve historical acquisition corporate actions for a basket >>> from gs_quant.markets.baskets import Basket >>> from gs_quant.markets.indices_utils import CorporateActionType >>> >>> basket = Basket("GSMBXXXX") >>> basket.get_corporate_actions(ca_type=[CorporateActionType.ACQUISITION]) **See also** :func:`get_fundamentals` """ where = dict(assetId=self.id, corporateActionType=ca_type) query = DataQuery(where=where, start_date=start, end_date=end) response = GsDataApi.query_data(query=query, dataset_id=IndicesDatasets.CORPORATE_ACTIONS.value) return pd.DataFrame(response)
def result(self): """ :return: a Pandas DataFrame containing the results of the report job """ status = self.status() if status == ReportStatus.cancelled: raise MqValueError( 'This report job in status "cancelled". Cannot retrieve results.' ) if status == ReportStatus.error: raise MqValueError( 'This report job is in status "error". Cannot retrieve results.' ) if status != ReportStatus.done: raise MqValueError( 'This report job is not done. Cannot retrieve results.') if self.__report_type in [ ReportType.Portfolio_Factor_Risk, ReportType.Asset_Factor_Risk ]: results = GsReportApi.get_factor_risk_report_results( risk_report_id=self.__report_id, start_date=self.__start_date, end_date=self.__end_date) return pd.DataFrame(results) if self.__report_type == ReportType.Portfolio_Performance_Analytics: query = DataQuery(where={'reportId': self.__report_id}, start_date=self.__start_date, end_date=self.__end_date) results = GsDataApi.query_data( query=query, dataset_id=ReportDataset.PPA_DATASET.value) return pd.DataFrame(results) return None
def get_portfolio_constituents( self, fields: List[str] = None, start_date: dt.date = None, end_date: dt.date = None, return_format: ReturnFormat = ReturnFormat.DATA_FRAME ) -> Union[Dict, pd.DataFrame]: """ Get historical portfolio constituents :param fields: list of fields to include in the results :param start_date: start date :param end_date: end date :param return_format: return format; defaults to a Pandas DataFrame, but can be manually set to ReturnFormat.JSON :return: Portfolio constituent data for each day in the requested date range """ where = {'reportId': self.id} date_batches = _get_ppaa_batches( self.get_asset_count(start_date, end_date), 3000000) queries = [ DataQuery(where=where, fields=fields, start_date=dates_batch[0], end_date=dates_batch[1]) for dates_batch in date_batches ] results = [ GsDataApi.query_data( query=query, dataset_id=ReportDataset.PORTFOLIO_CONSTITUENTS.value) for query in queries ] results = sum(results, []) return pd.DataFrame( results) if return_format == ReturnFormat.DATA_FRAME else results
def get_many_measures( self, measures: Tuple[str, ...] = None, start_date: dt.date = None, end_date: dt.date = None, return_format: ReturnFormat = ReturnFormat.DATA_FRAME ) -> Union[Dict, pd.DataFrame]: """ Get many historical portfolio metrics :param measures: a list of metrics :param start_date: start date :param end_date: end date :return: returns a Pandas DataFrame with the results """ if measures is None: measures = [] fields = tuple(measure for measure in measures) where = {'reportId': self.id} query = DataQuery(where=where, fields=fields, start_date=start_date, end_date=end_date) results = GsDataApi.query_data( query=query, dataset_id=ReportDataset.PPA_DATASET.value) return pd.DataFrame( results) if return_format == ReturnFormat.DATA_FRAME else results
def covariance(self, factor, start_date: date = DataContext.current.start_date, end_date: date = DataContext.current.end_date) -> Dict: """ Retrieve a Dictionary of date->covariance values between this factor and another for a date range """ covariance_data_raw = GsDataApi.execute_query( 'RISK_MODEL_COVARIANCE_MATRIX', DataQuery( where={"riskModel": self.risk_model_id, "factorId": self.id}, start_date=start_date, end_date=end_date ) ).get('data', []) date_to_matrix_order = factor.__matrix_order(start_date, end_date) covariance_data = {} for data in covariance_data_raw: date = data['date'] if date_to_matrix_order.get(date): matrix_order_on_date = date_to_matrix_order[date] covariance_data[date] = data[matrix_order_on_date] return covariance_data
def covariance( self, factor, start_date: date = DataContext.current.start_date, end_date: date = DataContext.current.end_date, format: ReturnFormat = ReturnFormat.DATA_FRAME ) -> Union[Dict, pd.DataFrame]: """ Retrieve a Dataframe or Dictionary of date->covariance values between this factor and another for a date range """ covariance_data_raw = GsDataApi.execute_query( 'RISK_MODEL_COVARIANCE_MATRIX', DataQuery(where={ "riskModel": self.risk_model_id, "factorId": self.id }, start_date=start_date, end_date=end_date)).get('data', []) date_to_matrix_order = factor.__matrix_order(start_date, end_date) covariance_data = {} for data in covariance_data_raw: date = data['date'] if date_to_matrix_order.get(date): matrix_order_on_date = date_to_matrix_order[date] covariance_data[date] = data[matrix_order_on_date] if format == ReturnFormat.DATA_FRAME: return pd.DataFrame.from_dict(covariance_data, orient='index', columns=['covariance']) return covariance_data
def returns( self, start_date: date = DataContext.current.start_date, end_date: date = DataContext.current.end_date, format: ReturnFormat = ReturnFormat.DATA_FRAME ) -> Union[Dict, pd.DataFrame]: """ Retrieve a Dataframe or Dictionary of date->factor return values for a date range """ appendage = self.__get_dataset_trial_appendage() data_query_results = GsDataApi.execute_query( f'RISK_MODEL_FACTOR{appendage}', DataQuery(where={ "riskModel": self.risk_model_id, "factorId": self.id }, fields=['return'], start_date=start_date, end_date=end_date)).get('data', []) return_data = { factor_data['date']: factor_data['return'] for factor_data in data_query_results if factor_data.get('return') } if format == ReturnFormat.DATA_FRAME: return pd.DataFrame.from_dict(return_data, orient='index', columns=['return']) return return_data
def __get_constituents_data(basket: Dict, basket_map: Dict, start: dt.date, end: dt.date, fields: List[str]) -> List: _id, _type = get(basket, 'assetId'), get(basket, 'type') if _id not in list(basket_map.keys()): return start_date = dt.datetime.strptime(basket['historyStartDate'], '%Y-%m-%d').date() start_date = start_date if start < start_date else start dataset_id = IndicesDatasets.GSBASKETCONSTITUENTS.value if _type == BasketType.CUSTOM_BASKET.value\ else IndicesDatasets.GIRBASKETCONSTITUENTS.value data = GsDataApi.query_data(query=DataQuery(where=dict(assetId=_id), startDate=start_date, endDate=end), dataset_id=dataset_id) asset_ids = list(set([d['underlyingAssetId'] for d in data])) asset_data = GsAssetApi.get_many_assets_data_scroll(id=asset_ids, fields=fields, limit=2000, scroll='1m') asset_data_map = {get(asset, 'id'): asset for asset in asset_data} for d in data: asset_id = get(d, 'underlyingAssetId', '') asset_id_map = get(asset_data_map, asset_id, {}) for f in fields: d[f] = get(asset_id_map, f) basket_map[_id].update(constituents=data) return basket_map[_id]
def get_many_measures(cls, report_id: str, measures: Tuple[str, ...], start_date: dt.date = None, end_date: dt.date = None): fields = [] for measure in measures: fields.append(measure) where = FieldFilterMap(report_id=report_id) query = DataQuery(where=where, fields=fields, start_date=start_date, end_date=end_date) return GsDataApi.query_data(query=query, dataset_id=PPA_DATASET)
def get_many_measures(self, measures: Tuple[str, ...], start_date: dt.date = None, end_date: dt.date = None) -> Union[MDAPIDataBatchResponse, DataQueryResponse, tuple, list]: fields = tuple(measure for measure in measures) where = {'reportId': self.id} query = DataQuery(where=where, fields=fields, start_date=start_date, end_date=end_date) return GsDataApi.query_data(query=query, dataset_id=ReportDataset.PPA_DATASET.value)
def get_measure(self, field: str, start_date: dt.date = None, end_date: dt.date = None) -> Union[MDAPIDataBatchResponse, DataQueryResponse, tuple, list]: fields = (field,) where = {'reportId': self.id} query = DataQuery(where=where, fields=fields, start_date=start_date, end_date=end_date) return GsDataApi.query_data(query=query, dataset_id=ReportDataset.PPA_DATASET.value)
def build_query(start: Optional[Union[dt.date, dt.datetime]] = None, end: Optional[Union[dt.date, dt.datetime]] = None, as_of: Optional[dt.datetime] = None, since: Optional[dt.datetime] = None, restrict_fields: bool = False, **kwargs): end_is_time = isinstance(end, dt.datetime) start_is_time = isinstance(start, dt.datetime) if kwargs.get('market_data_coordinates'): real_time = ((start is None or start_is_time) and (end is None or end_is_time)) query = MDAPIDataQuery(start_time=start if real_time else None, end_time=end if real_time else None, start_date=start if not real_time else None, end_date=end if not real_time else None, format='MessagePack', real_time=real_time, **kwargs) else: if start_is_time and end is not None and not end_is_time: raise ValueError( 'If start is of type datetime, so must end be!') if isinstance(start, dt.date) and end is not None and not isinstance( end, dt.date): raise ValueError('If start is of type date, so must end be!') query = DataQuery(start_date=start if not start_is_time else None, start_time=start if start_is_time else None, end_date=end if not end_is_time else None, end_time=end if end_is_time else None, as_of_time=as_of, since=since, format="MessagePack") where = FieldFilterMap() query_properties = query.properties() where_properties = where.properties() for field, value in kwargs.items(): snake_case_field = inflection.underscore(field) if snake_case_field in query_properties: setattr(query, snake_case_field, value) elif snake_case_field in where_properties: setattr(where, snake_case_field, value) query.where = where else: raise ValueError('Invalid query field: ' + field) if getattr(query, 'fields', None) is not None: try: query.restrict_fields = restrict_fields except AttributeError as e: _logger.debug('unable to set restrict_fields', exc_info=e) return query
def get_measure(self, field: str, start_date: dt.date = None, end_date: dt.date = None, return_format: ReturnFormat = ReturnFormat.DATA_FRAME) -> Union[Dict, pd.DataFrame]: fields = (field,) where = {'reportId': self.id} query = DataQuery(where=where, fields=fields, start_date=start_date, end_date=end_date) results = GsDataApi.query_data(query=query, dataset_id=ReportDataset.PPA_DATASET.value) return pd.DataFrame(results) if return_format == ReturnFormat.DATA_FRAME else results
def build_query(start: Optional[Union[dt.date, dt.datetime]] = None, end: Optional[Union[dt.date, dt.datetime]] = None, as_of: Optional[dt.datetime] = None, since: Optional[dt.datetime] = None, **kwargs): from gs_quant.api.gs.data import DataQuery end_is_time = isinstance(end, dt.datetime) start_is_time = isinstance(start, dt.datetime) if start_is_time and end is not None and not end_is_time: raise ValueError('If start is of type datetime, so must end be!') if isinstance(start, dt.date) and end is not None and not isinstance( end, dt.date): raise ValueError('If start is of type date, so must end be!') query = DataQuery(start_date=start if not start_is_time else None, start_time=start if start_is_time else None, end_date=end if not end_is_time else None, end_time=end if end_is_time else None, as_of_time=as_of, since=since, format="MessagePack") where = FieldFilterMap() query_properties = query.properties() where_properties = where.properties() for field, value in kwargs.items(): snake_case_field = inflection.underscore(field) if snake_case_field in query_properties: setattr(query, snake_case_field, value) elif snake_case_field in where_properties: setattr(where, snake_case_field, value) else: raise ValueError('Invalid query field: ' + field) if where: query.where = where return query
def __matrix_order(self, start_date: date, end_date: date) -> Dict: """ Retrieve Dictionary of date->matrix_order for the factor in the covariance matrix """ query_results = GsDataApi.execute_query( 'RISK_MODEL_COVARIANCE_MATRIX', DataQuery( where={"riskModel": self.risk_model_id, "factorId": self.id}, fields=['matrixOrder'], start_date=start_date, end_date=end_date ) ).get('data', []) return {data['date']: str(data['matrixOrder']) for data in query_results}
def get_measure(cls, report_id: str, field: str, start_date: dt.date = None, end_date: dt.date = None): fields = [field] where = FieldValueMap(report_id=report_id) query = DataQuery(where=where, fields=fields, start_date=start_date, end_date=end_date) return GsDataApi.query_data(query=query, dataset_id=PPA_DATASET)
def build_query(start: Optional[Union[dt.date, dt.datetime]] = None, end: Optional[Union[dt.date, dt.datetime]] = None, as_of: Optional[dt.datetime] = None, since: Optional[dt.datetime] = None, **kwargs): end_is_time = isinstance(end, dt.datetime) start_is_time = isinstance(start, dt.datetime) if kwargs.get('market_data_coordinates'): if not ((start is None or start_is_time) and (end is None or end_is_time)): raise NotImplementedError( 'EOD coordinates data not implemented') query = MDAPIDataQuery( market_data_coordinates=kwargs.get('market_data_coordinates'), start_time=start, end_time=end, format="MessagePack") else: if start_is_time and end is not None and not end_is_time: raise ValueError( 'If start is of type datetime, so must end be!') if isinstance(start, dt.date) and end is not None and not isinstance( end, dt.date): raise ValueError('If start is of type date, so must end be!') query = DataQuery(start_date=start if not start_is_time else None, start_time=start if start_is_time else None, end_date=end if not end_is_time else None, end_time=end if end_is_time else None, as_of_time=as_of, since=since, format="MessagePack") where = FieldFilterMap() query_properties = query.properties() where_properties = where.properties() for field, value in kwargs.items(): snake_case_field = inflection.underscore(field) if snake_case_field in query_properties: setattr(query, snake_case_field, value) elif snake_case_field in where_properties: setattr(where, snake_case_field, value) query.where = where else: raise ValueError('Invalid query field: ' + field) return query
def get_corporate_actions( self, start_date: dt.date = DateLimit.LOW_LIMIT.value, end_date: dt.date = DateLimit.HIGH_LIMIT.value ) -> DataQueryResponse: if not self.id: self.__raise_initialization_error( 'retrieve corporate actions data') query = DataQuery(where=dict(assetId=self.id), start_date=start_date, end_date=end_date) return GsDataApi.query_data( query=query, dataset_id=IndicesDatasets.CORPORATE_ACTIONS.value)
def get_latest_close_price(self, price_type: List[PriceType] = None ) -> pd.DataFrame: """ Retrieve latest close prices for an index. Only STS indices support indicative prices. :param price_type: Type of prices to return. Default returns official close price :return: dataframe with latest close price **Usage** Retrieve latest close prices for an index **Examples** >>> from gs_quant.markets.index import Index >>> >>> index = Index.get("GSMBXXXX") >>> index.get_latest_close_price([PriceType.OFFICIAL_CLOSE_PRICE, PriceType.INDICATIVE_CLOSE_PRICE]) """ if (not price_type) or (price_type == [PriceType.OFFICIAL_CLOSE_PRICE ]): return super().get_latest_close_price() prices = pd.DataFrame() if PriceType.OFFICIAL_CLOSE_PRICE in price_type: official_level = super().get_latest_close_price() prices['date'] = official_level.index prices['closePrice'] = official_level[0] if PriceType.INDICATIVE_CLOSE_PRICE in price_type: if self.__is_sts_index(): where = dict(assetId=self.id) query = DataQuery(where=where) response = GsDataApi.last_data( query=query, dataset_id=IndicesDatasets.STS_INDICATIVE_LEVELS.value) indicative_level = pd.DataFrame(response).iloc[-1:][[ 'date', 'indicativeClosePrice' ]] prices['date'] = indicative_level['date'].iat[0] prices['indicativeClosePrice'] = indicative_level[ 'indicativeClosePrice'].iat[0] else: raise MqValueError( 'PriceType.INDICATIVE_CLOSE_PRICE currently supports STS indices only' ) return prices
def _get_measures(self, fields: List, start_date: dt.date = None, end_date: dt.date = None, basket_ids: List[str] = None, return_format: ReturnFormat = ReturnFormat.DATA_FRAME) -> Union[Dict, pd.DataFrame]: where = {'reportId': self.id} if basket_ids: where['basketId'] = basket_ids dataset = ReportDataset.PTA_DATASET.value if self.position_source_type == PositionSourceType.Portfolio \ else ReportDataset.ATA_DATASET.value query = DataQuery(where=where, fields=fields, start_date=start_date, end_date=end_date) results = GsDataApi.query_data(query=query, dataset_id=dataset) return pd.DataFrame(results) if return_format == ReturnFormat.DATA_FRAME else results
def get_covariance(self, factor, start_date: date, end_date: date) -> List: """ Retrieve a list of covariances between this factor and another for a range of dates """ covariance_data = [] # Collect matrix order for requested factor on all available dates query = DataQuery(where={ "riskModel": self.risk_model_id, "factorId": factor.factor.identifier }, start_date=start_date, end_date=end_date) factor_covariances = GsDataApi.execute_query( 'RISK_MODEL_COVARIANCE_MATRIX', query).get('data', []) matrix_order_map = { data['date']: data['matrixOrder'] for data in factor_covariances } # Collect covariances at relevant matrix order on all available dates query = DataQuery(where={ "riskModel": self.risk_model_id, "factorId": self.factor.identifier }, start_date=start_date, end_date=end_date) factor_covariances = GsDataApi.execute_query( 'RISK_MODEL_COVARIANCE_MATRIX', query).get('data', []) for data in factor_covariances: date = data['date'] if matrix_order_map.get(date): covariance_data.append({ 'date': date, 'covariance': data[str(matrix_order_map[date])] }) return covariance_data
def get_fundamentals( self, start: dt.date = DateLimit.LOW_LIMIT.value, end: dt.date = dt.date.today(), period: FundamentalMetricPeriod = FundamentalMetricPeriod.ONE_YEAR. value, direction: FundamentalMetricPeriodDirection = FundamentalMetricPeriodDirection. FORWARD.value, metrics: List[FundamentalsMetrics] = FundamentalsMetrics.to_list() ) -> pd.DataFrame: """ Retrieve fundamentals data for a basket across a date range :param start: start date (default minimum date value) :param end: end date (default is today) :param period: period for the relevant metric (default is 1y) :param direction: direction of the outlook period (default is forward) :param metrics: list of fundamentals metrics (default is all) :return: dataframe with fundamentals information **Usage** Retrieve fundamentals data for a basket across a date range **Examples** Retrieve historical dividend yield data for a basket >>> from gs_quant.markets.baskets import Basket >>> from gs_quant.markets.indices_utils import FundamentalsMetrics >>> >>> basket = Basket.get("GSMBXXXX") >>> basket.get_corporate_actions(metrics=[FundamentalsMetrics.DIVIDEND_YIELD]) **See also** :func:`get_corporate_actions` """ where = dict(assetId=self.id, period=period, periodDirection=direction, metric=metrics) query = DataQuery(where=where, start_date=start, end_date=end) response = GsDataApi.query_data( query=query, dataset_id=IndicesDatasets.BASKET_FUNDAMENTALS.value) return pd.DataFrame(response)
def get_fundamentals( self, start: dt.date = DateLimit.LOW_LIMIT.value, end: dt.date = dt.date.today(), period: DataMeasure = DataMeasure.ONE_YEAR.value, direction: DataMeasure = DataMeasure.FORWARD.value, metrics: List[DataMeasure] = DataMeasure.list_fundamentals() ) -> pd.DataFrame: """ Retrieve fundamentals data for an index across a date range. Currently supports STS indices only :param start: start date (default is 1 January, 1970) :param end: end date (default is today) :param period: period for the relevant metric. Can be one of ONE_YEAR('1y'), TWO_YEARS('2y'), \ THREE_YEARS('3y') (default is 1y) :param direction: direction of the outlook period. Can be one of 'forward' or 'trailing' (default is forward) :param metrics: list of fundamentals metrics. (default is all) :return: dataframe with fundamentals information **Usage** Retrieve fundamentals data for an index across a date range **Examples** Retrieve historical dividend yield data for an index >>> from gs_quant.markets.index import Index >>> from gs_quant.data.fields import DataMeasure >>> >>> index = Index.get("GSMBXXXX") >>> index.get_fundamentals(metrics=[DataMeasure.DIVIDEND_YIELD]) """ if self.__is_sts_index(): where = dict(assetId=self.id, period=period, periodDirection=direction, metric=metrics) query = DataQuery(where=where, start_date=start, end_date=end) response = GsDataApi.query_data( query=query, dataset_id=IndicesDatasets.STS_FUNDAMENTALS.value) return pd.DataFrame(response) else: raise MqValueError( 'This method currently supports STS indices only')
def get_results(dataset_id: str, response: Union[DataQueryResponse, dict], query: DataQuery) -> list: if isinstance(response, dict): total_pages = response.get('totalPages') results = response.get('data', ()) else: total_pages = response.total_pages if response.total_pages is not None else 0 results = response.data if response.data is not None else () if total_pages: if query.page is None: query.page = total_pages - 1 results = results + GsDataApi.get_results(dataset_id, GsDataApi.execute_query(dataset_id, query), query) elif query.page - 1 > 0: query.page -= 1 results = results + GsDataApi.get_results(dataset_id, GsDataApi.execute_query(dataset_id, query), query) else: return results return results
def test_auto_scroll_on_pages(mocker): response = { "requestId": "049de678-1480000", "totalPages": 5, "data": [{ "date": "2012-01-25", "assetId": "MADXKSGX6921CFNF", "value": 1 }] } mocker.patch.object(ContextMeta, 'current', return_value=GsSession(Environment.QA)) mocker.patch.object(ContextMeta.current, '_post', return_value=response) query = DataQuery(start_date=dt.date(2017, 1, 15), end_date=dt.date(2017, 1, 18), where=FieldFilterMap(currency="GBP")) response = GsDataApi.get_results("test", response, query) assert len(response) == 5
def get_thematic_beta(self, basket_identifier: str, start: dt.date = DateLimit.LOW_LIMIT.value, end: dt.date = dt.date.today()) -> pd.DataFrame: if not self.positioned_entity_type == EntityType.ASSET: raise NotImplementedError response = GsAssetApi.resolve_assets(identifier=[basket_identifier], fields=['id', 'type'], limit=1)[basket_identifier] _id, _type = get(response, '0.id'), get(response, '0.type') if len(response) == 0 or _id is None: raise MqValueError(f'Basket could not be found using identifier {basket_identifier}.') if _type not in BasketType.to_list(): raise MqValueError(f'Asset {basket_identifier} of type {_type} is not a Custom or Research Basket.') query = DataQuery(where={'assetId': self.id, 'basketId': _id}, start_date=start, end_date=end) response = GsDataApi.query_data(query=query, dataset_id=IndicesDatasets.COMPOSITE_THEMATIC_BETAS.value) df = [] for r in response: df.append({'date': r['date'], 'assetId': r['assetId'], 'basketId': r['basketId'], 'thematicBeta': r['beta']}) df = pd.DataFrame(df) return df.set_index('date')
def get_fundamentals( self, period: FundamentalMetricPeriod = FundamentalMetricPeriod.ONE_YEAR. value, direction: FundamentalMetricPeriodDirection = FundamentalMetricPeriodDirection. FORWARD.value, metrics: [FundamentalsMetrics] = FundamentalsMetrics.to_list(), start_date: dt.date = DateLimit.LOW_LIMIT.value, end_date: dt.date = DateLimit.TODAY.value) -> DataQueryResponse: if not self.id: self.__raise_initialization_error('retrieve fundamentals data') where = dict(assetId=self.id, period=period, periodDirection=direction, metric=metrics) query = DataQuery(where=where, start_date=start_date, end_date=end_date) return GsDataApi.query_data( query=query, dataset_id=IndicesDatasets.BASKET_FUNDAMENTALS.value)
def get_flagships_performance( fields: [str] = [], basket_type: List[BasketType] = BasketType.to_list(), asset_class: List[AssetClass] = [AssetClass.Equity], region: List[Region] = None, styles: List[Union[CustomBasketStyles, ResearchBasketStyles]] = None, start: dt.date = None, end: dt.date = None, ) -> pd.DataFrame: """ Retrieve performance data for flagship baskets :param fields: Fields to retrieve in addition to bbid, mqid, name, region, basket type, \ styles, live date, and asset class :param basket_type: Basket type(s) :param asset_class: Asset class (defaults to Equity) :param region: Basket region(s) :param styles: Basket style(s) :param start: Date for which to retrieve pricing (defaults to previous business day) :param end: Date for which to retrieve pricing (defaults to previous business day) :return: pricing data for flagship baskets **Usage** Retrieve performance data for flagship baskets **Examples** Retrieve performance data for flagship Asia custom baskets >>> from gs_quant.markets.indices_utils import * >>> >>> get_flagships_performance(basket_type=[BasketType.CUSTOM_BASKET], region=[Region.ASIA]) **See also** :func:`get_flagships_with_assets` :func:`get_flagship_baskets` :func:`get_flagships_constituents` """ start = start or prev_business_date() end = end or prev_business_date() fields = list( set(fields).union( set([ 'name', 'region', 'type', 'flagship', 'isPairBasket', 'styles', 'liveDate', 'assetClass' ]))) coverage = GsDataApi.get_coverage( dataset_id=IndicesDatasets.GSCB_FLAGSHIP.value, fields=fields) basket_regions = [] if region is None else [r.value for r in region] basket_styles = [] if styles is None else [s.value for s in styles] basket_types = [b_type.value for b_type in basket_type] baskets_map = {} for basket in coverage: if get(basket, 'flagship') is False or get(basket, 'isPairBasket') is True or \ region is not None and get(basket, 'region') not in basket_regions or \ get(basket, 'type') not in basket_types or \ get(basket, 'assetClass') not in [a.value for a in asset_class] or \ styles is not None and not any(s in get(basket, 'styles', []) for s in basket_styles): continue baskets_map[get(basket, 'assetId')] = basket response = GsDataApi.query_data( query=DataQuery(where=dict(assetId=list(baskets_map.keys())), startDate=start, endDate=end), dataset_id=IndicesDatasets.GSCB_FLAGSHIP.value) performance = [] for basket in response: basket_data = baskets_map[get(basket, 'assetId')] basket_data.update(closePrice=get(basket, 'closePrice')) basket_data.update(date=get(basket, 'date')) performance.append(basket_data) return pd.DataFrame(performance)
def get_flagships_constituents( fields: [str] = [], basket_type: List[BasketType] = BasketType.to_list(), asset_class: List[AssetClass] = [AssetClass.Equity], region: List[Region] = None, styles: List[Union[CustomBasketStyles, ResearchBasketStyles]] = None, start: dt.date = None, end: dt.date = None, ) -> pd.DataFrame: """ Retrieve flagship baskets constituents :param fields: Fields to retrieve in addition to mqid, name, ticker, region, basket type, \ styles, live date, and asset class :param basket_type: Basket type(s) :param asset_class: Asset class (defaults to Equity) :param region: Basket region(s) :param styles: Basket style(s) :param start: Start date for which to retrieve constituents (defaults to previous business day) :param end: End date for which to retrieve constituents (defaults to previous business day) :return: flagship baskets constituents **Usage** Retrieve flagship baskets constituents **Examples** Retrieve a list of flagship baskets constituents >>> from gs_quant.markets.indices_utils import * >>> >>> get_flagships_constituents() **See also** :func:`get_flagships_with_assets` :func:`get_flagships_performance` :func:`get_flagship_baskets` """ start = start or prev_business_date() end = end or prev_business_date() fields = list( set(fields).union( set([ 'id', 'name', 'ticker', 'region', 'type', 'styles', 'liveDate', 'assetClass' ]))) query = dict(fields=fields, type=basket_type, asset_class=asset_class, is_pair_basket=[False], flagship=[True]) if region is not None: query.update(region=region) if styles is not None: query.update(styles=styles) basket_data = GsAssetApi.get_many_assets_data_scroll(**query, limit=2000, scroll='1m') basket_map = {get(basket, 'id'): basket for basket in basket_data} coverage = GsDataApi.get_coverage( dataset_id=IndicesDatasets.GSCB_FLAGSHIP.value, fields=['type', 'bbid'], include_history=True) cbs, rbs = [], [] for b in coverage: _id = get(b, 'assetId') _type = get(b, 'type') if _id in list(basket_map.keys()): start_date = dt.datetime.strptime(b['historyStartDate'], '%Y-%m-%d').date() start_date = start_date if start < start_date else start if _type == BasketType.CUSTOM_BASKET.value: data = GsDataApi.query_data( query=DataQuery(where=dict(assetId=_id), startDate=start_date, endDate=end), dataset_id=IndicesDatasets.GSBASKETCONSTITUENTS.value) basket_map[_id].update(constituents=data) cbs.append(basket_map[_id]) elif _type == BasketType.RESEARCH_BASKET.value: data = GsDataApi.query_data( query=DataQuery(where=dict(assetId=_id), startDate=start_date, endDate=end), dataset_id=IndicesDatasets.GIRBASKETCONSTITUENTS.value) basket_map[_id].update(constituents=data) rbs.append(basket_map[_id]) return pd.DataFrame(cbs + rbs)