def test_data_arrays_concat_on_tickers(self): ticker_1 = BloombergTicker("Example 1") ticker_2 = BloombergTicker("Example 2") fields = [PriceField.Open, PriceField.Close] index = date_range(start=str_to_date("2017-01-01"), periods=5, freq="D") index_1 = index[:3] data_1 = [[[4., 1.]], [[5., 2.]], [[6., 3.]]] data_array_1 = QFDataArray.create(index_1, [ticker_1], fields, data_1) self.assertEqual(np.dtype("float64"), data_array_1.dtype) index_2 = index[3:] data_2 = [[[np.nan, 10.]], [[np.nan, 14.]]] data_array_2 = QFDataArray.create(index_2, [ticker_2], fields, data_2) self.assertEqual(np.dtype("float64"), data_array_2.dtype) data = [[[4., 1.], [np.nan, np.nan]], [[5., 2.], [np.nan, np.nan]], [[6., 3.], [np.nan, np.nan]], [[np.nan, np.nan], [np.nan, 10.]], [[np.nan, np.nan], [np.nan, 14.]]] expected_data_array = QFDataArray.create(index, [ticker_1, ticker_2], fields, data) self.assertEqual(np.dtype("float64"), expected_data_array.dtype) concatenated_data_array = QFDataArray.concat( [data_array_1, data_array_2], dim=TICKERS) self.assertEqual(np.dtype("float64"), concatenated_data_array.dtype) assert_equal(expected_data_array, concatenated_data_array)
def setUp(self): 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' ]) data = [[[263.7628], [None], [111.02], [321.8249]], [[263.9803], [106.39], [121.29], [322.0949]], [[264.1640], [106.36], [121.22], [322.3203]], [[264.0932], [106.25], [121.05], [322.4172]], [[263.9816], [106.12], [120.95], [322.1411]], [[263.9816], [106.24], [121.05], [None]], [[264.4529], [106.28], [121.13], [None]], [[264.5108], [106.40], [121.07], [322.3553]], [[264.8223], [106.50], [121.10], [322.7489]], [[264.4531], [106.23], [121.31], [322.9710]], [[264.4690], [106.16], [121.14], [323.0688]], [[None], [106.06], [121.01], [323.1553]]] bloomberg = Mock(spec=BloombergDataProvider) bloomberg.get_price.return_value = QFDataArray.create( dates=datetime_index, tickers=self.BBG_TICKERS, fields=self.PRICE_FIELDS, data=data) bloomberg.supported_ticker_types.return_value = {BloombergTicker} quandl = Mock(spec=QuandlDataProvider) quandl.get_price.return_value = QFDataArray.create( dates=datetime_index, tickers=self.QUANDL_TICKERS, fields=self.PRICE_FIELDS, data=data) quandl.supported_ticker_types.return_value = {QuandlTicker} haver = Mock(spec=HaverDataProvider) haver.get_price.return_value = QFDataArray.create( dates=datetime_index, tickers=self.HAVER_TICKERS, fields=self.PRICE_FIELDS, data=data) haver.supported_ticker_types.return_value = {HaverTicker} ccy = Mock(spec=CryptoCurrencyDataProvider) ccy.get_price.return_value = QFDataArray.create( dates=datetime_index, tickers=self.CCY_TICKERS, fields=self.PRICE_FIELDS, data=data) ccy.supported_ticker_types.return_value = {CcyTicker} self.price_provider = GeneralPriceProvider(bloomberg, quandl, haver, ccy)
def tickers_dict_to_data_array(tickers_data_dict: Dict[Ticker, QFDataFrame], requested_tickers: Union[Ticker, Sequence[Ticker]], requested_fields) -> QFDataArray: """ Converts a dictionary mapping tickers to DateFrame onto a QFDataArray. Parameters ---------- tickers_data_dict: Dict[Ticker, QFDataFrame] Ticker -> QFDataFrame[dates, fields] requested_tickers: Sequence[Ticker] requested_fields Returns ------- QFDataArray """ # return empty xr.DataArray if there is no data to be converted requested_tickers, _ = convert_to_list(requested_tickers, Ticker) if not tickers_data_dict: return QFDataArray.create(dates=[], tickers=requested_tickers, fields=requested_fields) tickers = [] data_arrays = [] for ticker, df in tickers_data_dict.items(): df.index.name = DATES if df.empty: # if there is no data for a given ticker, skip it (proper column will be added afterwards anyway) continue data_array = df.to_xarray() data_array = data_array.to_array(dim=FIELDS, name=ticker) data_array = data_array.transpose(DATES, FIELDS) tickers.append(ticker) data_arrays.append(data_array) tickers_index = pd.Index(tickers, name=TICKERS) if not data_arrays: return QFDataArray.create(dates=[], tickers=requested_tickers, fields=requested_fields) result = QFDataArray.concat(data_arrays, dim=tickers_index) if len(tickers) < len(requested_tickers): result = result.reindex(tickers=requested_tickers, fields=requested_fields) # the DataArray gets a name after the first ticker in the tickers_data_dict.keys() which is incorrect; # it should have no name result.name = None return result
def _create_price_provider_mock(self, tickers): mock_data_array = QFDataArray.create( dates=date_range(start='2009-12-28', end='2009-12-30', freq='D'), tickers=tickers, fields=PriceField.ohlcv(), data=[ # 2009-12-28 [ # Open High Low Close Volume [25.0, 25.1, 25.2, 26.0, 25.3], # MSFT [27.0, 27.1, 27.2, 28.0, 27.3] # AAPL ], # 2009-12-29 [ # Open High Low Close Volume [None, None, None, None, None], # MSFT [29.0, 29.1, 29.2, 30.0, 29.3] # AAPL ], # 2009-12-30 [ # Open High Low Close Volume [31.0, 31.1, 31.2, 32.0, 31.3], # MSFT [None, None, None, None, None] # AAPL ] ]) price_data_provider_mock = Mock(spec=DataProvider, frequency=Frequency.DAILY) price_data_provider_mock.get_price.side_effect = lambda t, fields, start_time, end_time, frequency: \ mock_data_array.loc[start_time:end_time, t, fields].to_pandas() return price_data_provider_mock
def _get_data_for_multiple_tickers(self, tickers, fields, start_date, end_date, use_prices_types): if use_prices_types: type_of_field = PriceField def get_data_func(data_prov: DataProvider, tickers_for_single_data_provider): prices = data_prov.get_price(tickers_for_single_data_provider, fields, start_date, end_date) return prices else: type_of_field = str def get_data_func(data_prov: DataProvider, tickers_for_single_data_provider): prices = data_prov.get_history(tickers_for_single_data_provider, fields, start_date, end_date) return prices tickers, got_single_ticker = convert_to_list(tickers, Ticker) fields, got_single_field = convert_to_list(fields, type_of_field) got_single_date = start_date is not None and (start_date == end_date) partial_results = [] for ticker_class, ticker_group in groupby(tickers, lambda t: type(t)): data_provider = self._identify_data_provider(ticker_class) partial_result = get_data_func(data_provider, list(ticker_group)) if partial_result is not None: partial_results.append(partial_result) result = QFDataArray.concat(partial_results, dim=TICKERS) normalized_result = normalize_data_array( result, tickers, fields, got_single_date, got_single_ticker, got_single_field, use_prices_types) return normalized_result
def _data_array_to_dataframe(self, prices_data_array: QFDataArray, frequency: Frequency): """ Converts a QFDataArray into a DataFrame by removing the "Price Field" axis. Every index (e.g. 15:00) denotes the close price of the time range beginning at this time (15:00 - 15:01) The only exception is the time range 1 minute before market open (e.g. 9:29 - 9:30 if market opens 9:30). The price for this time range, denotes the OPEN price of 9:30 - 9:31. """ original_dates = list(prices_data_array.dates.to_index()) dates = prices_data_array.resample(dates='1D').first().dates.to_index() market_open_datetimes = [ price_datetime + MarketOpenEvent.trigger_time() for price_datetime in dates if price_datetime + MarketOpenEvent.trigger_time() in original_dates ] shifted_open_datetimes = [ price_datetime - frequency.time_delta() for price_datetime in market_open_datetimes ] new_dates = list(set(original_dates + shifted_open_datetimes)) new_dates = sorted(new_dates) prices_df = PricesDataFrame(index=new_dates, columns=prices_data_array.tickers) prices_df.loc[shifted_open_datetimes, :] = \ prices_data_array.loc[market_open_datetimes, :, PriceField.Open].values prices_df.loc[original_dates, :] = prices_data_array.loc[ original_dates, :, PriceField.Close].values return prices_df
def test_tickers_dict_to_data_array(self): ticker_1 = BloombergTicker("Example 1") ticker_2 = BloombergTicker("Example 2") fields = [PriceField.Open, PriceField.Close] index = self.index[:3] data = [[[4., 1.], [nan, 5.]], [[5., 2.], [nan, 7.]], [[6., 3.], [nan, 8.]]] prices_df_1 = QFDataFrame(data={ PriceField.Close: [1., 2., 3.], PriceField.Open: [4., 5., 6.] }, index=index) prices_df_2 = QFDataFrame(data={PriceField.Close: [5., 7., 8.]}, index=index) data_array = tickers_dict_to_data_array( { ticker_1: prices_df_1, ticker_2: prices_df_2 }, [ticker_1, ticker_2], fields) self.assertEqual(dtype("float64"), data_array.dtype) expected_data_array = QFDataArray.create(index, [ticker_1, ticker_2], fields, data) assert_equal(data_array, expected_data_array)
def _make_mock_data_array(self, tickers, fields): all_dates_market_open = pd.date_range( start=self.data_start_date + MarketOpenEvent.trigger_time(), end=self.data_end_date + MarketOpenEvent.trigger_time(), freq="B") all_dates_market_close = pd.date_range( start=self.data_start_date + MarketCloseEvent.trigger_time() - Frequency.MIN_1.time_delta(), end=self.data_end_date + MarketCloseEvent.trigger_time() - Frequency.MIN_1.time_delta(), freq="B") num_of_dates = len(all_dates_market_open) num_of_tickers = len(tickers) num_of_fields = len(fields) start_value = 100.0 values = np.arange( start_value, num_of_dates * num_of_tickers * num_of_fields + start_value) reshaped_values = np.reshape( values, (num_of_dates, num_of_tickers, num_of_fields)) mocked_result_market_open = QFDataArray.create(all_dates_market_open, tickers, fields, data=reshaped_values) mocked_result_market_close = QFDataArray.create(all_dates_market_close, tickers, fields, data=reshaped_values) mocked_result_market_close.loc[:, :, PriceField.Low] -= 5.0 mocked_result_market_close.loc[:, :, PriceField.High] += 5.0 all_dates = all_dates_market_open.union(all_dates_market_close) mocked_result = QFDataArray.create(all_dates, tickers, fields) mocked_result.loc[ all_dates_market_open, :, :] = mocked_result_market_open.loc[:, :, :] mocked_result.loc[ all_dates_market_close, :, :] = mocked_result_market_close.loc[:, :, :] self._add_test_cases(mocked_result, tickers) return mocked_result
def mock_data_provider(self) -> DataProvider: data_provider = Mock(spec=DataProvider) data_provider.get_price.return_value = QFDataArray.create( data=np.full((len(self.cached_dates_idx), len( self.cached_tickers), len(self.cached_fields)), 0), dates=self.cached_dates_idx, tickers=self.cached_tickers, fields=self.cached_fields) data_provider.get_futures_chain_tickers.return_value = dict() return data_provider
def _get_sample_data_array(cls, dates, tickers, fields): num_of_dates = len(dates) num_of_tickers = len(tickers) num_of_fields = len(fields) sample_data = [float(i) for i in range(num_of_dates * num_of_tickers * num_of_fields)] sample_3d_data = np.reshape(sample_data, (num_of_dates, num_of_tickers, num_of_fields)) sample_data_array = QFDataArray.create(dates, tickers, fields, sample_3d_data) return sample_data_array
def cast_data_array_to_proper_type(result: QFDataArray, use_prices_types=False): if use_prices_types: series_type = PricesSeries data_frame_type = PricesDataFrame else: series_type = QFSeries data_frame_type = QFDataFrame num_of_dimensions = len(result.shape) if num_of_dimensions == 0: casted_result = result.item() elif num_of_dimensions == 1: casted_result = cast_series(result.to_pandas(), series_type) casted_result.name = result.name elif num_of_dimensions == 2: casted_result = cast_dataframe(result.to_pandas(), data_frame_type) else: casted_result = result return casted_result
def _remove_unnecessary_data( self, real_contracts_prices_da: QFDataArray, rolling_dates: pd.DatetimeIndex) -> PricesDataFrame: """ Removes data which isn't necessary for calculating the rolling series from real contracts dataframe and returns the dataframe without unnecessary data. """ real_contracts_prices_da = real_contracts_prices_da.loc[ rolling_dates[0]:rolling_dates[-1], :, :] # drop all the dates where everything for that date is NaN (all tickers and all fields) real_contracts_prices_da = real_contracts_prices_da.dropna(dim=DATES, how='all') return real_contracts_prices_da
def _make_mock_data_array(cls, tickers, fields): all_dates_index = pd.bdate_range(start=cls.data_start_date, end=cls.test_end_date) num_of_dates = len(all_dates_index) num_of_tickers = len(tickers) num_of_fields = len(fields) start_value = 100.0 values = np.arange(start_value, num_of_dates * num_of_tickers * num_of_fields + start_value) reshaped_values = np.reshape(values, (num_of_dates, num_of_tickers, num_of_fields)) mocked_result = QFDataArray.create(all_dates_index, tickers, fields, data=reshaped_values) mocked_result.loc[:, :, PriceField.Low] -= 50.0 mocked_result.loc[:, :, PriceField.High] += 50.0 return mocked_result
def _aggregate_intraday_data(self, data_array, start_date: datetime, end_date: datetime, tickers: Sequence[Ticker], fields, frequency: Frequency): """ Function, which aggregates the intraday data array for various dates and returns a new data array with data sampled with the given frequency. """ # If the data is of intraday data type, which spans over multiple days, the base parameter of resample() # function should be adjusted differently for the first day. # # Therefore, the data array is divided into two separate arrays data_array_1, data_array_2 - first containing # only the first day, and the second one - containing all other dates. end_of_day = start_date + RelativeDelta(hour=23, minute=59, second=59) _end_date = end_of_day if (end_of_day < end_date) else end_date # Get both parts of the data array data_array_1 = data_array.loc[start_date:_end_date, :, :] data_array_2 = data_array.loc[end_of_day:end_date, :, :] if len(data_array_1) > 0: base_data_array_1 = pd.to_datetime( data_array_1[DATES].values[0]).minute data_array_1 = data_array_1.resample( dates=frequency.to_pandas_freq(), base=base_data_array_1, label='left', skipna=True).apply( lambda x: self._aggregate_data_array(x, tickers, fields)) if len(data_array_2) > 0: base_data_array_2 = MarketOpenEvent.trigger_time().minute data_array_2 = data_array_2.resample( dates=frequency.to_pandas_freq(), base=base_data_array_2, label='left', skipna=True).apply( lambda x: self._aggregate_data_array(x, tickers, fields)) data_array = QFDataArray.concat([data_array_1, data_array_2], dim=DATES) return data_array
def _acquire_data(input_file: str): data_frame = read_csv(input_file, parse_dates=['dates']) # The data_frame contains following headers: dates, open, high, low, close, volume, ticker. dates = data_frame['dates'].drop_duplicates() tickers = [DummyTicker(t) for t in data_frame['tickers'].unique()] # The columns in the csv file are in the exactly same order as the corresponding fields in the list below fields = PriceField.ohlcv() # Create a data array data_array = data_frame.set_index(['dates', 'tickers']).stack().to_xarray() # Construct a QFDataArray based on the data_array and sort it by the 'dates' coordinate data = QFDataArray.create(dates=dates, tickers=tickers, fields=fields, data=data_array).sortby('dates') start_date = dates.iloc[0] end_date = dates.iloc[-1] return data, start_date, end_date
def _create_price_provider_mock(tickers, price_fields): mock_data_array = QFDataArray.create( dates=date_range(start='2009-12-28', end='2009-12-30', freq='D'), tickers=tickers, fields=price_fields, data=[ # 2009-12-28 [ # Open High Low Close Volume [25.0, 25.1, 25.2, 26.0, 25.3], # MSFT [27.0, 27.1, 27.2, 28.0, 27.3] # AAPL ], # 2009-12-29 [ # Open High Low Close Volume [None, None, None, None, None], # MSFT [29.0, 29.1, 29.2, 30.0, 29.3] # AAPL ], # 2009-12-30 [ # Open High Low Close Volume [31.0, 31.1, 31.2, 32.0, 31.3], # MSFT [None, None, None, None, None] # AAPL ] ]) price_data_provider_mock = mock(strict=True) # type: GeneralPriceProvider when(price_data_provider_mock).get_price( tickers, [PriceField.Open, PriceField.Close], ANY(datetime), ANY(datetime)).thenReturn( mock_data_array.loc[:, :, [PriceField.Open, PriceField.Close]]) when(price_data_provider_mock).get_price( tickers, price_fields, ANY(datetime), ANY(datetime)).thenReturn(mock_data_array) return price_data_provider_mock
def _mock_data_provider(self): dates_index = pd.bdate_range(start=self.prices_start_date, end=self.test_end_date) fields_number = len(self.fields) tickers = [ BloombergTicker("MSFT US Equity"), BloombergTicker("AUDUSD Curncy"), BloombergTicker( "HOZ9 Comdty"), # Mock three contracts for Heating Oil BloombergTicker("HOF0 Comdty"), BloombergTicker("HOG0 Comdty"), ] # Mock price data array values = [ [ # 02-01-2020 # MSFT US Equity, AUDUSD Curncy, Heating Oil (3 contracts) prices [90], [90], [90], [90], [90] ], [ # 03-01-2020 [95], [95], [85], [100], [85] ], [ # 06-01-2020 [110], [100], [90], [100], [90] # The Heating Oil contract will create an open position ], [ # 07-01-2020 [90], [110], [95], [np.nan], [ 95 ] # Rolling for Heating Oil occurs, new Heating Oil contract is bought ], [ # 08-01-2020 [80], [120], [100], [100], [ 100 ] # Previous Heating Oil is sold (there was no price on the 7th) ], [ # 09-01-2020 [80], [120], [100], [100], [100] ], ] # Open, High, Low and Close prices are equal every day values = [[price * fields_number for price in day_prices] for day_prices in values] mocked_prices = QFDataArray.create(dates_index, tickers, self.fields, data=values) # Mock expiration dates exp_dates = { BloombergFutureTicker("Heating Oil", "HO{} Comdty", 1, 1, 100): QFDataFrame(data={ ExpirationDateField.FirstNotice: [ str_to_date("2019-12-01"), str_to_date("2020-01-07"), str_to_date("2020-02-03") ], ExpirationDateField.LastTradeableDate: [ str_to_date("2019-12-01"), str_to_date("2020-01-07"), str_to_date("2020-02-03") ], }, index=[ BloombergTicker("HOZ9 Comdty"), BloombergTicker("HOF0 Comdty"), BloombergTicker("HOG0 Comdty") ]) } return PresetDataProvider(data=mocked_prices, exp_dates=exp_dates, start_date=str_to_date("2019-12-01"), end_date=self.test_end_date, frequency=self.frequency)
def setUp(self): 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' ]) data = [[[263.7628], [None], [111.02], [321.8249]], [[263.9803], [106.39], [121.29], [322.0949]], [[264.1640], [106.36], [121.22], [322.3203]], [[264.0932], [106.25], [121.05], [322.4172]], [[263.9816], [106.12], [120.95], [322.1411]], [[263.9816], [106.24], [121.05], [None]], [[264.4529], [106.28], [121.13], [None]], [[264.5108], [106.40], [121.07], [322.3553]], [[264.8223], [106.50], [121.10], [322.7489]], [[264.4531], [106.23], [121.31], [322.9710]], [[264.4690], [106.16], [121.14], [323.0688]], [[None], [106.06], [121.01], [323.1553]]] bloomberg = mock(strict=True) when(bloomberg)\ .get_price(self.BBG_TICKERS, self.PRICE_FIELDS, self.START_DATE, self.END_DATE)\ .thenReturn( QFDataArray.create(dates=datetime_index, tickers=self.BBG_TICKERS, fields=self.PRICE_FIELDS, data=data) ) when(bloomberg).supported_ticker_types().thenReturn({BloombergTicker}) quandl = mock(strict=True) when(quandl)\ .get_price(self.QUANDL_TICKERS, self.PRICE_FIELDS, self.START_DATE, self.END_DATE)\ .thenReturn( QFDataArray.create( dates=datetime_index, tickers=self.QUANDL_TICKERS, fields=self.PRICE_FIELDS, data=data ) ) when(quandl).supported_ticker_types().thenReturn({QuandlTicker}) haver = mock(strict=True) when(haver)\ .get_price(self.HAVER_TICKERS, self.PRICE_FIELDS, self.START_DATE, self.END_DATE) \ .thenReturn( QFDataArray.create( dates=datetime_index, tickers=self.HAVER_TICKERS, fields=self.PRICE_FIELDS, data=data ) ) when(haver).supported_ticker_types().thenReturn({HaverTicker}) ccy = mock(strict=True) when(ccy)\ .get_price(self.CCY_TICKERS, self.PRICE_FIELDS, self.START_DATE, self.END_DATE) \ .thenReturn( QFDataArray.create( dates=datetime_index, tickers=self.CCY_TICKERS, fields=self.PRICE_FIELDS, data=data ) ) when(ccy).supported_ticker_types().thenReturn({CcyTicker}) self.price_provider = GeneralPriceProvider(bloomberg, quandl, haver, ccy)
def _mock_get_price(self, tickers, fields, start_date, end_date, frequency): tickers, got_single_ticker = convert_to_list(tickers, Ticker) fields, got_single_field = convert_to_list(fields, PriceField) mock_daily_data = QFDataArray.create( dates=date_range(start='2021-05-01', end='2021-05-06', freq='D'), tickers=[self.ticker_1, self.ticker_2], fields=PriceField.ohlcv(), data=[ # 2021-05-01 [ # Open High Low Close Volume [25.0, 25.1, 25.2, 26.0, 25.3], # TICKER 1 [27.0, 27.1, 27.2, 28.0, 27.3] # TICKER 2 ], # 2021-05-02 [ # Open High Low Close Volume [None, None, None, None, None], # TICKER 1 [29.0, 29.1, 29.2, 30.0, 29.3] # TICKER 2 ], # 2021-05-03 [ # Open High Low Close Volume [31.0, 31.1, 31.2, 32.0, 31.3], # TICKER 1 [None, None, None, None, None] # TICKER 2 ], # 2021-05-04 [ # Open High Low Close Volume [31.0, None, None, None, None], # TICKER 1 [None, None, None, None, None] # TICKER 2 ], # 2021-05-05 [ # Open High Low Close Volume [25.0, 25.1, 25.2, None, 25.3], # TICKER 1 [27.0, 27.1, 27.2, None, 27.3] # TICKER 2 ], # 2021-05-06 [ # Open High Low Close Volume [None, None, None, None, None], # TICKER 1 [None, None, None, None, None] # TICKER 2 ], ]) mock_intraday_data = QFDataArray.create( dates=date_range(start='2021-05-01', end='2021-05-06', freq='D'), tickers=[self.ticker_1, self.ticker_2], fields=PriceField.ohlcv(), data=[ # 2021-05-01 [ # Open High Low Close Volume [25.0, 25.1, 25.2, 26.0, 25.3], # TICKER 1 [27.0, 27.1, 27.2, 28.0, 27.3] # TICKER 2 ], # 2021-05-02 [ # Open High Low Close Volume [None, None, None, None, None], # TICKER 1 [29.0, 29.1, 29.2, 30.0, 29.3] # TICKER 2 ], # 2021-05-03 [ # Open High Low Close Volume [31.0, 31.1, 31.2, 32.0, 31.3], # TICKER 1 [None, None, None, None, None] # TICKER 2 ], # 2021-05-04 [ # Open High Low Close Volume [31.0, None, None, None, None], # TICKER 1 [None, None, None, None, None] # TICKER 2 ], # 2021-05-05 [ # Open High Low Close Volume [25.0, 25.1, 25.2, None, 25.3], # TICKER 1 [27.0, 27.1, 27.2, None, 27.3] # TICKER 2 ], # 2021-05-06 [ # Open High Low Close Volume [None, None, None, None, None], # TICKER 1 [None, None, None, None, None] # TICKER 2 ], ]) data = mock_daily_data.loc[start_date:end_date, tickers, fields] if frequency == Frequency.DAILY else \ mock_intraday_data.loc[start_date:end_date, tickers, fields] return normalize_data_array(data, tickers, fields, False, got_single_ticker, got_single_field, True)
def _set_bar_for_today(self, open_price, high_price, low_price, close_price, volume): self.data_handler.get_price.side_effect = lambda tickers, fields, start_date, end_date, frequency: \ QFDataArray.create(tickers=tickers, fields=fields, dates=date_range(start_date, end_date, freq=frequency.to_pandas_freq()), data=[[[nan, nan, nan, nan, nan]], [[open_price, high_price, low_price, close_price, volume]]])