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)