def handle_data(self, data): if self.target_shares == 0: assert 0 not in self.portfolio.positions self.order(self.sid(0), 10) self.target_shares = 10 return else: assert self.portfolio.positions[0].amount == \ self.target_shares, "Orders not filled immediately." assert self.portfolio.positions[0].last_sale_price == \ data.current(sid(0), "price"), \ "Orders not filled at current price." self.order_percent(self.sid(0), .001) if isinstance(self.sid(0), Equity): price = data.current(sid(0), "price") new_shares = (.001 * self.portfolio.portfolio_value) / price elif isinstance(self.sid(0), Future): new_shares = (.001 * self.portfolio.portfolio_value) / \ (data.current(sid(0), "price") * self.sid(0).contract_multiplier) new_shares = int(round_if_near_integer(new_shares)) self.target_shares += new_shares
def handle_data(self, data): if not self.ordered: assert not self.portfolio.positions else: # Since you can't own fractional shares (at least in this # example), we want to make sure that our target amount is # no more than a share's value away from our current # holdings. target_value = self.portfolio.portfolio_value * 0.002 position_value = self.portfolio.positions[0].amount * \ self.sale_price assert ( abs(target_value - position_value) <= self.sale_price ), "Orders not filled correctly" assert ( self.portfolio.positions[0].last_sale_date == self.get_datetime() ), "Orders not filled at current price." self.sale_price = data.current(sid(0), "price") self._order(sid(0), .002) self.ordered = True
def initialize(context): # Provide the bid-ask spread for each of the securities in the universe. spreads = { sid(24): 0.05, sid(3766): 0.08 } # Initialize slippage settings given the parameters of our model set_slippage(PerStockSpreadSlippage(spreads))
def handle_data(context, data): for stock in data: print stock, sid(stock) if not context.has_ordered: for stock in data: print stock order(sid(stock), 100) context.has_ordered = True print "==================="
def handle_data(self, data): if self.incr == 0: assert 0 not in self.portfolio.positions else: assert self.portfolio.positions[0].amount == \ self.incr, "Orders not filled immediately." assert self.portfolio.positions[0].last_sale_price == \ self.last_price, "Orders was not filled at last price." self.incr += 1 self.order_value(self.sid(0), data.current(sid(0), "price")) self.last_price = data.current(sid(0), "price")
def handle_data_api(context, data): if context.incr == 0: assert 0 not in context.portfolio.positions else: assert context.portfolio.positions[0].amount == context.incr, "Orders not filled immediately." assert context.portfolio.positions[0].last_sale_price == data.current( sid(0), "price" ), "Orders not filled at current price." context.incr += 1 order(sid(0), 1) record(incr=context.incr)
def handle_data(self, data): if self.incr == 0: assert 0 not in self.portfolio.positions else: assert self.portfolio.positions[0].amount == self.incr, "Orders not filled immediately." assert self.portfolio.positions[0].last_sale_price == data.current( sid(0), "price" ), "Orders not filled at current price." self.incr += 2 multiplier = 2.0 if isinstance(self.sid(0), Future): multiplier *= self.sid(0).multiplier self.order_value(self.sid(0), data.current(sid(0), "price") * multiplier)
def handle_data(self, data): if self.target_shares == 0: assert 0 not in self.portfolio.positions self.order(self.sid(0), 10) self.target_shares = 10 return else: assert self.portfolio.positions[0].amount == self.target_shares, "Orders not filled immediately." assert self.portfolio.positions[0].last_sale_price == data.current( sid(0), "price" ), "Orders not filled at current price." self.order_target_value(self.sid(0), 20) self.target_shares = np.round(20 / data.current(sid(0), "price")) if isinstance(self.sid(0), Equity): self.target_shares = np.round(20 / data.current(sid(0), "price")) if isinstance(self.sid(0), Future): self.target_shares = np.round(20 / (data.current(sid(0), "price") * self.sid(0).multiplier))
def handle_data(self, data): if self.target_shares == 0: assert 0 not in self.portfolio.positions else: assert self.portfolio.positions[0].amount == self.target_shares, "Orders not filled immediately." assert self.portfolio.positions[0].last_sale_price == data.current( sid(0), "price" ), "Orders not filled at current price." self.target_shares = 10 self.order_target(self.sid(0), self.target_shares)
def compute(self, today, asset_ids, out, *inputs): #print asset_ids #print maskset if asset_finder != None: assets = [_sid(id).symbol for id in asset_ids] else: assets = [sid(id).symbol for id in asset_ids] #print "--------------" #print pd.Series(assets) out[:] = pd.Series(assets).isin(maskdf.index)
def handle_data(self, data): if self.incr == 0: assert 0 not in self.portfolio.positions else: assert self.portfolio.positions[0]['amount'] == \ self.incr, "Orders not filled immediately." assert self.portfolio.positions[0]['last_sale_price'] == \ data.current(sid(0), "price"), \ "Orders not filled at current price." self.incr += 2 multiplier = 2. if isinstance(self.sid(0), Future): multiplier *= self.sid(0).multiplier self.order_value( self.sid(0), data.current(sid(0), "price") * multiplier )
def handle_data(self, data): if self.incr == 0: assert 0 not in self.portfolio.positions else: assert self.portfolio.positions[0]["amount"] == self.incr, "Orders not filled immediately." assert self.portfolio.positions[0]["last_sale_price"] == data.current( sid(0), "price" ), "Orders not filled at current price." self.incr += 1 self.order(self.sid(0), 1)
def handle_data(self, data): if self.incr == 0: assert 0 not in self.portfolio.positions else: assert self.portfolio.positions[0].amount == \ self.incr, "Orders not filled immediately." assert self.portfolio.positions[0].last_sale_price == \ data.current(sid(0), "price"), \ "Orders not filled at current price." self.incr += 1 self.order(self.sid(0), 1)
def handle_data(self, data): if self.target_shares == 0: assert 0 not in self.portfolio.positions else: assert self.portfolio.positions[0].amount == \ self.target_shares, "Orders not filled immediately." assert self.portfolio.positions[0].last_sale_price == \ data.current(sid(0), "price"), \ "Orders not filled at current price." self.target_shares = 10 self.order_target(self.sid(0), self.target_shares)
def handle_data(context, data): # 获取股票的收盘价 close_data = history(12,'1d','close') # 取得过去五天的平均价格 ma5 = close_data[-6:-2].mean() # 取得过去10天的平均价格 ma10 = close_data[-11:-2].mean() # 取得当前的现金 print get_datetime(),ma5,ma10 cash = context.portfolio.cash #print ma5[sid(symbol(context.security))],ma10[sid(stock)],cash,symbol(context.security) #如果当前有余额,并且五日均线大于十日均线 if ma5[sid(symbol(context.security))] > ma10[sid(symbol(context.security))]: order_value(symbol(context.security), cash) # 如果五日均线小于十日均线,并且目前有头寸 elif ma5[sid(symbol(context.security))] < ma10[sid(symbol(context.security))]: # 全部卖出 order_target(symbol(context.security), 0)
def handle_data(self, data): if self.target_shares == 0: assert 0 not in self.portfolio.positions self.order(self.sid(0), 10) self.target_shares = 10 return else: assert self.portfolio.positions[0].amount == \ self.target_shares, "Orders not filled immediately." assert self.portfolio.positions[0].last_sale_price == \ data.current(sid(0), "price"), \ "Orders not filled at current price." self.order_target_value(self.sid(0), 20) self.target_shares = np.round(20 / data.current(sid(0), "price")) if isinstance(self.sid(0), Equity): self.target_shares = np.round(20 / data.current(sid(0), "price")) if isinstance(self.sid(0), Future): self.target_shares = np.round( 20 / (data.current(sid(0), "price") * self.sid(0).multiplier))
def handle_data_api(context, data): if context.incr == 0: assert 0 not in context.portfolio.positions else: assert context.portfolio.positions[0]['amount'] == \ context.incr, "Orders not filled immediately." assert context.portfolio.positions[0]['last_sale_price'] == \ data[0].price, "Orders not filled at current price." context.incr += 1 order(sid(0), 1) record(incr=context.incr)
def handle_data_api(context, data): if context.incr == 0: assert 0 not in context.portfolio.positions else: assert (context.portfolio.positions[0].amount == context.incr ), "Orders not filled immediately." assert (context.portfolio.positions[0].last_sale_date == context. get_datetime()), "Orders not filled at current datetime." context.incr += 1 order(sid(0), 1) record(incr=context.incr)
def zmq_event_gen(self, port=5555): context = zmq.Context() price_socket = context.socket(zmq.REQ) price_socket.connect('tcp://localhost:%s' % port) orders_socket = context.socket(zmq.PUB) orders_socket.bind('tcp://*:%s' % (port+1)) for dt in self.sim_params.trading_days: prices = [] # Investigate the asset_finder class. How might data be stored? for sid_id in self.trading_environment.asset_finder.sids: prompt = "{} [{}]".format(dt, sid(sid_id)) price_socket.send_string(prompt) data = price_socket.recv_string() price = float(data) # Look at DataFrameSource to see that the dataframe input # quickly gets turned into a series of events (that are yielded) event = { 'dt': dt, 'sid': sid(sid_id), 'price': float(price), 'volume': 1e9, 'type': DATASOURCE_TYPE.TRADE, } event = Event(event) prices.append(event) # We return a generator. Zipline makes heavy use of `yield` and generators # to build an event-driven model that runs syncronously]. # How could we modify an algoithm to run async? yield dt, prices # What columns are being displayed? # Why might some orders have a commission and others are NAN? # 'orders' is a collection of all orders placed. # How could we change this to include open_orders? show_orders(self.blotter.orders, orders_socket)
def handle_data(self, data): if self.incr == 0: assert len(self.portfolio.positions.keys()) == 0 method_to_check = getattr(self, self.method_name) method_to_check(self.sid(133), data.current(sid(0), "price"), style=StopLimitOrder(10, 10)) assert len(self.blotter.open_orders[self.sid(133)]) == 1 result = self.blotter.open_orders[self.sid(133)][0] assert result.limit == 10 assert result.stop == 10 self.incr += 1
def handle_data(self, data): if not self.ordered: assert 0 not in self.portfolio.positions else: # Since you can't own fractional shares (at least in this # example), we want to make sure that our target amount is # no more than a share's value away from our current # holdings. target_value = self.portfolio.portfolio_value * 0.002 position_value = self.portfolio.positions[0].amount * \ self.sale_price assert abs(target_value - position_value) <= self.sale_price, \ "Orders not filled correctly" assert self.portfolio.positions[0].last_sale_price == \ data.current(sid(0), "price"), \ "Orders not filled at current price." self.sale_price = data.current(sid(0), "price") self.order_target_percent(self.sid(0), .002) self.ordered = True
def findSector(self, assets): sector_list = [] for msid in assets: stock = sid(msid).symbol try: industry = basic.loc[stock].industry sector_no = sector_dict[industry] sector_list.append(sector_no) except: #print "stock %s in industry %s not find in default sector set, set zero" % (stock,industry) sector_list.append(self.missing_value) else: pass return sector_list
def compute(self, today, assets, out, *inputs): if trigger_date != None and today != pd.Timestamp(trigger_date, tz='UTC'): return if os.path.splitext(source)[1] == '.csv': df = pd.read_csv(source, index_col=0, parse_dates=True) # df = df[df.index >= pd.Timestamp(str(today))] print today, df else: raise ValueError new_index = [sid(asset).symbol + "_return" for asset in assets] df = df.reindex(columns=new_index) out[:] = df.ix[0].values print "RNNpredict:", today, out
def get_sectors_no(mids): basic = load_tushare_df("basic") _class, _ = get_sector_class() no_ = [] missing_value = 0 for msid in mids: stock = sid(msid).symbol try: industry = basic.loc[stock].industry sector_no = _class[industry] no_.append(sector_no) except: # print "stock %s in industry %s not find in default sector set, set zero" % (stock,industry) no_.append(missing_value) return no_
def initialize(context): """ Called once at the start of a backtest, and once per day at the start of live trading. """ # Attach the pipeline to the algo algo.attach_pipeline(make_pipeline(), 'pipeline') algo.set_benchmark(algo.sid('FIBBG000BDTBL9')) # Rebalance every day, 30 minutes before market close. algo.schedule_function( rebalance, algo.date_rules.every_day(), algo.time_rules.market_close(minutes=30), )
def handle_data_api(context, data): if context.incr == 0: assert 0 not in context.portfolio.positions else: assert ( context.portfolio.positions[0].amount == context.incr ), "Orders not filled immediately." assert ( context.portfolio.positions[0].last_sale_date == context.get_datetime() ), "Orders not filled at current datetime." context.incr += 1 order(sid(0), 1) record(incr=context.incr)
def _find_sector(self, asset): sector_no = 0 sector_name = "" if asset_finder != None: stock = _sid(asset).symbol else: stock = sid(asset).symbol try: industry = basic.loc[stock].industry sector_no = sector_dict[industry] sector_name = industry except: #print "stock %s in not find in default sector set, set zero" % (stock) pass else: pass return sector_no, sector_name
def bonds(context, data): logger.debug('buying bonds on: %s', algo.get_datetime()) logger.debug('num open orders: %s', len(algo.get_open_orders())) logger.debug('len existing portfolio (afer ejection): %s', len(context.portfolio.positions)) logger.debug('cash: %s', context.portfolio.cash) logger.debug('portfolio_value: %s', context.portfolio.portfolio_value) logger.debug('num_positions: %s', len(context.portfolio.positions)) logger.debug('positions: %s', context.portfolio.positions) if logger.level is logging.DEBUG: for equity, values in context.portfolio.positions.items(): logger.debug( 'context.portfolio.positions - equity: %s, amount: %s, cost_basis: %s, sold_on: %s, sold_at_price: %s', equity, values.amount, values.cost_basis, values.last_sale_date, values.last_sale_price) if context.portfolio.cash > 0 and context.trend_filter is False: logger.debug('converting all cash to bonds') order_target_value(algo.sid('FIBBG000NTFYM5'), context.portfolio.cash)
def handle_data(self, data): if self.incr == 0: assert 0 not in self.portfolio.positions else: assert ( self.portfolio.positions[0].amount == self.incr ), "Orders not filled immediately." assert ( self.portfolio.positions[0].last_sale_date == self.get_datetime() ), "Orders not filled at current datetime." self.incr += 2 multiplier = 2. if isinstance(self.sid(0), Future): multiplier *= self.sid(0).multiplier self.order_value( self.sid(0), data.current(sid(0), "price") * multiplier )
def compute(self, today, assets, out, *inputs): if trigger_date != None and today != pd.Timestamp( trigger_date, tz='UTC' ): # 仅仅是最重的预测factor给定时间执行了,其他的各依赖factor还是每次computer调用都执行,也流是每天都执行! 不理想 return if os.path.splitext(source)[1] == '.db': conn = sqlite3.connect( source, check_same_thread=False) #预测过程由外部程序完成,结果写入到数据库中 query = "select * from predict where date >= '%s' order by date limit 1 " % str( today)[:19] df = pd.read_sql(query, conn) df = df.set_index('date') conn.close() elif os.path.splitext(source)[1] == '.csv': df = pd.read_csv("predict.csv", index_col=0, parse_dates=True) df = df[df.index >= pd.Timestamp(str(today))] print today, df else: raise ValueError new_index = [sid(asset).symbol + "_return" for asset in assets] df = df.reindex(columns=new_index) out[:] = df.ix[0].values print "RNNpredict:", today, out
import pytz from datetime import datetime from zipline.api import order, symbol, record, order_target, sid from zipline.algorithm import TradingAlgorithm from zipline.utils.factory import load_bars_from_yahoo from zipline import api dow_constituents = [ ["1999-11-01", sid(4922), 1], # Minnesota Mining & Manufacturing/3M Company ["1999-11-01", sid(2), 1], ["1999-11-01", sid(679), 1], ["1999-11-01", sid(7289), 1], # AT&T Corporation ["1999-11-01", sid(698), 1], ["1999-11-01", sid(1267), 1], ["1999-11-01", sid(1335), 1], ["1999-11-01", sid(4283), 1], ["1999-11-01", sid(2119), 1], ["1999-11-01", sid(2482), 1], ["1999-11-01", sid(8347), 1], ["1999-11-01", sid(3149), 1], ["1999-11-01", sid(3246), 1], ["1999-11-01", sid(3735), 1], ["1999-11-01", sid(3496), 1], ["1999-11-01", sid(25090), 1], # AlliedSignal Incorporated/Honeywell ["1999-11-01", sid(3951), 1], ["1999-11-01", sid(3766), 1], ["1999-11-01", sid(3971), 1], ["1999-11-01", sid(25006), 1], ["1999-11-01", sid(4151), 1], ["1999-11-01", sid(4707), 1], ["1999-11-01", sid(5029), 1],
def handle_data(context, data): print context #raw_input() #输出每天持仓情况 if not context.has_ordered: for stock in data: #openprice=history(3, '1d', 'open') closeprice = history(5, '1d', 'close') #-2:昨天,-3 前天.-4 大前天 print get_datetime(), closeprice[sid(stock)][0], closeprice[sid( stock)][1], closeprice[sid(stock)][2], closeprice[sid( stock)][3], closeprice[sid(stock)][4] #print closeprice,closeprice[sid(stock)][1] if closeprice[sid(stock)][-2] > closeprice[sid( stock)][-3] and closeprice[sid(stock)][-3] > closeprice[ sid(stock)][-4]: print "buy", get_datetime() order(stock, 300) elif closeprice[sid(stock)][-2] < closeprice[sid( stock)][-3] and closeprice[sid(stock)][-3] < closeprice[ sid(stock)][-4]: print "sell", get_datetime() order(stock, -300)
def initialize(context): """ Called once at the start of the algorithm. """ # STANDARD SETTINGS # set_benchmark(sid(8554)) #SPY # set_slippage(slippage.FixedSlippage(spread=0.00)) # set_commission(commission.PerShare(cost=0.0, min_trade_cost=0)) # DAILY, WEEKLY, MONTHLY context.rebalance_frequency = RebalanceFrequency.DAILY # Must be a positive integer, refer to parameters of each function # rebalance_number = 5 if RebalanceFrequency.DAILY and you want to rebalance every 5 days # rebalance_number = 3 if RebalanceFrequency.MONTHLY and you want to rebalance every 3 months context.rebalance_number = 1 context.lookback = 42 # Default universe context.securities = [ (sid(19662)), #XLY (sid(21652)), #IYR (sid(21647)), #IYG (sid(19656)), #XLF (sid(19658)), #XLK (sid(19655)), #XLE (sid(19661)), #XLV (sid(19657)), #XLI (sid(19659)), #XLP (sid(19654)), #XLB (sid(19660)) #XlU ] # Run at the start of each month, when the market opens and rebalance zipline.schedule_function(rebalance, context.rebalance_frequency, time_rule=zipline.time_rules.market_open())
def rebalance(context, data): """ Execute orders according to our schedule_function() timing. """ logger.debug('rebalancing on: %s', algo.get_datetime()) context.trend_filter = False # new_portfolio = algo.pipeline_output('pipeline').dropna(subset=['overall_rank']).sort_values('momentum', ascending=False) new_portfolio = algo.pipeline_output('pipeline').dropna( subset=['overall_rank']).sort_values('momentum', ascending=False) for equity, row in new_portfolio.iterrows(): logger.debug('new portfolio (before filtering) - equity: %s', equity) # print(new_portfolio) # new_portfolio = new_portfolio[new_portfolio['overall_rank'].notna() & new_portfolio['momentum'] > 40][:20] # new_portfolio = new_portfolio[(new_portfolio['momentum_decile'] > 8)][:20] new_portfolio = new_portfolio.nlargest( 20, ['overall_rank', 'momentum']) #<- $600K PL in 10 years # new_portfolio = new_portfolio.nlargest(20, ['momentum', 'overall_rank']) #<- 1M PL in 10 years if logger.level is logging.DEBUG: for equity, row in new_portfolio.iterrows(): logger.debug('new portfolio - (after filtering) equity: %s', equity) # print(len(new_portfolio.index)) # volatility driven weights # new_portfolio['inverse_volatility'] = new_portfolio['volatility'].apply(lambda x: 1 / x) # inv_vola_sum = new_portfolio['inverse_volatility'].sum() # new_portfolio['target_weight'] = new_portfolio['inverse_volatility'].apply(lambda x: x / inv_vola_sum) # portfolio size driven weights # num_equities = len(new_portfolio.index) # new_portfolio['target_weight'] = 1 / num_equities\ # logger.info('len existing portfolio: %s', len(context.portfolio.positions)) if logger.level is logging.DEBUG: for equity, values in context.portfolio.positions.items(): logger.debug( 'context.portfolio.positions - equity: %s, amount: %s, cost_basis: %s, sold_on: %s, sold_at_price: %s', equity, values.amount, values.cost_basis, values.last_sale_date, values.last_sale_price) order_target(algo.sid('FIBBG000NTFYM5'), 0) logger.debug('selling all bonds') for equity in context.portfolio.positions: if equity is algo.sid('FIBBG000NTFYM5'): continue if equity not in set(new_portfolio.index.tolist()): # logger.info('selling %s', equity) order_target_percent(equity, 0) stock_weights = 1.0 / max(len(context.portfolio.positions), len(new_portfolio.index)) logger.debug('len existing portfolio (afer ejection): %s', len(context.portfolio.positions)) logger.debug('len new portfolio: %s', len(new_portfolio.index)) logger.debug('stock_weights: %s', stock_weights) # print(context.portfolio.positions.get(algo.sid('FIBBG000NTFYM5'))) # spy = context.portfolio.positions.get(algo.sid('FIBBG000NTFYM5')) # if (spy is not None) and (spy.amount > 0): # order_target_percent(algo.sid('FIBBG000NTFYM5'), 0) for equity, row in new_portfolio.iterrows(): if row.trend_filter is True: # logger.info('buying %s', equity) context.trend_filter = True order_target_percent(equity, stock_weights) else: context.trend_filter = False logger.debug('cash: %s', context.portfolio.cash) logger.debug('portfolio_value: %s', context.portfolio.portfolio_value) logger.debug('num_positions: %s', len(context.portfolio.positions)) logger.debug('positions: %s', context.portfolio.positions)
def handle_data(context, data): log.info(f"Trade date {data.current_session}") # look for existing strategies to exit first which avoids immeditely # exiting an entered strategy if context.complex_positions: log.info(f"Found positions to trade: {context.complex_positions}") for complex_position in context.complex_positions: log.info(f"Processing {data.current_session}") # check if any date to exit trade has been exceeded. using any # covers the case where there are uneven expirations. this is a bad # approach because naively takes dte without considering trading days # if trade_exit_dte_breached is true, exit trade (covered in if below) dte_session_ = partial( dte_session, context.trading_calendar, context.backtest_params["trade_exit_dte"], ) trade_exit_dte_reached = any([ context.datetime >= dte_session_( sid(leg.option).expiration_date) for leg in complex_position ]) # compute the cost basis of the position which is used to decide whether # to exit position based on the position stop loss. execution price # would be better than cost_basis but this value doesn't seem to exist cost_basis = sum([ context.portfolio.positions[leg.option].cost_basis * np.copysign(1, context.portfolio.positions[leg.option].amount) for leg in complex_position ]) # aggregate the current value of the position based on the last_sale_price # which is the mid price. mid is probably a decent estimate of the closing # price for atm liquid options current_value = sum([ context.portfolio.positions[leg.option].last_sale_price * np.copysign(1, context.portfolio.positions[leg.option].amount) for leg in complex_position ]) # if the curent value of the position, which is negative if a credit, # gets closer to 0 e.g. increases e.g. spreads start to collapse, we're # making money. therefore if the current_value is greater than the # basis minus what money we want to make, we buy back the position at # a winner # if the current value of the position, which is negative if a credit, # goes further negative e.g. spreads continue to widen, we're losing # money. therefore if the current_value is less than the basis # plus the stop loss percent, we buy back the position at a loser is_debit = is_long = cost_basis > 0 stop_reached, limit_reached = check_order_triggers( current_value, is_debit, is_long, stop_price=context.stop_percent * cost_basis, limit_price=context.limit_percent * cost_basis, ) print( f"current_value={current_value} stop_price={context.stop_percent * cost_basis} limit_price={context.limit_percent * cost_basis}" ) if stop_reached or limit_reached or trade_exit_dte_reached: print("in exit ") [order(leg.option, -leg.amount) for leg in complex_position] context.complex_positions.remove(complex_position) chain = option_chain(context.root_symbol, data.current_session) ic = IronCondors(chain, **context.backtest_params) trades = ic.get_trades() if not trades.empty: for _, trade in trades.iterrows(): sids = trade[[ "short_call_sid", "long_call_sid", "short_put_sid", "long_put_sid" ]].values amounts = trade[[ "short_call_amount", "long_call_amount", "short_put_amount", "long_put_amount", ]].values # add the orders [order(sid(s), a) for s, a in zip(sids, amounts)] # track the orders context.complex_positions.append( [Leg(sid(s), a) for s, a in zip(sids, amounts)])
def initialize(context): context.aapl = sid(24) schedule_function(ma_crossover_handling, date_rules.every_day(), time_rules.market_open(hours=1))
def initialize(context): dates = pd.date_range('2018-01-01', '2018-09-28') # assets = bundle_data.asset_finder.lookup_symbols(['A', 'AAL'], as_of_date=None) # assets = bundle_data.asset_finder sids = bundle_data.asset_finder.sids assets = [sid(item) for item in sids] # The values for Column A will just be a 2D array of numbers ranging from 1 -> N. column_A_frame = pd.DataFrame( data=np.arange(len(dates) * len(assets), dtype=float).reshape(len(dates), len(assets)), index=dates, columns=sids, ) # Column B will always provide True for 0 and False for 1. column_B_frame = pd.DataFrame(data={sids[0]: True, sids[1]: False}, index=dates) loaders = { MyDataSet.column_A: DataFrameLoader(MyDataSet.column_A, column_A_frame), MyDataSet.column_B: DataFrameLoader(MyDataSet.column_B, column_B_frame), } def my_dispatcher(column): return loaders[column] # Set up pipeline engine # Loader for pricing pipeline_loader = USEquityPricingLoader( bundle_data.equity_daily_bar_reader, bundle_data.adjustment_reader, ) def choose_loader(column): if column in USEquityPricing.columns: return pipeline_loader return my_dispatcher(column) engine = SimplePipelineEngine( get_loader=choose_loader, calendar=trading_calendar.all_sessions, asset_finder=bundle_data.asset_finder, ) p = Pipeline( columns={ 'price': USEquityPricing.close.latest, 'col_A': MyDataSet.column_A.latest, 'col_B': MyDataSet.column_B.latest }, screen=StaticAssets(assets) ) df = engine.run_pipeline( p, pd.Timestamp('2016-01-07', tz='utc'), pd.Timestamp('2016-01-07', tz='utc') ) df = df.sort_values(by=['price'], axis=0, ascending=False) print(df)
def initialize(context): bundle_data = bundles.load('quandl') sids = bundle_data.asset_finder.sids symbols = [sid(item) for item in sids]
def handle_data(context, data): if not context.has_ordered: for stock in data: order(sid(stock), 100) context.has_ordered = True
def __init__(self): ''' this is a utility class that can return the list of Dow30 stocks for a given date. the input date must be >= 1999-11-01. source: http://www.djindexes.com/mdsidx/downloads/brochure_info/Dow_Jones_Industrial_Average_Historical_Components.pdf ''' raw_constituents = [ ["1999-11-01", sid(4922), 1], # Minnesota Mining & Manufacturing/3M Company ["1999-11-01", sid(2), 1], ["1999-11-01", sid(679), 1], ["1999-11-01", sid(7289), 1], # AT&T Corporation ["1999-11-01", sid(698), 1], ["1999-11-01", sid(1267), 1], ["1999-11-01", sid(1335), 1], ["1999-11-01", sid(4283), 1], ["1999-11-01", sid(2119), 1], ["1999-11-01", sid(2482), 1], ["1999-11-01", sid(8347), 1], ["1999-11-01", sid(3149), 1], ["1999-11-01", sid(3246), 1], ["1999-11-01", sid(3735), 1], ["1999-11-01", sid(3496), 1], ["1999-11-01", sid(25090), 1], # AlliedSignal Incorporated/Honeywell ["1999-11-01", sid(3951), 1], ["1999-11-01", sid(3766), 1], ["1999-11-01", sid(3971), 1], ["1999-11-01", sid(25006), 1], ["1999-11-01", sid(4151), 1], ["1999-11-01", sid(4707), 1], ["1999-11-01", sid(5029), 1], ["1999-11-01", sid(5061), 1], ["1999-11-01", sid(4954), 1], ["1999-11-01", sid(5938), 1], ["1999-11-01", sid(6653), 1], # SBC Communications Incorporated/AT&T Incorporated ["1999-11-01", sid(7883), 1], ["1999-11-01", sid(8229), 1], ["1999-11-01", sid(2190), 1], ["2004-04-08", sid(7289), 0], ["2004-04-08", sid(2482), 0], ["2004-04-08", sid(3971), 0], ["2004-04-08", sid(239), 1], ["2004-04-08", sid(5923), 1], ["2004-04-08", sid(21839), 1], ["2008-02-19", sid(4954), 0], ["2008-02-19", sid(25090), 0], ["2008-02-19", sid(700), 1], ["2008-02-19", sid(23112), 1], ["2008-09-22", sid(239), 0], ["2008-09-22", sid(22802), 1], # KRFT/MDLZ ["2009-06-08", sid(1335), 0], ["2009-06-08", sid(3246), 0], ["2009-06-08", sid(7041), 1], ["2009-06-08", sid(1900), 1], ["2012-09-24", sid(22802), 0], ["2012-09-24", sid(7792), 1], ["2013-09-23", sid(700), 0], ["2013-09-23", sid(3735), 0], ["2013-09-23", sid(20088), 1], ["2013-09-23", sid(35920), 1], ["2015-03-18", sid(6653), 0], ["2015-03-18", sid(24), 1] ] # translate the date string into a datetime.date self.data = [] for equity in raw_constituents: self.data.append(( datetime.datetime.strptime(equity[0], "%Y-%m-%d").date(), equity[1], equity[2] ))