def get_tabular_data(self, ticker: BloombergTicker, field: str) -> List:
"""
Provides current tabular data from Bloomberg.
Was tested on 'INDX_MEMBERS' and 'MERGERS_AND_ACQUISITIONS' requests. There is no guarantee that
all other request will be handled, as returned data structures might vary.
Parameters
-----------
ticker: BloombergTicker
ticker for security that should be retrieved
field: str
field of security that should be retrieved
Returns
-------
List
tabular data for the given ticker and field
"""
if field is None:
raise ValueError("Field being None is not supported by {}".format(
self.__class__.__name__))
self._connect_if_needed()
self._assert_is_connected()
tickers, got_single_ticker = convert_to_list(ticker, BloombergTicker)
fields, got_single_field = convert_to_list(field, (PriceField, str))
tickers_str = tickers_as_strings(tickers)
result = self._tabular_data_provider.get(tickers_str, fields)
return result
def get_history(
self, tickers: Union[BloombergTicker, Sequence[BloombergTicker]], fields: Union[str, Sequence[str]],
start_date: datetime, end_date: datetime = None, frequency: Frequency = Frequency.DAILY,
currency: str = None,
override_name: str = None, override_value: str = None) \
-> Union[QFSeries, QFDataFrame, QFDataArray]:
if fields is None:
raise ValueError("Fields being None is not supported by {}".format(self.__class__.__name__))
self._connect_if_needed()
self._assert_is_connected()
got_single_date = start_date is not None and (start_date == end_date)
tickers, got_single_ticker = convert_to_list(tickers, BloombergTicker)
fields, got_single_field = convert_to_list(fields, (PriceField, str))
if end_date is None:
end_date = datetime.now()
tickers_str = tickers_as_strings(tickers)
data_array = self._historical_data_provider.get(
tickers_str, fields, start_date, end_date, frequency, currency, override_name, override_value)
normalized_result = normalize_data_array(
data_array, tickers, fields, got_single_date, got_single_ticker, got_single_field)
return normalized_result
def get_current_values(
self, tickers: Union[BloombergTicker, Sequence[BloombergTicker]], fields: Union[str, Sequence[str]]) \
-> Union[None, float, QFSeries, QFDataFrame]:
"""
Gets the current values of fields for given tickers.
Parameters
----------
tickers: BloombergTicker, Sequence[BloombergTicker]
tickers for securities which should be retrieved
fields: str, Sequence[str]
fields of securities which should be retrieved
Returns
-------
QFDataFrame/QFSeries
Either QFDataFrame with 2 dimensions: ticker, field or QFSeries with 1 dimensions: ticker of field
(depending if many tickers or fields was provided) is returned.
Raises
-------
BloombergError
When couldn't get the data from Bloomberg Service
"""
self._connect_if_needed()
self._assert_is_connected()
tickers, got_single_ticker = convert_to_list(tickers, BloombergTicker)
fields, got_single_field = convert_to_list(fields, (PriceField, str))
tickers_str = tickers_as_strings(tickers)
data_frame = self._reference_data_provider.get(tickers_str, fields)
# to keep the order of tickers and fields we reindex the data frame
data_frame = data_frame.reindex(index=tickers, columns=fields)
# squeeze unused dimensions
tickers_indices = 0 if got_single_ticker else slice(None)
fields_indices = 0 if got_single_field else slice(None)
squeezed_result = data_frame.iloc[tickers_indices, fields_indices]
casted_result = cast_dataframe_to_proper_type(squeezed_result)
return casted_result
def get_history(
self, tickers: Union[BloombergTicker, Sequence[BloombergTicker]], fields: Union[str, Sequence[str]],
start_date: datetime, end_date: datetime = None, frequency: Frequency = Frequency.DAILY,
currency: str = None,
override_name: str = None, override_value: str = None) \
-> Union[QFSeries, QFDataFrame, QFDataArray]:
"""
Gets historical data from Bloomberg from the (start_date - end_date) time range. In case of frequency, which is
higher than daily frequency (intraday data), the data is indexed by the start_date. E.g. Time range: 8:00 - 8:01,
frequency: 1 minute - indexed with the 8:00 timestamp
Parameters
----------
tickers: Ticker, Sequence[Ticker]
tickers for securities which should be retrieved
fields: None, str, Sequence[str]
fields of securities which should be retrieved. If None, all available fields will be returned
(only supported by few DataProviders)
start_date: datetime
date representing the beginning of historical period from which data should be retrieved
end_date: datetime
date representing the end of historical period from which data should be retrieved;
if no end_date was provided, by default the current date will be used
frequency: Frequency
frequency of the data
currency: str
override_name: str
override_value: str
Returns
-------
QFSeries, QFDataFrame, QFDataArray
If possible the result will be squeezed, so that instead of returning QFDataArray, data of lower
dimensionality will be returned. The results will be either an QFDataArray (with 3 dimensions: date, ticker,
field), a QFDataFrame (with 2 dimensions: date, ticker or field; it is also possible to get 2 dimensions
ticker and field if single date was provided) or QFSeries (with 1 dimensions: date).
If no data is available in the database or an non existing ticker was provided an empty structure
(QFSeries, QFDataFrame or QFDataArray) will be returned returned.
"""
if fields is None:
raise ValueError("Fields being None is not supported by {}".format(
self.__class__.__name__))
self._connect_if_needed()
self._assert_is_connected()
if end_date is None:
end_date = datetime.now()
got_single_date = start_date is not None and ((
start_date == end_date) if frequency <= Frequency.DAILY else False)
tickers, got_single_ticker = convert_to_list(tickers, BloombergTicker)
fields, got_single_field = convert_to_list(fields, (PriceField, str))
tickers_mapping = {
BloombergTicker.from_string(t.as_string()): t
for t in tickers
}
tickers_str = tickers_as_strings(tickers)
data_array = self._historical_data_provider.get(
tickers_str, fields, start_date, end_date, frequency, currency,
override_name, override_value)
# Map each of the tickers in data array with corresponding ticker from tickers_mapping dictionary
def _map_ticker(ticker):
try:
return tickers_mapping[ticker]
except KeyError:
return ticker
data_array.tickers.values = [
_map_ticker(t) for t in data_array.tickers.values
]
normalized_result = normalize_data_array(data_array, tickers, fields,
got_single_date,
got_single_ticker,
got_single_field)
return normalized_result
