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)
