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]]])
