def _receive_reference_response(self, tickers, fields):
response_events = get_response_events(self._session)
tickers_fields_container = pd.DataFrame(index=tickers, columns=fields)
for ev in response_events:
check_event_for_errors(ev)
security_data_array = extract_security_data(ev)
check_security_data_for_errors(security_data_array)
for i in range(security_data_array.numValues()):
security_data = security_data_array.getValueAsElement(i)
check_security_data_for_errors(security_data)
security_name = security_data.getElementAsString(SECURITY)
ticker = BloombergTicker.from_string(security_name)
field_data_array = security_data.getElement(FIELD_DATA)
for field_name in fields:
try:
value = field_data_array.getElementAsFloat(field_name)
except blpapi.exception.InvalidConversionException:
value = field_data_array.getElementAsString(field_name)
except blpapi.exception.NotFoundException:
value = np.nan
tickers_fields_container.loc[ticker, field_name] = value
return tickers_fields_container
def get_random_specific_ticker(self) -> BloombergTicker:
"""
Returns sample ticker from the family id that can be used in Bloomberg to get further data (future chain members
for example).
Returns
-------
BloombergTicker
"""
seed = next(self._random_contract_codes)
specific_ticker_string = self.family_id.format(seed)
return BloombergTicker.from_string(specific_ticker_string)
def _receive_historical_response(self, requested_tickers,
requested_fields):
response_events = get_response_events(self._session)
# mapping: ticker -> DataArray[dates, fields]
tickers_data_dict = dict() # type: Dict[BloombergTicker, pd.DataFrame]
for event in response_events:
check_event_for_errors(event)
security_data = extract_security_data(event)
security_name = security_data.getElementAsString(SECURITY)
ticker = BloombergTicker.from_string(security_name)
try:
check_security_data_for_errors(security_data)
field_data_array = security_data.getElement(FIELD_DATA)
field_data_list = [
field_data_array.getValueAsElement(i)
for i in range(field_data_array.numValues())
]
dates = [
pd.to_datetime(x.getElementAsDatetime(DATE))
for x in field_data_list
]
data = np.empty((len(dates), len(requested_fields)))
data[:] = np.nan
dates_fields_values = pd.DataFrame(data,
index=dates,
columns=requested_fields)
for field_name in requested_fields:
dates_fields_values.loc[:, field_name] = [
self._get_float_or_nan(data_of_date_elem, field_name)
for data_of_date_elem in field_data_list
]
tickers_data_dict[ticker] = dates_fields_values
except BloombergError:
self.logger.exception(
"Error in the received historical response")
return tickers_dict_to_data_array(tickers_data_dict, requested_tickers,
requested_fields)
def setUpClass(cls):
cls.start_date = str_to_date("2017-10-01")
cls.end_date = str_to_date("2017-11-01")
cls.frequency = Frequency.DAILY
datetime_index = pd.DatetimeIndex([
'2017-10-02', '2017-10-03', '2017-10-04', '2017-10-05', '2017-10-06',
'2017-10-09', '2017-10-10', '2017-10-11', '2017-10-12', '2017-10-13',
'2017-10-16', '2017-10-17', '2017-10-18', '2017-10-19', '2017-10-20',
'2017-10-23', '2017-10-24', '2017-10-25', '2017-10-26', '2017-10-27',
'2017-10-30', '2017-10-31', '2017-11-01'
])
bbg_data_provider = Mock(spec=BloombergDataProvider)
all_tickers_str = ['BCIT3T Index', 'IEF US Equity', 'LQD US Equity', 'MSBIERTR Index', 'MXUS Index',
'SPGSCITR Index', 'XAU Curncy']
all_tickers = BloombergTicker.from_string(all_tickers_str)
assets_prices_df = PricesDataFrame(index=datetime_index, columns=all_tickers, data=[
[263.7628, 106.24, 121.02, 321.8249, 2409.48, 2295.60, 1271.13],
[263.9803, 106.39, 121.29, 322.0949, 2414.41, 2294.91, 1271.66],
[264.1640, 106.36, 121.22, 322.3203, 2417.31, 2294.28, 1274.85],
[264.0932, 106.25, 121.05, 322.4172, 2430.80, 2323.34, 1268.22],
[263.9816, 106.12, 120.95, 322.1411, 2428.16, 2282.24, 1276.68],
[263.9816, 106.24, 121.05, None, 2423.41, 2284.78, 1284.05],
[264.4529, 106.28, 121.13, 322.3113, 2428.73, 2318.99, 1288.03],
[264.5108, 106.40, 121.07, 322.3553, 2433.09, 2324.63, 1291.72],
[264.8223, 106.50, 121.10, 322.7489, 2428.89, 2314.78, 1293.72],
[264.9401, 106.86, 121.58, 322.8720, 2430.63, 2342.19, 1303.82],
[264.2089, 106.68, 121.41, 322.8467, 2434.66, 2353.20, 1295.79],
[264.0592, 106.64, 121.39, 323.1079, 2436.35, 2345.04, 1285.12],
[263.9370, 106.37, 121.21, 323.2238, 2438.08, 2345.57, 1281.08],
[264.0463, 106.48, 121.39, 323.5498, 2439.31, 2332.31, 1290.13],
[263.8424, 106.04, 121.06, 322.9874, 2451.70, 2340.26, 1280.47],
[263.8961, 106.14, 121.18, 322.7436, 2441.71, 2343.72, 1282.27],
[263.7129, 105.82, 120.88, 322.3214, 2445.61, 2366.00, 1276.58],
[263.3216, 105.65, 120.56, 322.4332, 2434.13, 2364.23, 1277.53],
[263.3638, 105.51, 120.55, 322.1635, 2438.07, 2376.52, 1266.99],
[263.8662, 105.85, 120.91, 322.3655, 2457.45, 2396.93, 1273.35],
[264.4531, 106.23, 121.31, 322.9710, 2449.20, 2407.43, 1276.29],
[264.4690, 106.16, 121.14, 323.0688, 2452.15, 2415.28, 1271.45],
[264.4727, 106.06, 121.01, 323.1553, 2455.70, 2415.48, 1274.66]
])
bbg_data_provider.get_price.return_value = assets_prices_df
cls.bbg_data_provider = bbg_data_provider
def _get_intraday_data(self, ref_data_service, tickers, fields, start_date,
end_date, frequency):
"""
Sends requests for each ticker and combines the outputs together.
"""
tickers_data_dict = dict()
for ticker_str in tickers:
request = ref_data_service.createRequest("IntradayBarRequest")
self._set_intraday_time_period(request, start_date, end_date,
frequency)
set_ticker(request, ticker_str)
self._session.sendRequest(request)
ticker = BloombergTicker.from_string(ticker_str)
tickers_data_dict[ticker] = self._receive_intraday_response(
ticker, fields)
return tickers_dict_to_data_array(tickers_data_dict, tickers, fields)
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
def tickers_from_strings(
tickers_strings: List[str]) -> List[BloombergTicker]:
return [
BloombergTicker.from_string(ticker)
for ticker in tickers_strings
]
def tickers_from_strings(tickers_strings: List[str], security_type: SecurityType, point_value: int) \
-> List[BloombergTicker]:
return [BloombergTicker.from_string(ticker, security_type, point_value) for ticker in tickers_strings]
def get_active_ticker(self) -> BloombergTicker:
""" Returns the active ticker. """
specific_ticker_string = self.family_id.format("A")
return BloombergTicker.from_string(specific_ticker_string)
def get_active_ticker(self) -> BloombergTicker:
""" Returns the active ticker. """
specific_ticker_string = self.family_id.format("A")
return BloombergTicker.from_string(specific_ticker_string,
self.security_type,
self.point_value)
