def test_bts_simulation_dt(self): code = """ def initialize(context): pass """ algo = self.make_algo(script=code, metrics=metrics.load("none")) algo.metrics_tracker = algo._create_metrics_tracker() benchmark_source = algo._create_benchmark_source() algo.metrics_tracker.handle_start_of_simulation(benchmark_source) dt = pd.Timestamp("2016-08-04 9:13:14", tz="US/Eastern") algo_simulator = AlgorithmSimulator( algo, self.sim_params, self.data_portal, BeforeTradingStartsOnlyClock(dt), benchmark_source, NoRestrictions(), None, ) # run through the algo's simulation list(algo_simulator.transform()) # since the clock only ever emitted a single before_trading_start # event, we can check that the simulation_dt was properly set assert dt == algo_simulator.simulation_dt
def _create_generator(self, sim_params, source_filter=None): """ Create a basic generator setup using the sources to this algorithm. ::source_filter:: is a method that receives events in date sorted order, and returns True for those events that should be processed by the zipline, and False for those that should be skipped. """ if not self.initialized: self.initialize(*self.initialize_args, **self.initialize_kwargs) self.initialized = True if self.perf_tracker is None: # HACK: When running with the `run` method, we set perf_tracker to # None so that it will be overwritten here. self.perf_tracker = PerformanceTracker(sim_params) self.portfolio_needs_update = True self.account_needs_update = True self.performance_needs_update = True self.data_gen = self._create_data_generator(source_filter, sim_params) self.trading_client = AlgorithmSimulator(self, sim_params) transact_method = transact_partial(self.slippage, self.commission) self.set_transact(transact_method) return self.trading_client.transform(self.data_gen)
def _create_generator(self, sim_params, source_filter=None): """ Create a basic generator setup using the sources and transforms attached to this algorithm. ::source_filter:: is a method that receives events in date sorted order, and returns True for those events that should be processed by the zipline, and False for those that should be skipped. """ sim_params.data_frequency = self.data_frequency # perf_tracker will be instantiated in __init__ if a sim_params # is passed to the constructor. If not, we instantiate here. if self.perf_tracker is None: self.perf_tracker = PerformanceTracker(sim_params) self.data_gen = self._create_data_generator(source_filter, sim_params) self.trading_client = AlgorithmSimulator(self, sim_params) transact_method = transact_partial(self.slippage, self.commission) self.set_transact(transact_method) return self.trading_client.transform(self.data_gen)
def test_bts_simulation_dt(self): code = """ def initialize(context): pass """ algo = TradingAlgorithm(script=code, sim_params=self.sim_params, env=self.env) algo.perf_tracker = PerformanceTracker( sim_params=self.sim_params, trading_calendar=self.trading_calendar, asset_finder=self.asset_finder, ) dt = pd.Timestamp("2016-08-04 9:13:14", tz='US/Eastern') algo_simulator = AlgorithmSimulator( algo, self.sim_params, self.data_portal, BeforeTradingStartsOnlyClock(dt), algo._create_benchmark_source(), NoRestrictions(), None ) # run through the algo's simulation list(algo_simulator.transform()) # since the clock only ever emitted a single before_trading_start # event, we can check that the simulation_dt was properly set self.assertEqual(dt, algo_simulator.simulation_dt)
def _create_generator(self, sim_params, source_filter=None): """ Create a basic generator setup using the sources to this algorithm. ::source_filter:: is a method that receives events in date sorted order, and returns True for those events that should be processed by the zipline, and False for those that should be skipped. """ if not self.initialized: self.initialize(*self.initialize_args, **self.initialize_kwargs) self.initialized = True if self.perf_tracker is None: # HACK: When running with the `run` method, we set perf_tracker to # None so that it will be overwritten here. #self.perf_tracker = CustomPerfTracker( self.perf_tracker = PerformanceTracker( sim_params=sim_params, env=self.trading_environment ) self.portfolio_needs_update = True self.account_needs_update = True self.performance_needs_update = True self.data_gen = self._create_data_generator(source_filter, sim_params) # Zipline uses a lot of composition object oriented design. # How does composition help keep the system flexible and allow for object to be # substituted at run-time. # Zipline is a backtester that runs on historical data but it's also # the engine that drives Quantopion's live trading. # What objects might be modified to allow for live trading and greater functionality? # What Are the other key objects? (hint, look at the blotter) self.trading_client = AlgorithmSimulator(self, sim_params) transact_method = transact_partial(self.slippage, self.commission) self.set_transact(transact_method) # The transform method does the heavy lifting of the main zipline event loop return self.trading_client.transform(self.data_gen)
def _create_generator(self, sim_params, source_filter=None): """ Create a basic generator setup using the sources and transforms attached to this algorithm. ::source_filter:: is a method that receives events in date sorted order, and returns True for those events that should be processed by the zipline, and False for those that should be skipped. """ # Instantiate perf_tracker self.perf_tracker = PerformanceTracker(sim_params) self.portfolio_needs_update = True self.data_gen = self._create_data_generator(source_filter, sim_params) self.trading_client = AlgorithmSimulator(self, sim_params) transact_method = transact_partial(self.slippage, self.commission) self.set_transact(transact_method) return self.trading_client.transform(self.data_gen)