def test_slippage_and_commission_dispatching(self): blotter = SimulationBlotter( self.sim_params, equity_slippage=FixedSlippage(spread=0.0), future_slippage=FixedSlippage(spread=2.0), equity_commission=PerTrade(cost=1.0), future_commission=PerTrade(cost=2.0), ) blotter.order(self.asset_24, 1, MarketOrder()) blotter.order(self.future_cl, 1, MarketOrder()) bar_data = self.create_bardata( simulation_dt_func=lambda: self.sim_params.sessions[-1], ) txns, commissions, _ = blotter.get_transactions(bar_data) # The equity transaction should have the same price as its current # price because the slippage spread is zero. Its commission should be # $1.00. equity_txn = txns[0] self.assertEqual( equity_txn.price, bar_data.current(equity_txn.asset, 'price'), ) self.assertEqual(commissions[0]['cost'], 1.0) # The future transaction price should be 1.0 more than its current # price because half of the 'future_slippage' spread is added. Its # commission should be $2.00. future_txn = txns[1] self.assertEqual( future_txn.price, bar_data.current(future_txn.asset, 'price') + 1.0, ) self.assertEqual(commissions[1]['cost'], 2.0)
def initialize(self, stock_list, PCA_Weight, R_PCA_Protfolio, window_length=60): self.K_factors = 5 self.spreads = [] self.invested = 0 self.window_length = window_length self.ols_transform = ols_transform(refresh_period=1, window_length=self.window_length) self.regressor_name = stock_list self.instant_fill = True self.slippage = FixedSlippage(spread=0) self.sscore = [ ] # store those sscores which can be regarded as the hist self.beta = [] # keep track of the changing beta self.before_sid1_position = [] # keep track of the sid1 position self.before_sid2_position = [] # keep track of the sid2 position self.current_sid1_price = [] self.current_sid2_price = [] self.PCA_Weight = PCA_Weight self.PCA_R_PCA_Protfolio = R_PCA_Protfolio[:, 0:self. K_factors] ##############################
def test_blotter_processes_splits(self): blotter = SimulationBlotter(equity_slippage=FixedSlippage()) # set up two open limit orders with very low limit prices, # one for sid 1 and one for sid 2 asset1 = self.asset_finder.retrieve_asset(1) asset2 = self.asset_finder.retrieve_asset(2) asset133 = self.asset_finder.retrieve_asset(133) blotter.order(asset1, 100, LimitOrder(10, asset=asset1)) blotter.order(asset2, 100, LimitOrder(10, asset=asset2)) # send in splits for assets 133 and 2. We have no open orders for # asset 133 so it should be ignored. blotter.process_splits([(asset133, 0.5), (asset2, 0.3333)]) for asset in [asset1, asset2]: order_lists = blotter.open_orders[asset] assert order_lists is not None assert 1 == len(order_lists) asset1_order = blotter.open_orders[1][0] asset2_order = blotter.open_orders[2][0] # make sure the asset1 order didn't change assert 100 == asset1_order.amount assert 10 == asset1_order.limit assert 1 == asset1_order.asset # make sure the asset2 order did change # to 300 shares at 3.33 assert 300 == asset2_order.amount assert 3.33 == asset2_order.limit assert 2 == asset2_order.asset
def initialize(self, *args, **kwargs): self.add_transform(MovingAverage, 'mavg', ['price'], market_aware=True, window_length=2) self.set_slippage(FixedSlippage())
def test_blotter_processes_splits(self): blotter = Blotter('daily', equity_slippage=FixedSlippage()) # set up two open limit orders with very low limit prices, # one for sid 1 and one for sid 2 asset1 = self.asset_finder.retrieve_asset(1) asset2 = self.asset_finder.retrieve_asset(2) asset133 = self.asset_finder.retrieve_asset(133) blotter.order(asset1, 100, LimitOrder(10)) blotter.order(asset2, 100, LimitOrder(10)) # send in splits for assets 133 and 2. We have no open orders for # asset 133 so it should be ignored. blotter.process_splits([(asset133, 0.5), (asset2, 0.3333)]) for asset in [asset1, asset2]: order_lists = blotter.open_orders[asset] self.assertIsNotNone(order_lists) self.assertEqual(1, len(order_lists)) asset1_order = blotter.open_orders[1][0] asset2_order = blotter.open_orders[2][0] # make sure the asset1 order didn't change self.assertEqual(100, asset1_order.amount) self.assertEqual(10, asset1_order.limit) self.assertEqual(1, asset1_order.asset) # make sure the asset2 order did change # to 300 shares at 3.33 self.assertEqual(300, asset2_order.amount) self.assertEqual(3.33, asset2_order.limit) self.assertEqual(2, asset2_order.asset)
def test_blotter_processes_splits(self): blotter = Blotter('daily', self.env.asset_finder, slippage_func=FixedSlippage()) # set up two open limit orders with very low limit prices, # one for sid 1 and one for sid 2 blotter.order(blotter.asset_finder.retrieve_asset(1), 100, LimitOrder(10)) blotter.order(blotter.asset_finder.retrieve_asset(2), 100, LimitOrder(10)) # send in a split for sid 2 blotter.process_splits([(2, 0.3333)]) for sid in [1, 2]: order_lists = blotter.open_orders[sid] self.assertIsNotNone(order_lists) self.assertEqual(1, len(order_lists)) aapl_order = blotter.open_orders[1][0].to_dict() fls_order = blotter.open_orders[2][0].to_dict() # make sure the aapl order didn't change self.assertEqual(100, aapl_order['amount']) self.assertEqual(10, aapl_order['limit']) self.assertEqual(1, aapl_order['sid']) # make sure the fls order did change # to 300 shares at 3.33 self.assertEqual(300, fls_order['amount']) self.assertEqual(3.33, fls_order['limit']) self.assertEqual(2, fls_order['sid'])
def initialize(context): """ Initialization and trading logic """ # Set comission and slippage if enable_commission: comm_model = PerDollar(cost=commission_pct) else: comm_model = PerDollar(cost=0.0) set_commission(comm_model) if enable_slippage: slippage_model = VolumeShareSlippage( volume_limit=slippage_volume_limit, price_impact=slippage_impact) else: slippage_model = FixedSlippage(spread=0.0) # Used only for progress output context.last_month = initial_portfolio # Store index membership context.index_members = pd.read_csv('./data/sp500_members.csv', index_col=0, parse_dates=[0]) # Schedule rebalance monthly schedule_function(func=rebalance, date_rule=date_rules.month_start(), time_rule=time_rules.market_open())
def initialize(self): #,startDate,endDate,startDateTrading,debug): self.secs=['SPY','XLY','XLP','XLE','XLF','XLB','XLK','XLV','XLI','XLU'] self.slippage=FixedSlippage() # self.set_commission(commission.PerShare(cost=.005)) self.leverage = 1.0 self.top_k = 1 self.weight = self.leverage/self.top_k self.trailing_return= trailing_return(refresh_period=30, window_length=61)
def initialize(self, window_length=60): self.spreads = [] self.invested = 0 self.window_length = window_length self.ols_transform = ols_transform(refresh_period=1, window_length=self.window_length) self.instant_fill = True self.slippage = FixedSlippage(spread=0) self.sscore = [ ] # store those sscores which can be regarded as the hist
def initialize(context): logging.debug('enter initialize') context.set_slippage(FixedSlippage()) context.set_commission(commission.PerTrade(cost=5)) context.LOW_RSI = initialize.low_RSI context.HIGH_RSI = initialize.high_RSI context.rsi_window = initialize.rsi_window add_history(context.rsi_window, '1d', 'price') context.i = 0 context.invested = False
def initialize(self, tickers, basket): # To keep track of whether we invested in the stock or not self.invested = False self.commission = PerTrade(0.00) #self.starting_cash(10000) self.set_slippage(FixedSlippage()) self.capital_base = 10000 self.tickers = tickers self.basket = basket self.quantity = 0
def initialize(self): self.invested = False self.trade_size = 1000 self.long = False self.short = False self.closed = False self.trading_day_counter = 0 self.pct_stop = 0.025 self.long_stop_price = 0.0 self.short_stop_price = 0.0 self.target = 0.05 commission_cost = self.trade_size * COMMISSION self.set_slippage(FixedSlippage(spread=0.10)) self.set_commission(PerTrade(cost=commission_cost))
def initialize(self, *args, **kwargs): self.refresh_period = kwargs.pop('refresh_period', 2) self.window_length = kwargs.pop('window_length', 3) self.args = args self.kwargs = kwargs self.history_return_price_class = [] self.history_return_price_decorator = [] self.history_return_args = [] self.history_return_price_market_aware = [] self.history_return_more_days_than_refresh = [] self.return_price_class = ReturnPriceBatchTransform( market_aware=False, refresh_period=self.refresh_period, delta=timedelta(days=self.window_length)) self.return_price_decorator = return_price_batch_decorator( market_aware=False, refresh_period=self.refresh_period, delta=timedelta(days=self.window_length)) self.return_args_batch = return_args_batch_decorator( market_aware=False, refresh_period=self.refresh_period, delta=timedelta(days=self.window_length)) self.return_price_market_aware = ReturnPriceBatchTransform( market_aware=True, refresh_period=self.refresh_period, window_length=self.window_length) self.return_price_more_days_than_refresh = ReturnPriceBatchTransform( market_aware=True, refresh_period=1, window_length=3) self.set_slippage(FixedSlippage())
def run(self, algo, tBeg=None, tEnd=None, commission=None, slippage=None, warn=False, bar_source='yahoo', adjusted=True, data_frequency='daily', include_open=True, csi_port='ETFs'): # Set a default algo if none is provided if not algo: raise Exception('No algo provided') self.algo = algo # set commission model if commission: self.algo.set_commission(commission) else: self.algo.set_commission( PerShareWithMin(comm_per_share=0.01, comm_min=1.0)) # set slippage model if slippage: self.algo.set_slippage(slippage) else: self.algo.set_slippage(FixedSlippage(spread=0.0)) # guess starting and ending dates if none are provided if not tEnd: tEnd = get_end_date() if not tBeg: tBeg = get_start_date(self.algo.iL, tNow=tEnd) tBeg = pytz.utc.localize(tBeg) tEnd = pytz.utc.localize(tEnd) self.sim_params = SimulationParameters(tBeg, tEnd, data_frequency=data_frequency, capital_base=self.capital_base, make_new_environment=True, extra_dates=[]) # print self.sim_params source = self.get_bar_source(tBeg, tEnd, bar_source, adjusted=adjusted, include_open=include_open, csi_port=csi_port) if bar_source == 'redshift': bench_source, self.bench_price_utc = redshift.get_bench_source( tBeg, tEnd) else: bench_source = None sources = [source] if not warn: # turn off warnings import warnings warnings.filterwarnings('ignore') self.run_time = time.time() self.results = self.algo.run(sources, sim_params=self.sim_params, benchmark_return_source=bench_source) self.run_time = time.time() - self.run_time
def test_order_rejection(self): blotter = SimulationBlotter(self.sim_params) # Reject a nonexistent order -> no order appears in new_order, # no exceptions raised out blotter.reject(56) self.assertEqual(blotter.new_orders, []) # Basic tests of open order behavior open_order_id = blotter.order(self.asset_24, 100, MarketOrder()) second_order_id = blotter.order(self.asset_24, 50, MarketOrder()) self.assertEqual(len(blotter.open_orders[self.asset_24]), 2) open_order = blotter.open_orders[self.asset_24][0] self.assertEqual(open_order.status, ORDER_STATUS.OPEN) self.assertEqual(open_order.id, open_order_id) self.assertIn(open_order, blotter.new_orders) # Reject that order immediately (same bar, i.e. still in new_orders) blotter.reject(open_order_id) self.assertEqual(len(blotter.new_orders), 2) self.assertEqual(len(blotter.open_orders[self.asset_24]), 1) still_open_order = blotter.new_orders[0] self.assertEqual(still_open_order.id, second_order_id) self.assertEqual(still_open_order.status, ORDER_STATUS.OPEN) rejected_order = blotter.new_orders[1] self.assertEqual(rejected_order.status, ORDER_STATUS.REJECTED) self.assertEqual(rejected_order.reason, '') # Do it again, but reject it at a later time (after tradesimulation # pulls it from new_orders) blotter = SimulationBlotter(self.sim_params) new_open_id = blotter.order(self.asset_24, 10, MarketOrder()) new_open_order = blotter.open_orders[self.asset_24][0] self.assertEqual(new_open_id, new_open_order.id) # Pretend that the trade simulation did this. blotter.new_orders = [] rejection_reason = "Not enough cash on hand." blotter.reject(new_open_id, reason=rejection_reason) rejected_order = blotter.new_orders[0] self.assertEqual(rejected_order.id, new_open_id) self.assertEqual(rejected_order.status, ORDER_STATUS.REJECTED) self.assertEqual(rejected_order.reason, rejection_reason) # You can't reject a filled order. # Reset for paranoia blotter = SimulationBlotter(self.sim_params) blotter.slippage_models[Equity] = FixedSlippage() filled_id = blotter.order(self.asset_24, 100, MarketOrder()) filled_order = None blotter.current_dt = self.sim_params.sessions[-1] bar_data = self.create_bardata( simulation_dt_func=lambda: self.sim_params.sessions[-1], ) txns, _, closed_orders = blotter.get_transactions(bar_data) for txn in txns: filled_order = blotter.orders[txn.order_id] blotter.prune_orders(closed_orders) self.assertEqual(filled_order.id, filled_id) self.assertIn(filled_order, blotter.new_orders) self.assertEqual(filled_order.status, ORDER_STATUS.FILLED) self.assertNotIn(filled_order, blotter.open_orders[self.asset_24]) blotter.reject(filled_id) updated_order = blotter.orders[filled_id] self.assertEqual(updated_order.status, ORDER_STATUS.FILLED)
def setUp(self): self.zipline_test_config = {'sid': 133, 'slippage': FixedSlippage()} setup_logger(self)
def initialize(self): # Moving window. Defining maxlen causes the window length # to remain constant as old events get dropped once full. self.window = deque(maxlen=delta_t) # Turns off slippage to simplify simulation. self.set_slippage(FixedSlippage())
def transaction_sim(self, **params): """ This is a utility method that asserts expected results for conversion of orders to transactions given a trade history""" tempdir = TempDirectory() try: trade_count = params['trade_count'] trade_interval = params['trade_interval'] order_count = params['order_count'] order_amount = params['order_amount'] order_interval = params['order_interval'] expected_txn_count = params['expected_txn_count'] expected_txn_volume = params['expected_txn_volume'] # optional parameters # --------------------- # if present, alternate between long and short sales alternate = params.get('alternate') # if present, expect transaction amounts to match orders exactly. complete_fill = params.get('complete_fill') env = TradingEnvironment() sid = 1 if trade_interval < timedelta(days=1): sim_params = factory.create_simulation_parameters( data_frequency="minute") minutes = env.market_minute_window( sim_params.first_open, int((trade_interval.total_seconds() / 60) * trade_count) + 100) price_data = np.array([10.1] * len(minutes)) assets = { sid: pd.DataFrame({ "open": price_data, "high": price_data, "low": price_data, "close": price_data, "volume": np.array([100] * len(minutes)), "dt": minutes }).set_index("dt") } write_bcolz_minute_data( env, env.days_in_range(minutes[0], minutes[-1]), tempdir.path, assets) equity_minute_reader = BcolzMinuteBarReader(tempdir.path) data_portal = DataPortal( env, equity_minute_reader=equity_minute_reader, ) else: sim_params = factory.create_simulation_parameters( data_frequency="daily") days = sim_params.trading_days assets = { 1: pd.DataFrame( { "open": [10.1] * len(days), "high": [10.1] * len(days), "low": [10.1] * len(days), "close": [10.1] * len(days), "volume": [100] * len(days), "day": [day.value for day in days] }, index=days) } path = os.path.join(tempdir.path, "testdata.bcolz") DailyBarWriterFromDataFrames(assets).write(path, days, assets) equity_daily_reader = BcolzDailyBarReader(path) data_portal = DataPortal( env, equity_daily_reader=equity_daily_reader, ) if "default_slippage" not in params or \ not params["default_slippage"]: slippage_func = FixedSlippage() else: slippage_func = None blotter = Blotter(sim_params.data_frequency, self.env.asset_finder, slippage_func) env.write_data( equities_data={ sid: { "start_date": sim_params.trading_days[0], "end_date": sim_params.trading_days[-1] } }) start_date = sim_params.first_open if alternate: alternator = -1 else: alternator = 1 tracker = PerformanceTracker(sim_params, self.env) # replicate what tradesim does by going through every minute or day # of the simulation and processing open orders each time if sim_params.data_frequency == "minute": ticks = minutes else: ticks = days transactions = [] order_list = [] order_date = start_date for tick in ticks: blotter.current_dt = tick if tick >= order_date and len(order_list) < order_count: # place an order direction = alternator**len(order_list) order_id = blotter.order( blotter.asset_finder.retrieve_asset(sid), order_amount * direction, MarketOrder()) order_list.append(blotter.orders[order_id]) order_date = order_date + order_interval # move after market orders to just after market next # market open. if order_date.hour >= 21: if order_date.minute >= 00: order_date = order_date + timedelta(days=1) order_date = order_date.replace(hour=14, minute=30) else: bar_data = BarData(data_portal, lambda: tick, sim_params.data_frequency) txns, _ = blotter.get_transactions(bar_data) for txn in txns: tracker.process_transaction(txn) transactions.append(txn) for i in range(order_count): order = order_list[i] self.assertEqual(order.sid, sid) self.assertEqual(order.amount, order_amount * alternator**i) if complete_fill: self.assertEqual(len(transactions), len(order_list)) total_volume = 0 for i in range(len(transactions)): txn = transactions[i] total_volume += txn.amount if complete_fill: order = order_list[i] self.assertEqual(order.amount, txn.amount) self.assertEqual(total_volume, expected_txn_volume) self.assertEqual(len(transactions), expected_txn_count) cumulative_pos = tracker.position_tracker.positions[sid] if total_volume == 0: self.assertIsNone(cumulative_pos) else: self.assertEqual(total_volume, cumulative_pos.amount) # the open orders should not contain sid. oo = blotter.open_orders self.assertNotIn(sid, oo, "Entry is removed when no open orders") finally: tempdir.cleanup()
def initialize(self, *args, **kwargs): self.refresh_period = kwargs.pop('refresh_period', 1) self.window_length = kwargs.pop('window_length', 3) self.args = args self.kwargs = kwargs self.history_return_price_class = [] self.history_return_price_decorator = [] self.history_return_args = [] self.history_return_arbitrary_fields = [] self.history_return_nan = [] self.history_return_sid_filter = [] self.history_return_field_filter = [] self.history_return_field_no_filter = [] self.history_return_ticks = [] self.history_return_not_full = [] self.return_price_class = ReturnPriceBatchTransform( refresh_period=self.refresh_period, window_length=self.window_length, clean_nans=False) self.return_price_decorator = return_price_batch_decorator( refresh_period=self.refresh_period, window_length=self.window_length, clean_nans=False) self.return_args_batch = return_args_batch_decorator( refresh_period=self.refresh_period, window_length=self.window_length, clean_nans=False) self.return_arbitrary_fields = return_data( refresh_period=self.refresh_period, window_length=self.window_length, clean_nans=False) self.return_nan = return_price_batch_decorator( refresh_period=self.refresh_period, window_length=self.window_length, clean_nans=True) self.return_sid_filter = return_price_batch_decorator( refresh_period=self.refresh_period, window_length=self.window_length, clean_nans=True, sids=[0]) self.return_field_filter = return_data( refresh_period=self.refresh_period, window_length=self.window_length, clean_nans=True, fields=['price']) self.return_field_no_filter = return_data( refresh_period=self.refresh_period, window_length=self.window_length, clean_nans=True) self.return_not_full = return_data(refresh_period=0, window_length=self.window_length, compute_only_full=False) self.uses_ufunc = uses_ufunc(refresh_period=self.refresh_period, window_length=self.window_length, clean_nans=False) self.price_multiple = price_multiple( refresh_period=self.refresh_period, window_length=self.window_length, clean_nans=False) self.iter = 0 self.set_slippage(FixedSlippage())
def initialize(self, window_length=100): self.set_slippage(FixedSlippage()) self.invested = False self.regression_transform = regression_transform(refresh_period=500, window_length=window_length)
def test_order_rejection(self): blotter = SimulationBlotter() # Reject a nonexistent order -> no order appears in new_order, # no exceptions raised out blotter.reject(56) assert blotter.new_orders == [] # Basic tests of open order behavior open_order_id = blotter.order(self.asset_24, 100, MarketOrder()) second_order_id = blotter.order(self.asset_24, 50, MarketOrder()) assert len(blotter.open_orders[self.asset_24]) == 2 open_order = blotter.open_orders[self.asset_24][0] assert open_order.status == ORDER_STATUS.OPEN assert open_order.id == open_order_id assert open_order in blotter.new_orders # Reject that order immediately (same bar, i.e. still in new_orders) blotter.reject(open_order_id) assert len(blotter.new_orders) == 2 assert len(blotter.open_orders[self.asset_24]) == 1 still_open_order = blotter.new_orders[0] assert still_open_order.id == second_order_id assert still_open_order.status == ORDER_STATUS.OPEN rejected_order = blotter.new_orders[1] assert rejected_order.status == ORDER_STATUS.REJECTED assert rejected_order.reason == "" # Do it again, but reject it at a later time (after tradesimulation # pulls it from new_orders) blotter = SimulationBlotter() new_open_id = blotter.order(self.asset_24, 10, MarketOrder()) new_open_order = blotter.open_orders[self.asset_24][0] assert new_open_id == new_open_order.id # Pretend that the trade simulation did this. blotter.new_orders = [] rejection_reason = "Not enough cash on hand." blotter.reject(new_open_id, reason=rejection_reason) rejected_order = blotter.new_orders[0] assert rejected_order.id == new_open_id assert rejected_order.status == ORDER_STATUS.REJECTED assert rejected_order.reason == rejection_reason # You can't reject a filled order. # Reset for paranoia blotter = SimulationBlotter() blotter.slippage_models[Equity] = FixedSlippage() filled_id = blotter.order(self.asset_24, 100, MarketOrder()) filled_order = None blotter.current_dt = self.sim_params.sessions[-1] bar_data = self.create_bardata( simulation_dt_func=lambda: self.sim_params.sessions[-1], ) txns, _, closed_orders = blotter.get_transactions(bar_data) for txn in txns: filled_order = blotter.orders[txn.order_id] blotter.prune_orders(closed_orders) assert filled_order.id == filled_id assert filled_order in blotter.new_orders assert filled_order.status == ORDER_STATUS.FILLED assert filled_order not in blotter.open_orders[self.asset_24] blotter.reject(filled_id) updated_order = blotter.orders[filled_id] assert updated_order.status == ORDER_STATUS.FILLED