def test_spot_price_is_adjusted_if_needed(self): # on cls.days[1], the first 9 minutes of ILLIQUID_SPLIT_ASSET are # missing. let's get them. day0_minutes = self.env.market_minutes_for_day(self.days[0]) day1_minutes = self.env.market_minutes_for_day(self.days[1]) for idx, minute in enumerate(day0_minutes[-10:-1]): bar_data = BarData(self.data_portal, lambda: minute, "minute") self.assertEqual( 380, bar_data.current(self.ILLIQUID_SPLIT_ASSET, "price") ) bar_data = BarData( self.data_portal, lambda: day0_minutes[-1], "minute" ) self.assertEqual( 390, bar_data.current(self.ILLIQUID_SPLIT_ASSET, "price") ) for idx, minute in enumerate(day1_minutes[0:9]): bar_data = BarData(self.data_portal, lambda: minute, "minute") # should be half of 390, due to the split self.assertEqual( 195, bar_data.current(self.ILLIQUID_SPLIT_ASSET, "price") )
def test_get_value_during_non_market_hours(self): # make sure that if we try to get the OHLCV values of ASSET1 during # non-market hours, we don't get the previous market minute's values futures_cal = get_calendar("us_futures") data_portal = DataPortal( self.env.asset_finder, futures_cal, first_trading_day=self.DATA_PORTAL_FIRST_TRADING_DAY, equity_minute_reader=self.bcolz_equity_minute_bar_reader, ) bar_data = BarData( data_portal, lambda: pd.Timestamp("2016-01-06 3:15", tz="US/Eastern"), "minute", futures_cal ) self.assertTrue(np.isnan(bar_data.current(self.ASSET1, "open"))) self.assertTrue(np.isnan(bar_data.current(self.ASSET1, "high"))) self.assertTrue(np.isnan(bar_data.current(self.ASSET1, "low"))) self.assertTrue(np.isnan(bar_data.current(self.ASSET1, "close"))) self.assertEqual(0, bar_data.current(self.ASSET1, "volume")) # price should still forward fill self.assertEqual(390, bar_data.current(self.ASSET1, "price"))
def test_after_assets_dead(self): # both assets end on self.day[-1], so let's try the next day next_day = self.trading_schedule.next_execution_day( self.equity_daily_bar_days[-1] ) bar_data = BarData(self.data_portal, lambda: next_day, "daily") self.check_internal_consistency(bar_data) for asset in self.ASSETS: self.assertFalse(bar_data.can_trade(asset)) self.assertFalse(bar_data.is_stale(asset)) for field in OHLCP: self.assertTrue(np.isnan(bar_data.current(asset, field))) self.assertEqual(0, bar_data.current(asset, "volume")) last_traded_dt = bar_data.current(asset, "last_traded") if asset == self.ASSET1: self.assertEqual(self.equity_daily_bar_days[-2], last_traded_dt) else: self.assertEqual(self.equity_daily_bar_days[1], last_traded_dt)
def test_spot_price_adjustments(self, adjustment_type, liquid_day_0_price, liquid_day_1_price, illiquid_day_0_price, illiquid_day_1_price_adjusted): """Test the behaviour of spot prices during adjustments.""" table_name = adjustment_type + 's' liquid_asset = getattr(self, (adjustment_type.upper() + "_ASSET")) illiquid_asset = getattr( self, ("ILLIQUID_" + adjustment_type.upper() + "_ASSET")) # verify there is an adjustment for liquid_asset adjustments = self.adjustments_reader.get_adjustments_for_sid( table_name, liquid_asset.sid) self.assertEqual(1, len(adjustments)) adjustment = adjustments[0] self.assertEqual(adjustment[0], pd.Timestamp("2016-01-06", tz='UTC')) # ... but that's it's not applied when using spot value bar_data = BarData(self.data_portal, lambda: self.days[0], "daily") self.assertEqual(liquid_day_0_price, bar_data.current(liquid_asset, "price")) bar_data = BarData(self.data_portal, lambda: self.days[1], "daily") self.assertEqual(liquid_day_1_price, bar_data.current(liquid_asset, "price")) # ... except when we have to forward fill across a day boundary # ILLIQUID_ASSET has no data on days 0 and 2, and a split on day 2 bar_data = BarData(self.data_portal, lambda: self.days[1], "daily") self.assertEqual(illiquid_day_0_price, bar_data.current(illiquid_asset, "price")) bar_data = BarData(self.data_portal, lambda: self.days[2], "daily") # 3 (price from previous day) * 0.5 (split ratio) self.assertAlmostEqual(illiquid_day_1_price_adjusted, bar_data.current(illiquid_asset, "price"))
def test_after_assets_dead(self): # both assets end on self.day[-1], so let's try the next day minute = self.get_last_minute_of_session( self.trading_calendar.next_session_label( self.equity_daily_bar_days[-1])) bar_data = BarData(self.data_portal, lambda: minute, "daily") self.check_internal_consistency(bar_data) for asset in self.ASSETS: self.assertFalse(bar_data.can_trade(asset)) self.assertFalse(bar_data.is_stale(asset)) for field in OHLCP: self.assertTrue(np.isnan(bar_data.current(asset, field))) self.assertEqual(0, bar_data.current(asset, "volume")) last_traded_dt = bar_data.current(asset, "last_traded") if asset == self.ASSET1: self.assertEqual(self.equity_daily_bar_days[-2], last_traded_dt) else: self.assertEqual(self.equity_daily_bar_days[1], last_traded_dt)
def test_spot_price_is_adjusted_if_needed(self): # on cls.days[1], the first 9 minutes of ILLIQUID_SPLIT_ASSET are # missing. let's get them. day0_minutes = self.trading_calendar.minutes_for_session( self.equity_minute_bar_days[0]) day1_minutes = self.trading_calendar.minutes_for_session( self.equity_minute_bar_days[1]) for idx, minute in enumerate(day0_minutes[-10:-1]): bar_data = BarData(self.data_portal, lambda: minute, "minute") self.assertEqual( 380, bar_data.current(self.ILLIQUID_SPLIT_ASSET, "price")) bar_data = BarData(self.data_portal, lambda: day0_minutes[-1], "minute") self.assertEqual(390, bar_data.current(self.ILLIQUID_SPLIT_ASSET, "price")) for idx, minute in enumerate(day1_minutes[0:9]): bar_data = BarData(self.data_portal, lambda: minute, "minute") # should be half of 390, due to the split self.assertEqual( 195, bar_data.current(self.ILLIQUID_SPLIT_ASSET, "price"))
def test_last_active_day(self): bar_data = BarData( self.data_portal, lambda: self.get_last_minute_of_session( self.equity_daily_bar_days[-1] ), "daily", self.trading_calendar ) self.check_internal_consistency(bar_data) for asset in self.ASSETS: if asset in (1, 2): self.assertFalse(bar_data.can_trade(asset)) else: self.assertTrue(bar_data.can_trade(asset)) self.assertFalse(bar_data.is_stale(asset)) if asset in (1, 2): assert_almost_equal(nan, bar_data.current(asset, "open")) assert_almost_equal(nan, bar_data.current(asset, "high")) assert_almost_equal(nan, bar_data.current(asset, "low")) assert_almost_equal(nan, bar_data.current(asset, "close")) assert_almost_equal(0, bar_data.current(asset, "volume")) assert_almost_equal(nan, bar_data.current(asset, "price")) else: self.assertEqual(6, bar_data.current(asset, "open")) self.assertEqual(7, bar_data.current(asset, "high")) self.assertEqual(4, bar_data.current(asset, "low")) self.assertEqual(5, bar_data.current(asset, "close")) self.assertEqual(500, bar_data.current(asset, "volume")) self.assertEqual(5, bar_data.current(asset, "price"))
def test_semi_active_day(self): # on self.days[0], only asset1 has data bar_data = BarData(self.data_portal, lambda: self.days[0], "daily") self.check_internal_consistency(bar_data) self.assertTrue(bar_data.can_trade(self.ASSET1)) self.assertFalse(bar_data.can_trade(self.ASSET2)) # because there is real data self.assertFalse(bar_data.is_stale(self.ASSET1)) # because there has never been a trade bar yet self.assertFalse(bar_data.is_stale(self.ASSET2)) self.assertEqual(3, bar_data.current(self.ASSET1, "open")) self.assertEqual(4, bar_data.current(self.ASSET1, "high")) self.assertEqual(1, bar_data.current(self.ASSET1, "low")) self.assertEqual(2, bar_data.current(self.ASSET1, "close")) self.assertEqual(200, bar_data.current(self.ASSET1, "volume")) self.assertEqual(2, bar_data.current(self.ASSET1, "price")) self.assertEqual(self.days[0], bar_data.current(self.ASSET1, "last_traded")) for field in OHLCP: self.assertTrue(np.isnan(bar_data.current(self.ASSET2, field)), field) self.assertEqual(0, bar_data.current(self.ASSET2, "volume")) self.assertTrue(bar_data.current(self.ASSET2, "last_traded") is pd.NaT)
def test_semi_active_day(self): # on self.days[0], only asset1 has data bar_data = BarData(self.data_portal, lambda: self.days[0], "daily") self.check_internal_consistency(bar_data) self.assertTrue(bar_data.can_trade(self.ASSET1)) self.assertFalse(bar_data.can_trade(self.ASSET2)) # because there is real data self.assertFalse(bar_data.is_stale(self.ASSET1)) # because there has never been a trade bar yet self.assertFalse(bar_data.is_stale(self.ASSET2)) self.assertEqual(3, bar_data.current(self.ASSET1, "open")) self.assertEqual(4, bar_data.current(self.ASSET1, "high")) self.assertEqual(1, bar_data.current(self.ASSET1, "low")) self.assertEqual(2, bar_data.current(self.ASSET1, "close")) self.assertEqual(200, bar_data.current(self.ASSET1, "volume")) self.assertEqual(2, bar_data.current(self.ASSET1, "price")) self.assertEqual(self.days[0], bar_data.current(self.ASSET1, "last_traded")) for field in OHLCP: self.assertTrue(np.isnan(bar_data.current(self.ASSET2, field)), field) self.assertEqual(0, bar_data.current(self.ASSET2, "volume")) self.assertTrue( bar_data.current(self.ASSET2, "last_traded") is pd.NaT )
def test_spot_price_adjustments(self, adjustment_type, liquid_day_0_price, liquid_day_1_price, illiquid_day_0_price, illiquid_day_1_price_adjusted): """Test the behaviour of spot prices during adjustments.""" table_name = adjustment_type + 's' liquid_asset = getattr(self, (adjustment_type.upper() + "_ASSET")) illiquid_asset = getattr( self, ("ILLIQUID_" + adjustment_type.upper() + "_ASSET") ) # verify there is an adjustment for liquid_asset adjustments = self.adjustments_reader.get_adjustments_for_sid( table_name, liquid_asset.sid ) self.assertEqual(1, len(adjustments)) adjustment = adjustments[0] self.assertEqual( adjustment[0], pd.Timestamp("2016-01-06", tz='UTC') ) # ... but that's it's not applied when using spot value bar_data = BarData(self.data_portal, lambda: self.days[0], "daily") self.assertEqual( liquid_day_0_price, bar_data.current(liquid_asset, "price") ) bar_data = BarData(self.data_portal, lambda: self.days[1], "daily") self.assertEqual( liquid_day_1_price, bar_data.current(liquid_asset, "price") ) # ... except when we have to forward fill across a day boundary # ILLIQUID_ASSET has no data on days 0 and 2, and a split on day 2 bar_data = BarData(self.data_portal, lambda: self.days[1], "daily") self.assertEqual( illiquid_day_0_price, bar_data.current(illiquid_asset, "price") ) bar_data = BarData(self.data_portal, lambda: self.days[2], "daily") # 3 (price from previous day) * 0.5 (split ratio) self.assertAlmostEqual( illiquid_day_1_price_adjusted, bar_data.current(illiquid_asset, "price") )
def test_last_active_day(self): bar_data = BarData(self.data_portal, lambda: self.days[-1], "daily") self.check_internal_consistency(bar_data) for asset in self.ASSETS: self.assertTrue(bar_data.can_trade(asset)) self.assertFalse(bar_data.is_stale(asset)) self.assertEqual(6, bar_data.current(asset, "open")) self.assertEqual(7, bar_data.current(asset, "high")) self.assertEqual(4, bar_data.current(asset, "low")) self.assertEqual(5, bar_data.current(asset, "close")) self.assertEqual(500, bar_data.current(asset, "volume")) self.assertEqual(5, bar_data.current(asset, "price"))
def test_last_active_day(self): bar_data = BarData(self.data_portal, lambda: self.days[-1], "daily") self.check_internal_consistency(bar_data) for asset in self.ASSETS: self.assertTrue(bar_data.can_trade(asset)) self.assertFalse(bar_data.is_stale(asset)) self.assertEqual(6, bar_data.current(asset, "open")) self.assertEqual(7, bar_data.current(asset, "high")) self.assertEqual(4, bar_data.current(asset, "low")) self.assertEqual(5, bar_data.current(asset, "close")) self.assertEqual(500, bar_data.current(asset, "volume")) self.assertEqual(5, bar_data.current(asset, "price"))
def test_overnight_adjustments(self): # verify there is a split for SPLIT_ASSET splits = self.adjustments_reader.get_adjustments_for_sid( "splits", self.SPLIT_ASSET.sid) self.assertEqual(1, len(splits)) split = splits[0] self.assertEqual(split[0], pd.Timestamp("2016-01-06", tz='UTC')) # Current day is 1/06/16 day = self.days[1] eight_fortyfive_am_eastern = \ pd.Timestamp("{0}-{1}-{2} 8:45".format( day.year, day.month, day.day), tz='US/Eastern' ) bar_data = BarData(self.data_portal, lambda: eight_fortyfive_am_eastern, "minute") expected = { 'open': 391 / 2.0, 'high': 392 / 2.0, 'low': 389 / 2.0, 'close': 390 / 2.0, 'volume': 39000 * 2.0, 'price': 390 / 2.0, } with handle_non_market_minutes(bar_data): for field in OHLCP + ['volume']: value = bar_data.current(self.SPLIT_ASSET, field) # Assert the price is adjusted for the overnight split self.assertEqual(value, expected[field])
def test_get_value_is_unadjusted(self): # verify there is a split for SPLIT_ASSET splits = self.adjustment_reader.get_adjustments_for_sid( "splits", self.SPLIT_ASSET.sid ) self.assertEqual(1, len(splits)) split = splits[0] self.assertEqual( split[0], pd.Timestamp("2016-01-06", tz='UTC') ) # ... but that's it's not applied when using spot value minutes = self.trading_calendar.minutes_for_sessions_in_range( self.equity_minute_bar_days[0], self.equity_minute_bar_days[1] ) for idx, minute in enumerate(minutes): bar_data = BarData(self.data_portal, lambda: minute, "minute", self.trading_calendar) self.assertEqual( idx + 1, bar_data.current(self.SPLIT_ASSET, "price") )
def test_minute_before_assets_trading(self): # grab minutes that include the day before the asset start minutes = self.env.market_minutes_for_day( self.env.previous_trading_day(self.days[0])) # this entire day is before either asset has started trading for idx, minute in enumerate(minutes): bar_data = BarData(self.data_portal, lambda: minute, "minute") self.check_internal_consistency(bar_data) self.assertFalse(bar_data.can_trade(self.ASSET1)) self.assertFalse(bar_data.can_trade(self.ASSET2)) self.assertFalse(bar_data.is_stale(self.ASSET1)) self.assertFalse(bar_data.is_stale(self.ASSET2)) for field in ALL_FIELDS: for asset in self.ASSETS: asset_value = bar_data.current(asset, field) if field in OHLCP: self.assertTrue(np.isnan(asset_value)) elif field == "volume": self.assertEqual(0, asset_value) elif field == "last_traded": self.assertTrue(asset_value is pd.NaT)
def test_day_before_assets_trading(self): # use the day before self.equity_daily_bar_days[0] day = self.trading_schedule.previous_execution_day( self.equity_daily_bar_days[0] ) bar_data = BarData(self.data_portal, lambda: day, "daily") self.check_internal_consistency(bar_data) self.assertFalse(bar_data.can_trade(self.ASSET1)) self.assertFalse(bar_data.can_trade(self.ASSET2)) self.assertFalse(bar_data.is_stale(self.ASSET1)) self.assertFalse(bar_data.is_stale(self.ASSET2)) for field in ALL_FIELDS: for asset in self.ASSETS: asset_value = bar_data.current(asset, field) if field in OHLCP: self.assertTrue(np.isnan(asset_value)) elif field == "volume": self.assertEqual(0, asset_value) elif field == "last_traded": self.assertTrue(asset_value is pd.NaT)
def test_day_before_assets_trading(self): # use the day before self.bcolz_daily_bar_days[0] minute = self.get_last_minute_of_session( self.trading_calendar.previous_session_label( self.equity_daily_bar_days[0] ) ) bar_data = BarData(self.data_portal, lambda: minute, "daily", self.trading_calendar) self.check_internal_consistency(bar_data) self.assertFalse(bar_data.can_trade(self.ASSET1)) self.assertFalse(bar_data.can_trade(self.ASSET2)) self.assertFalse(bar_data.is_stale(self.ASSET1)) self.assertFalse(bar_data.is_stale(self.ASSET2)) for field in ALL_FIELDS: for asset in self.ASSETS: asset_value = bar_data.current(asset, field) if field in OHLCP: self.assertTrue(np.isnan(asset_value)) elif field == "volume": self.assertEqual(0, asset_value) elif field == "last_traded": self.assertTrue(asset_value is pd.NaT)
def test_minute_after_assets_stopped(self): minutes = self.env.market_minutes_for_day( self.env.next_trading_day(self.days[-1])) last_trading_minute = \ self.env.market_minutes_for_day(self.days[-1])[-1] # this entire day is after both assets have stopped trading for idx, minute in enumerate(minutes): bar_data = BarData(self.data_portal, lambda: minute, "minute") self.assertFalse(bar_data.can_trade(self.ASSET1)) self.assertFalse(bar_data.can_trade(self.ASSET2)) self.assertFalse(bar_data.is_stale(self.ASSET1)) self.assertFalse(bar_data.is_stale(self.ASSET2)) self.check_internal_consistency(bar_data) for field in ALL_FIELDS: for asset in self.ASSETS: asset_value = bar_data.current(asset, field) if field in OHLCP: self.assertTrue(np.isnan(asset_value)) elif field == "volume": self.assertEqual(0, asset_value) elif field == "last_traded": self.assertEqual(last_trading_minute, asset_value)
def test_minute_after_assets_stopped(self): minutes = self.env.market_minutes_for_day( self.env.next_trading_day(self.days[-1]) ) last_trading_minute = \ self.env.market_minutes_for_day(self.days[-1])[-1] # this entire day is after both assets have stopped trading for idx, minute in enumerate(minutes): bar_data = BarData(self.data_portal, lambda: minute, "minute") self.assertFalse(bar_data.can_trade(self.ASSET1)) self.assertFalse(bar_data.can_trade(self.ASSET2)) self.assertFalse(bar_data.is_stale(self.ASSET1)) self.assertFalse(bar_data.is_stale(self.ASSET2)) self.check_internal_consistency(bar_data) for field in ALL_FIELDS: for asset in self.ASSETS: asset_value = bar_data.current(asset, field) if field in OHLCP: self.assertTrue(np.isnan(asset_value)) elif field == "volume": self.assertEqual(0, asset_value) elif field == "last_traded": self.assertEqual(last_trading_minute, asset_value)
def getCurrentPrice(self, zipline_data: BarData, alloc_weights: np.array = None) -> float: """Compute and return the current asset price (using stored component asset allocation weights) or supplied override allocation weights. Arguments: zipline_data {BarData} -- Instance zipline data bundle. Keyword Arguments: alloc_weights {np.array} -- Alternate allocation weights to be used instead of stored allocation weights (default: {None}). Returns: float -- Synthetic ETF price at the current time step. """ # Getting current component asset prices current_asset_prices = np.array( zipline_data.current(symbols(*self.tickers), 'price')) if alloc_weights is None: alloc_weights = self.alloc_weights # Comuting current price (dot product b/w current prices and alloc) return np.dot(current_asset_prices, alloc_weights)
def test_spot_price_is_unadjusted(self): # verify there is a split for SPLIT_ASSET splits = self.adjustments_reader.get_adjustments_for_sid( "splits", self.SPLIT_ASSET.sid ) self.assertEqual(1, len(splits)) split = splits[0] self.assertEqual( split[0], pd.Timestamp("2016-01-06", tz='UTC') ) # ... but that's it's not applied when using spot value minutes = self.env.minutes_for_days_in_range( start=self.days[0], end=self.days[1] ) for idx, minute in enumerate(minutes): bar_data = BarData(self.data_portal, lambda: minute, "minute") self.assertEqual( idx + 1, bar_data.current(self.SPLIT_ASSET, "price") )
def test_minute_before_assets_trading(self): # grab minutes that include the day before the asset start minutes = self.env.market_minutes_for_day( self.env.previous_trading_day(self.days[0]) ) # this entire day is before either asset has started trading for idx, minute in enumerate(minutes): bar_data = BarData(self.data_portal, lambda: minute, "minute") self.check_internal_consistency(bar_data) self.assertFalse(bar_data.can_trade(self.ASSET1)) self.assertFalse(bar_data.can_trade(self.ASSET2)) self.assertFalse(bar_data.is_stale(self.ASSET1)) self.assertFalse(bar_data.is_stale(self.ASSET2)) for field in ALL_FIELDS: for asset in self.ASSETS: asset_value = bar_data.current(asset, field) if field in OHLCP: self.assertTrue(np.isnan(asset_value)) elif field == "volume": self.assertEqual(0, asset_value) elif field == "last_traded": self.assertTrue(asset_value is pd.NaT)
def test_after_assets_dead(self): session = self.END_DATE bar_data = BarData(self.data_portal, lambda: session, "daily", self.trading_calendar) self.check_internal_consistency(bar_data) for asset in self.ASSETS: self.assertFalse(bar_data.can_trade(asset)) self.assertFalse(bar_data.is_stale(asset)) for field in OHLCP: self.assertTrue(np.isnan(bar_data.current(asset, field))) self.assertEqual(0, bar_data.current(asset, "volume")) last_traded_dt = bar_data.current(asset, "last_traded") if asset in (self.ASSET1, self.ASSET2): self.assertEqual(self.equity_daily_bar_days[3], last_traded_dt)
def test_fully_active_day(self): bar_data = BarData( self.data_portal, lambda: self.get_last_minute_of_session( self.equity_daily_bar_days[1] ), "daily", self.trading_calendar ) self.check_internal_consistency(bar_data) # on self.equity_daily_bar_days[1], both assets have data for asset in self.ASSETS: self.assertTrue(bar_data.can_trade(asset)) self.assertFalse(bar_data.is_stale(asset)) self.assertEqual(4, bar_data.current(asset, "open")) self.assertEqual(5, bar_data.current(asset, "high")) self.assertEqual(2, bar_data.current(asset, "low")) self.assertEqual(3, bar_data.current(asset, "close")) self.assertEqual(300, bar_data.current(asset, "volume")) self.assertEqual(3, bar_data.current(asset, "price")) self.assertEqual( self.equity_daily_bar_days[1], bar_data.current(asset, "last_traded") )
def test_after_assets_dead(self): # both assets end on self.day[-1], so let's try the next day next_day = self.env.next_trading_day(self.days[-1]) bar_data = BarData(self.data_portal, lambda: next_day, "daily") self.check_internal_consistency(bar_data) for asset in self.ASSETS: self.assertFalse(bar_data.can_trade(asset)) self.assertFalse(bar_data.is_stale(asset)) for field in OHLCP: self.assertTrue(np.isnan(bar_data.current(asset, field))) self.assertEqual(0, bar_data.current(asset, "volume")) last_traded_dt = bar_data.current(asset, "last_traded") if asset == self.ASSET1: self.assertEqual(self.days[-2], last_traded_dt) else: self.assertEqual(self.days[1], last_traded_dt)
def test_overnight_adjustments(self): # verify there is a split for SPLIT_ASSET splits = self.adjustment_reader.get_adjustments_for_sid( "splits", self.SPLIT_ASSET.sid ) self.assertEqual(1, len(splits)) split = splits[0] self.assertEqual( split[0], pd.Timestamp("2016-01-06", tz='UTC') ) # Current day is 1/06/16 day = self.equity_daily_bar_days[1] eight_fortyfive_am_eastern = \ pd.Timestamp("{0}-{1}-{2} 8:45".format( day.year, day.month, day.day), tz='US/Eastern' ) bar_data = BarData(self.data_portal, lambda: eight_fortyfive_am_eastern, "minute", self.trading_calendar) expected = { 'open': 391 / 2.0, 'high': 392 / 2.0, 'low': 389 / 2.0, 'close': 390 / 2.0, 'volume': 39000 * 2.0, 'price': 390 / 2.0, } with handle_non_market_minutes(bar_data): for field in OHLCP + ['volume']: value = bar_data.current(self.SPLIT_ASSET, field) # Assert the price is adjusted for the overnight split self.assertEqual(value, expected[field])
def test_day_before_assets_trading(self): # use the day before self.days[0] day = self.env.previous_trading_day(self.days[0]) bar_data = BarData(self.data_portal, lambda: day, "daily") self.check_internal_consistency(bar_data) self.assertFalse(bar_data.can_trade(self.ASSET1)) self.assertFalse(bar_data.can_trade(self.ASSET2)) self.assertFalse(bar_data.is_stale(self.ASSET1)) self.assertFalse(bar_data.is_stale(self.ASSET2)) for field in ALL_FIELDS: for asset in self.ASSETS: asset_value = bar_data.current(asset, field) if field in OHLCP: self.assertTrue(np.isnan(asset_value)) elif field == "volume": self.assertEqual(0, asset_value) elif field == "last_traded": self.assertTrue(asset_value is pd.NaT)
def updateWeights(self, zipline_data: BarData) -> np.array: """Update current weights of the component assets; this recomputes the price-weighted allocation as of the date of the current `zipline_data`. Arguments: zipline_data {BarData} -- Instance zipline data bundle. Returns: np.array -- Array of asset weights. """ # Getting current component asset prices current_asset_prices = np.array( zipline_data.current(symbols(*self.tickers), 'price')) # Computing current sum current_sum = np.sum(current_asset_prices) # Binding allocation weights (list and dict) self.alloc_weights = current_asset_prices / current_sum self.alloc_weights_dict = dict(zip(self.tickers, self.alloc_weights)) # Return new weights return self.alloc_weights
def test_regular_minute(self): minutes = self.env.market_minutes_for_day(self.days[0]) for idx, minute in enumerate(minutes): # day2 has prices # (every minute for asset1, every 10 minutes for asset2) # asset1: # opens: 2-391 # high: 3-392 # low: 0-389 # close: 1-390 # volume: 100-3900 (by 100) # asset2 is the same thing, but with only every 10th minute # populated. # this test covers the "IPO morning" case, because asset2 only # has data starting on the 10th minute. bar_data = BarData(self.data_portal, lambda: minute, "minute") self.check_internal_consistency(bar_data) asset2_has_data = (((idx + 1) % 10) == 0) self.assertTrue(bar_data.can_trade(self.ASSET1)) self.assertFalse(bar_data.is_stale(self.ASSET1)) if idx < 9: self.assertFalse(bar_data.can_trade(self.ASSET2)) self.assertFalse(bar_data.is_stale(self.ASSET2)) else: self.assertTrue(bar_data.can_trade(self.ASSET2)) if asset2_has_data: self.assertFalse(bar_data.is_stale(self.ASSET2)) else: self.assertTrue(bar_data.is_stale(self.ASSET2)) for field in ALL_FIELDS: asset1_value = bar_data.current(self.ASSET1, field) asset2_value = bar_data.current(self.ASSET2, field) # now check the actual values if idx == 0 and field == "low": # first low value is 0, which is interpreted as NaN self.assertTrue(np.isnan(asset1_value)) else: if field in OHLC: self.assertEqual( idx + 1 + field_info[field], asset1_value ) if asset2_has_data: self.assertEqual( idx + 1 + field_info[field], asset2_value ) else: self.assertTrue(np.isnan(asset2_value)) elif field == "volume": self.assertEqual((idx + 1) * 100, asset1_value) if asset2_has_data: self.assertEqual((idx + 1) * 100, asset2_value) else: self.assertEqual(0, asset2_value) elif field == "price": self.assertEqual(idx + 1, asset1_value) if asset2_has_data: self.assertEqual(idx + 1, asset2_value) elif idx < 9: # no price to forward fill from self.assertTrue(np.isnan(asset2_value)) else: # forward-filled price self.assertEqual((idx // 10) * 10, asset2_value) elif field == "last_traded": self.assertEqual(minute, asset1_value) if idx < 9: self.assertTrue(asset2_value is pd.NaT) elif asset2_has_data: self.assertEqual(minute, asset2_value) else: last_traded_minute = minutes[(idx // 10) * 10] self.assertEqual(last_traded_minute - 1, asset2_value)
def test_old_new_data_api_paths(self): """ Test that the new and old data APIs hit the same code paths. We want to ensure that the old data API(data[sid(N)].field and similar) and the new data API(data.current(sid(N), field) and similar) hit the same code paths on the DataPortal. """ test_start_minute = self.env.market_minutes_for_day( self.sim_params.trading_days[0] )[1] test_end_minute = self.env.market_minutes_for_day( self.sim_params.trading_days[0] )[-1] bar_data = BarData( self.data_portal, lambda: test_end_minute, "minute" ) ohlcvp_fields = [ "open", "high", "low" "close", "volume", "price", ] spot_value_meth = 'zipline.data.data_portal.DataPortal.get_spot_value' def assert_get_spot_value_called(fun, field): """ Assert that get_spot_value was called during the execution of fun. Takes in a function fun and a string field. """ with patch(spot_value_meth) as gsv: fun() gsv.assert_called_with( self.asset1, field, test_end_minute, 'minute' ) # Ensure that data.current(sid(n), field) has the same behaviour as # data[sid(n)].field. for field in ohlcvp_fields: assert_get_spot_value_called( lambda: getattr(bar_data[self.asset1], field), field, ) assert_get_spot_value_called( lambda: bar_data.current(self.asset1, field), field, ) history_meth = 'zipline.data.data_portal.DataPortal.get_history_window' def assert_get_history_window_called(fun, is_legacy): """ Assert that get_history_window was called during fun(). Takes in a function fun and a boolean is_legacy. """ with patch(history_meth) as ghw: fun() # Slightly hacky, but done to get around the fact that # history( explicitly passes an ffill param as the last arg, # while data.history doesn't. if is_legacy: ghw.assert_called_with( [self.asset1, self.asset2, self.asset3], test_end_minute, 5, "1m", "volume", True ) else: ghw.assert_called_with( [self.asset1, self.asset2, self.asset3], test_end_minute, 5, "1m", "volume", ) test_sim_params = SimulationParameters( period_start=test_start_minute, period_end=test_end_minute, data_frequency="minute", env=self.env ) history_algorithm = self.create_algo( history_algo, sim_params=test_sim_params ) assert_get_history_window_called( lambda: history_algorithm.run(self.data_portal), is_legacy=True ) assert_get_history_window_called( lambda: bar_data.history( [self.asset1, self.asset2, self.asset3], "volume", 5, "1m" ), is_legacy=False )
def test_regular_minute(self): minutes = self.env.market_minutes_for_day(self.days[0]) for idx, minute in enumerate(minutes): # day2 has prices # (every minute for asset1, every 10 minutes for asset2) # asset1: # opens: 2-391 # high: 3-392 # low: 0-389 # close: 1-390 # volume: 100-3900 (by 100) # asset2 is the same thing, but with only every 10th minute # populated. # this test covers the "IPO morning" case, because asset2 only # has data starting on the 10th minute. bar_data = BarData(self.data_portal, lambda: minute, "minute") self.check_internal_consistency(bar_data) asset2_has_data = (((idx + 1) % 10) == 0) self.assertTrue(bar_data.can_trade(self.ASSET1)) self.assertFalse(bar_data.is_stale(self.ASSET1)) if idx < 9: self.assertFalse(bar_data.can_trade(self.ASSET2)) self.assertFalse(bar_data.is_stale(self.ASSET2)) else: self.assertTrue(bar_data.can_trade(self.ASSET2)) if asset2_has_data: self.assertFalse(bar_data.is_stale(self.ASSET2)) else: self.assertTrue(bar_data.is_stale(self.ASSET2)) for field in ALL_FIELDS: asset1_value = bar_data.current(self.ASSET1, field) asset2_value = bar_data.current(self.ASSET2, field) # now check the actual values if idx == 0 and field == "low": # first low value is 0, which is interpreted as NaN self.assertTrue(np.isnan(asset1_value)) else: if field in OHLC: self.assertEqual(idx + 1 + field_info[field], asset1_value) if asset2_has_data: self.assertEqual(idx + 1 + field_info[field], asset2_value) else: self.assertTrue(np.isnan(asset2_value)) elif field == "volume": self.assertEqual((idx + 1) * 100, asset1_value) if asset2_has_data: self.assertEqual((idx + 1) * 100, asset2_value) else: self.assertEqual(0, asset2_value) elif field == "price": self.assertEqual(idx + 1, asset1_value) if asset2_has_data: self.assertEqual(idx + 1, asset2_value) elif idx < 9: # no price to forward fill from self.assertTrue(np.isnan(asset2_value)) else: # forward-filled price self.assertEqual((idx // 10) * 10, asset2_value) elif field == "last_traded": self.assertEqual(minute, asset1_value) if idx < 9: self.assertTrue(asset2_value is pd.NaT) elif asset2_has_data: self.assertEqual(minute, asset2_value) else: last_traded_minute = minutes[(idx // 10) * 10] self.assertEqual(last_traded_minute - 1, asset2_value)