def main(argv): # create trader object trader = shift.Trader("democlient") # connect and subscribe to all available order books try: trader.connect("initiator.cfg", "password") trader.subAllOrderBook() except shift.IncorrectPassword as e: print(e) except shift.ConnectionTimeout as e: print(e) # demo01(trader) # demo02(trader) # demo03(trader) # demo04(trader) # demo05(trader) # demo06(trader) # demo07(trader) # demo08(trader) # demo09(trader) # demo10(trader) # disconnect trader.disconnect() return
def main(argv): # create trader object trader = shift.Trader("test001") # connect and subscribe to all available order books try: trader.connect("initiator.cfg", "password") trader.sub_all_order_book() except shift.IncorrectPasswordError as e: print(e) except shift.ConnectionTimeoutError as e: print(e) for _ in range(10): # demo_01(trader) # demo_02(trader) # demo_03(trader) # demo_04(trader) # demo_05(trader) demo_06(trader) # demo_07(trader) # demo_08(trader) # demo_09(trader) # demo_10(trader) time.sleep(600) # disconnect trader.disconnect() return
def subscribe(): trader = shift.Trader("test001") # connect and subscribe to all available order books try: trader.connect("initiator.cfg", "password") trader.sub_all_order_book() except shift.IncorrectPasswordError as e: print(e) except shift.ConnectionTimeoutError as e: print(e) return trader
def main(argv): trader = shift.Trader(credentials.my_username) try: trader.connect("initiator.cfg", credentials.my_password) trader.sub_all_order_book() except shift.IncorrectPasswordError as e: print(e) except shift.ConnectionTimeoutError as e: print(e) time.sleep(2) ticker = "AAPL" ticker_data = {} que = queue.Queue() t = threading.Thread(target=que.put(collect_data(trader, ticker)), name='ticker_data_one') t.start() t.join() ticker_data[ticker] = que.get() should_long = ticker_data[ticker]["long"] if should_long: tickers = ["NKE", "INTC", "AAPL", "BA"] long_thread = threading.Thread(target=longer, args=[trader, tickers], name='longer_thread') long_thread.start() routine_summary_thread = threading.Thread(target=routine_summary, args=[trader], name='routine_summary') routine_summary_thread.start() long_thread.join() routine_summary_thread.join() else: long_and_short_aapl = threading.Thread(target=market_maker_one, args=[trader, ticker], name='long_and_short') routine_summary_thread = threading.Thread(target=routine_summary, args=[trader], name='routine_summary') routine_summary_thread.start() long_and_short_aapl.start() long_and_short_aapl.join() routine_summary_thread.join() trader.disconnect()
def __init__(self): """ Virtually private constructor. """ if TraderS.__instance != None: raise Exception("This class is a singleton!") else: try: # create trader object trader = shift.Trader(my_username) # connection & subs to order_book trader.connect("initiator.cfg", my_password) TraderS.__instance = trader except shift.IncorrectPasswordError as e: print(e) except shift.ConnectionTimeoutError as e: print(e)
def main(): # create trader object trader = shift.Trader("test001") # connect and subscribe to all available order books try: trader.connect("initiator.cfg", "password") trader.sub_all_order_book() time.sleep(1) except shift.IncorrectPasswordError as e: print(e) except shift.ConnectionTimeoutError as e: print(e) algo_1(trader) trader.disconnect()
def main(): trader = shift.Trader("test001") try: trader.connect("initiator.cfg", "password") trader.sub_all_order_book() if trader.get_last_trade_time().year == 1969: pass except shift.IncorrectPasswordError as e: print(e) except shift.ConnectionTimeoutError as e: print(e) momentum_strategy(trader, {}) trader.disconnect() return
def main(trader: shift.Trader) -> None: """ main entrypoint """ trader = shift.Trader(credentials.my_username) try: trader.connect("initiator.cfg", credentials.my_password) trader.sub_all_order_book() except shift.IncorrectPasswordError as e: print(e) except shift.ConnectionTimeoutError as e: print(e) time.sleep(2) check_time = 5 # minutes current = trader.get_last_trade_time() start_time = dt.combine(current, dt.datetime(10, 0, 0)) end_time = dt.combine(current, dt.datetime(15, 30, 0)) while trader.get_last_trade_time() < start_time: sleep(check_time * 60) processes = run_processes(trader) while trader.get_last_trade_time() < end_time: sleep(check_time * 60) for order in trader.get_waiting_list(): trader.submit_cancellation(order) for item in trader.get_portfolio_items().values(): ticker = item.get_symbol() sell = shift.Order(shift.Order.Type.MARKET_SELL, ticker, item.get_shares()) trader.submit_order(sell) time_wait_sell = 60 # seconds sleep(time_wait_sell) stop_processes(processes) # print stuff routine_summary(trader)
def __init__(self, username: str, password: str, verbose: bool): self._verbose = verbose self._trader = shift.Trader(username) self._orders = [] self._next_trade_time = None self._available_bp = 0 self._risk_tolerance = 0 if self._verbose: self.__username = username try: print(f"Attempting to connect as {username}...") self._trader.connect("initiator.cfg", password) self._trader.sub_all_order_book() except shift.IncorrectPasswordError as e: print(e) sys.exit(1) except shift.ConnectionTimeoutError as e: print(e) sys.exit(1)
def main(argv): # create trader object trader = shift.Trader("democlient") # connect and subscribe to all available order books try: trader.connect("initiator.cfg", "password") trader.sub_all_order_book() except shift.IncorrectPasswordError as e: print(e) except shift.ConnectionTimeoutError as e: print(e) # limit_buy = shift.Order(shift.Order.Type.LIMIT_BUY, "AAPL", 1, 10.00) # trader.submit_order(limit_buy) # # # for order in trader.get_order_book("AAPL", shift.OrderBookType.LOCAL_BID): # print(order.price) # demo_01(trader) demo_02(trader) demo_03(trader) demo_04(trader) demo_05(trader) demo_06(trader) demo_07(trader) demo_08(trader) demo_09(trader) demo_10(trader) # disconnect trader.disconnect() return
elif t < dt.time(15, 45, 0): dt.sleep(60 * 3) elif t < dt.time(15, 55, 0): dt.sleep(60 * 2) elif t < dt.time(15, 58, 30): dt.sleep(60 * 1) elif t < dt.time(15, 59, 0): dt.sleep(10) else: break return True if __name__ == '__main__': import os print(os.getcwd()) trader = shift.Trader('test001') trader.disconnect() trader.connect('initiator.cfg', 'password') trader.sub_all_order_book() try: dat = pd.read_csv("sample_last_price.csv") sym_ls = list(dat['Symbol']) field_ls = list(dat.columns) if sleep_till_end(trader): df = grab_last_price(trader, sym_ls, field_ls) df.to_csv('last_price.csv') except: trader.disconnect() print('crashed.')
trader = subscribe() for idx, i in enumerate(signals): market_order(order_type=i, symbol=securities[idx], contract_size=10) trader.disconnect() else: time.sleep(30) trader = subscribe() prices, moving_av = update_data(ls, prices) if __name__ == "__main__": trader = shift.Trader("test001") # connect and subscribe to all available order books try: trader.connect("initiator.cfg", "password") trader.sub_all_order_book() except shift.IncorrectPasswordError as e: print(e) except shift.ConnectionTimeoutError as e: print(e) p = trader.get_sample_prices_size("AAPL") ls = trader.get_stock_list() print(p)
def main(argv): ''' STEP 0 ''' # create trader object trader = shift.Trader("test002") #Change this? # trader = shift.Trader("wolves_of_wall_street") # connect and subscribe to all available order books try: trader.connect("initiator.cfg", "password") # trader.connect("initiator.cfg", "ubd7w26JahGS9p4A") trader.subAllOrderBook() except shift.IncorrectPassword as e: print(e) except shift.ConnectionTimeout as e: print(e) ''' STEP 1 ''' # 6.5 hours = 23400 global start start = time.time() #Create PortfolioItems for each company? #Create PortfolioSummary ''' STEP 2 ''' #EXECUTE METHODS stock_data = [] for company in COMPANIES: stock_data.append(Stock(company)) # stock_data.append(Stock(COMPANIES[2])) request_prices(trader) # Make the connection to get sample prices (requestSamplePrices) for all companies while time.time() - start < TIME_TO_STOP_BUY: # 22500 corresponds to 3:45 #Execute trades and stuff s = time.time() for stk in stock_data: STATES_TRANSITION[stk.state](stk, trader) printSummary(trader) ''' STEP 3 ''' while time.time() - start < TIME_TO_SELL: for stk in stock_data: global THRESHOLD global NUM_TRADES price_current = get_current_price(stk.name, trader) pressure = get_pressure(stk.name, trader) # pressure = 1.0 prediction = get_prediction(stk, trader,1,1,0) # if time.time() - start > TIME_TO_STOP_BUY: # THRESHOLD /= 1.5 PURCHASE_SIZE = trader.getPortfolioItem(stk.name).getShares() if PURCHASE_SIZE < 0: continue if (prediction - stk.current_price) / stk.current_price <= -1.0 * THRESHOLD and pressure > 0.0: if expected_sell_return(stk, trader, prediction) > 0: limit_sell = shift.Order(shift.Order.LIMIT_SELL, stk.name, PURCHASE_SIZE, prediction) trader.submitOrder(limit_sell) stk.SO = True stk.state = 3 continue time.sleep(10) #Do this at 3:59? trader.cancelAllSamplePricesRequests() #Cancel the sample prices connection # Cancel all buy orders and sell orders for order in trader.getWaitingList(): if order.type == shift.Order.LIMIT_BUY: order.type = shift.Order.CANCEL_BID trader.submitOrder(order) elif order.type == shift.Order.LIMIT_SELL: order.type = shift.Order.CANCEL_ASK trader.submitOrder(order) #cancelAllPendingOrders(trader) for order in trader.getWaitingList(): print("%6s\t%21s\t%7.2f\t\t%4d\t%36s\t%26s" % (order.symbol, order.type, order.price, order.size, order.id, order.timestamp)) while trader.getWaitingListSize() != 0: #Wait for the orders to go through print("Waiting") time.sleep(3) for company in COMPANIES: # For all holdings, market sell them # For all short positions, market buy # If no holdings for a particular company, do nothing portfolio_item = trader.getPortfolioItem(company) num_shares = int(portfolio_item.getShares()/100) bid_book = trader.getOrderBook(company, shift.OrderBookType.GLOBAL_BID, 1) print(bid_book[0].price) global NUM_TRADES if num_shares > 0: trader.submitOrder(shift.Order(shift.Order.MARKET_SELL,company,size = num_shares) )#Sell at market price NUM_TRADES += 1 elif num_shares < 0: trader.submitOrder(shift.Order(shift.Order.MARKET_BUY, company, size = -1*num_shares)) NUM_TRADES += 1 #Update log with transaction print("printing submitted orders") for order in trader.getSubmittedOrders(): print("%6s\t%21s\t%7.2f\t\t%4d\t%36s\t%26s" % (order.symbol, order.type, order.price, order.size, order.id, order.timestamp)) for company in COMPANIES: portfolio_item = trader.getPortfolioItem(company) num_shares = portfolio_item.getShares() while num_shares != 0: portfolio_item = trader.getPortfolioItem(company) num_shares = portfolio_item.getShares() #Update log #Print summary printSummary(trader) time.sleep(10) print(trader.getPortfolioSummary().getTotalBP()) ''' STEP 4 ''' trader.disconnect() #Disconnect
time_wait_sell = 60 # seconds sleep(time_wait_sell) stop_processes(processes) # print stuff routine_summary(trader) # bad_year = 1969 if __name__ == '__main__': # year = bad_year # curr_try, num_tries = 1, 1000 sleep(5) trader = shift.Trader(credentials.my_username) try: trader.connect("initiator.cfg", credentials.my_password) trader.sub_all_order_book() except shift.IncorrectPasswordError as e: print(e) except shift.ConnectionTimeoutError as e: print(e) sleep(15) # while year == bad_year: # print(f'try {curr_try}') # if curr_try == num_tries:
def main(argv): client_id_number = 1 # client ID number stock_ticker = "AAPL" # stock ticker (e.g. XYZ) simulation_duration = 380 # duration of simulation (in minutes) trading_rate = 190 # number of trader per simulation session initial_bid_price = 99.95 # initial bid price initial_ask_price = 100.05 # initial ask price minimum_dollar_change = 0.05 # minimum dollar change (e.g. 0.01) verbose = False # verbose mode try: opts, args = getopt.getopt(argv, "hn:t:d:r:b:a:c:v", ["help", "number=", "ticker=", "duration=", "rate=", "bid=", "ask=", "change=", "verbose"]) except getopt.GetoptError as e: # print help information and exit: print() print(e) # will print something like "option -a not recognized" usage() sys.exit(2) for o, a in opts: if o in ("-h", "--help"): usage() sys.exit() elif o in ("-n", "--number"): client_id_number = int(a) elif o in ("-t", "--ticker"): stock_ticker = str(a) elif o in ("-d", "--duration"): simulation_duration = int(a) elif o in ("-r", "--rate"): trading_rate = int(a) elif o in ("-b", "--bind"): initial_bid_price = float(a) elif o in ("-a", "--ask"): initial_ask_price = float(a) elif o in ("-c", "--change"): minimum_dollar_change = float(a) elif o in ("-v", "--verbose"): verbose = True else: assert False, "unhandled option" client_id = f"test{str(client_id_number).zfill(3)}" last_price = (initial_bid_price + initial_ask_price) / 2.0 best_bid = initial_bid_price best_ask = initial_ask_price confidence_level = int(numpy.random.randint(low=1, high=5)) # confidence level: 1, 2, 3, or 4 risk_appetite = int(numpy.random.randint(low=1, high=5)) # risk appetite: 1, 2, 3, or 4 if verbose: print() print(f"Confidence Level: {confidence_level}") print(f"Risk Appetite: {risk_appetite}") print() num_trades = numpy.random.poisson(lam=trading_rate) trading_times = set() trading_times.add(0) for i in range(num_trades): trading_times.add(math.trunc(simulation_duration * 60 * float(numpy.random.uniform(low=0.0, high=1.0)))) trading_times.add(simulation_duration * 60) # sort trading times trading_times = list(trading_times) trading_times.sort() # update num_trades taking bend and end of simulation into consideration num_trades = len(trading_times) # create trader object trader = shift.Trader(client_id) # attach callback functors # trader.onLastPriceUpdated(goodcbfs.LastPriceUpdatedCB(stock_ticker, verbose)) # trader.onPortfolioSummaryUpdated(goodcbfs.PortfolioSummaryUpdatedCB(verbose)) # trader.onPortfolioItemUpdated(goodcbfs.PortfolioItemUpdatedCB(stock_ticker, verbose)) # trader.onWaitingListUpdated(goodcbfs.WaitingListUpdatedCB(verbose)) # connect try: trader.connect("initiator.cfg", "password") except shift.IncorrectPassword as e: print(e) sys.exit(2) except shift.ConnectionTimeout as e: print(e) sys.exit(2) # subscribe to all available order books trader.subAllOrderBook() # trading strategy for i in range(1, num_trades): # trading_times[0] == 0 time.sleep(trading_times[i] - trading_times[i - 1]) if verbose: print() print(f"Trading Time: {trading_times[i]}") # cancel last order if it has not executed yet if trader.getWaitingListSize() != 0: if verbose: print("Canceling Pending Orders!") # trader.cancelAllPendingOrders() for order in trader.getWaitingList(): if order.type == shift.Order.LIMIT_BUY: order.type = shift.Order.CANCEL_BID else: order.type = shift.Order.CANCEL_ASK trader.submitOrder(order) while trader.getWaitingListSize() > 0: time.sleep(1) # robot should not trade anymore if i == (num_trades - 1): break target_rate = float(numpy.random.uniform(low=0.0, high=0.25 * confidence_level)) if verbose: print(f"Target Rate: {target_rate}") curr_last_price = trader.getLastPrice(stock_ticker) last_price = last_price if curr_last_price == 0.0 else curr_last_price if numpy.random.binomial(n=1, p=0.5) == 0: # limit buy curr_best_bid = trader.getBestPrice(stock_ticker).getBidPrice() best_bid = best_bid if curr_best_bid == 0.0 else curr_best_bid target_price = min(last_price, best_bid) if verbose: print(f"Last Price: {last_price:.2f}") print(f"Best Bid: {best_bid:.2f}") print(f"Target Price: {target_price:.2f}") order_price = decimal_truncate( target_price + minimum_dollar_change * float(numpy.random.normal(loc=0.0, scale=(0.5 * risk_appetite))), 2) if verbose: print(f"Bid Price: {order_price:.2f}") order_size = math.floor((target_rate * trader.getPortfolioSummary().getTotalBP()) / (100 * order_price)) if verbose: print(f"Bid Size: {order_size}") limit_buy = shift.Order(shift.Order.LIMIT_BUY, stock_ticker, order_size, order_price) trader.submitOrder(limit_buy) else: # limit sell curr_best_ask = trader.getBestPrice(stock_ticker).getAskPrice() best_ask = best_ask if curr_best_ask == 0.0 else curr_best_ask target_price = max(last_price, best_ask) if verbose: print(f"Last Price: {last_price:.2f}") print(f"Best ask: {best_ask:.2f}") print(f"Target Price: {target_price:.2f}") order_price = decimal_truncate( target_price + minimum_dollar_change * float(numpy.random.normal(loc=0.0, scale=(0.5 * risk_appetite))), 2) if verbose: print(f"Ask Price: {order_price:.2f}") order_size = math.floor(target_rate * (trader.getPortfolioItem(stock_ticker).getShares() / 100)) if verbose: print(f"Ask Size: {order_size}") limit_sell = shift.Order(shift.Order.LIMIT_SELL, stock_ticker, order_size, order_price) trader.submitOrder(limit_sell) if verbose: print() # disconnect trader.disconnect()
def main(argv): # Create trader object trader = shift.Trader( credentials.user ) # **Change to competition user*********************************************************** # Connect and subscribe to all available order books try: trader.connect( "initiator.cfg", credentials.password ) # **Change to competition password************************************* #trader.sub_all_order_book() # Subscribe to orderbook for all tickers. Can also choose one particular stock trader.sub_order_book("CS1") trader.sub_order_book("CS2") except shift.IncorrectPasswordError as e: print(e) except shift.ConnectionTimeoutError as e: print(e) time.sleep(10) # Date of simulation today = trader.get_last_trade_time().date() startTime = dt.time(9, 30, 30) # Competition time dayStart = dt.datetime.combine(today, startTime) #Begin collecting prices """ trader.request_sample_prices(["CS1", "CS2"], 5.0, 26) # Ticker list, sample freq, sample window size !!!!!!!!!!! """ # Wait for 30 minutes trafficLight(trader, dayStart, 2.0) # End of trading day datetime endTime = dt.time(15, 50, 0) # Competition time dayEnd = dt.datetime.combine(today, endTime) # Begin trading print("Initial buying power:", trader.get_portfolio_summary().get_total_bp()) # View destination exchange(s) for each ticker seeExchange(trader, "CS1") seeExchange(trader, "CS2") # Stop loss / take profit manageInvCS1 = threading.Thread(target=manageInventory, args=[trader, 'CS1', dayEnd], name='manageInvCS1') manageInvCS2 = threading.Thread(target=manageInventory, args=[trader, 'CS2', dayEnd], name='manageInvCS2') # ---TECHNICAL ANALYSIS STRATEGY--- threads """ longTechCS1 = threading.Thread(target=technicalStrat, args=[trader, "CS1", True, dayEnd, 1.0], name='longTechCS1') shortTechCS1 = threading.Thread(target=technicalStrat, args=[trader, "CS1", False, dayEnd, 1.0], name='shortTechCS1') longTechCS2 = threading.Thread(target=technicalStrat, args=[trader, "CS2", True, dayEnd, 1.0], name='longTechCS2') shortTechCS2 = threading.Thread(target=technicalStrat, args=[trader, "CS2", False, dayEnd, 1.0], name='shortTechCS2') """ # ---MARKET MAKER STRATEGY--- threads #******allocation should now be max % at risk******# longCS1_1 = threading.Thread(target=marketMaker, args=[ trader, 'CS1', dayEnd, .15, shift.Order.Type.LIMIT_BUY, 3, 30, 0.08 ], name='longCS1_1') longCS1_2 = threading.Thread(target=marketMaker, args=[ trader, 'CS1', dayEnd, .15, shift.Order.Type.LIMIT_BUY, 3, 30, 0.08 ], name='longCS1_2') longCS1_3 = threading.Thread(target=marketMaker, args=[ trader, 'CS1', dayEnd, .15, shift.Order.Type.LIMIT_BUY, 3, 30, 0.08 ], name='longCS1_3') longCS1_4 = threading.Thread(target=marketMaker, args=[ trader, 'CS1', dayEnd, .15, shift.Order.Type.LIMIT_BUY, 3, 30, 0.08 ], name='longCS1_4') longCS2_1 = threading.Thread(target=marketMaker, args=[ trader, 'CS2', dayEnd, .15, shift.Order.Type.LIMIT_BUY, 3, 30, 0.08 ], name='longCS2_1') longCS2_2 = threading.Thread(target=marketMaker, args=[ trader, 'CS2', dayEnd, .15, shift.Order.Type.LIMIT_BUY, 3, 30, 0.08 ], name='longCS2_2') longCS2_3 = threading.Thread(target=marketMaker, args=[ trader, 'CS2', dayEnd, .15, shift.Order.Type.LIMIT_BUY, 3, 30, 0.08 ], name='longCS2_3') longCS2_4 = threading.Thread(target=marketMaker, args=[ trader, 'CS2', dayEnd, .15, shift.Order.Type.LIMIT_BUY, 3, 30, 0.08 ], name='longCS2_4') shortCS1_1 = threading.Thread(target=marketMaker, args=[ trader, 'CS1', dayEnd, .15, shift.Order.Type.LIMIT_SELL, 3, 30, 0.08 ], name='shortCS1_1') shortCS1_2 = threading.Thread(target=marketMaker, args=[ trader, 'CS1', dayEnd, .15, shift.Order.Type.LIMIT_SELL, 3, 30, 0.08 ], name='shortCS1_2') shortCS1_3 = threading.Thread(target=marketMaker, args=[ trader, 'CS1', dayEnd, .15, shift.Order.Type.LIMIT_SELL, 3, 30, 0.08 ], name='shortCS1_3') shortCS1_4 = threading.Thread(target=marketMaker, args=[ trader, 'CS1', dayEnd, .15, shift.Order.Type.LIMIT_SELL, 3, 30, 0.08 ], name='shortCS1_4') shortCS2_1 = threading.Thread(target=marketMaker, args=[ trader, 'CS2', dayEnd, .15, shift.Order.Type.LIMIT_SELL, 3, 30, 0.08 ], name='shortCS2_1') shortCS2_2 = threading.Thread(target=marketMaker, args=[ trader, 'CS2', dayEnd, .15, shift.Order.Type.LIMIT_SELL, 3, 30, 0.08 ], name='shortCS2_2') shortCS2_3 = threading.Thread(target=marketMaker, args=[ trader, 'CS2', dayEnd, .15, shift.Order.Type.LIMIT_SELL, 3, 30, 0.08 ], name='shortCS2_3') shortCS2_4 = threading.Thread(target=marketMaker, args=[ trader, 'CS2', dayEnd, .15, shift.Order.Type.LIMIT_SELL, 3, 30, 0.08 ], name='shortCS2_4') # --Initiate threads-- manageInvCS1.start() manageInvCS2.start() """ longTechCS1.start() shortTechCS1.start() longTechCS2.start() shortTechCS2.start() """ longCS1_1.start() shortCS1_1.start() longCS2_1.start() shortCS2_1.start() time.sleep(5) longCS1_2.start() shortCS1_2.start() longCS2_2.start() shortCS2_2.start() time.sleep(5) longCS1_3.start() shortCS1_3.start() longCS2_3.start() shortCS2_3.start() time.sleep(5) longCS1_4.start() shortCS1_4.start() longCS2_4.start() shortCS2_4.start() time.sleep(5) # --Execute functions on threads-- manageInvCS1.join() manageInvCS2.join() """ longTechCS1.join() shortTechCS1.join() longTechCS2.join() shortTechCS2.join() """ longCS1_1.join() shortCS1_1.join() longCS2_1.join() shortCS2_1.join() longCS1_2.join() shortCS1_2.join() longCS2_2.join() shortCS2_2.join() longCS1_3.join() shortCS1_3.join() longCS2_3.join() shortCS2_3.join() longCS1_4.join() shortCS1_4.join() longCS2_4.join() shortCS2_4.join() # Disconnect time.sleep(60) # Wait for all threads to sell inventory print("Final buying power:", trader.get_portfolio_summary().get_total_bp()) trader.disconnect() return
def main(argv: List[str]): stock_ticker = "AAPL" # stock ticker (e.g. XYZ) simulation_duration = 380 # duration of simulation (in minutes) trading_rate = 190 # number of trader per simulation session initial_price = 100.00 # initial price minimum_dollar_change = 0.05 # minimum dollar change (e.g. 0.01) verbose = False # verbose mode try: opts, args = getopt.getopt( argv, "ht:d:r:p:c:v", [ "help", "ticker=", "duration=", "rate=", "price=", "change=", "verbose" ], ) except getopt.GetoptError as e: # print help information and exit: print() print(e) # will print something like "option -a not recognized" usage() sys.exit(2) for o, a in opts: if o in ("-h", "--help"): usage() sys.exit() elif o in ("-t", "--ticker"): stock_ticker = str(a) elif o in ("-d", "--duration"): simulation_duration = int(a) elif o in ("-r", "--rate"): trading_rate = int(a) elif o in ("-p", "--price"): initial_price = float(a) elif o in ("-c", "--change"): minimum_dollar_change = float(a) elif o in ("-v", "--verbose"): verbose = True else: assert False, "unhandled option" last_price = initial_price # confidence level: 1, 2, 3, or 4 confidence_level = int(numpy.random.randint(low=1, high=5)) # risk appetite: 1, 2, 3, or 4 risk_appetite = int(numpy.random.randint(low=1, high=5)) if verbose: print() print(f"Confidence Level: {confidence_level}") print(f"Risk Appetite: {risk_appetite}") print() num_trades = numpy.random.poisson(lam=trading_rate) trading_times = set() trading_times.add(0) for i in range(num_trades): trading_times.add( round(simulation_duration * 60 * float(numpy.random.uniform(low=0.0, high=1.0)))) trading_times.add(simulation_duration * 60) # sort trading times trading_times = list(trading_times) trading_times.sort() # update num_trades taking bend and end of simulation into consideration num_trades = len(trading_times) # create trader object trader = shift.Trader(my_username) # attach callback functors # trader.on_last_price_updated(goodcbfs.LastPriceUpdatedCB(stock_ticker, verbose)) # trader.on_execution_updated(goodcbfs.ExecutionUpdatedCB(verbose)) # trader.on_portfolio_summary_updated(goodcbfs.PortfolioSummaryUpdatedCB(verbose)) # trader.on_portfolio_item_updated(goodcbfs.PortfolioItemUpdatedCB(verbose)) # trader.on_waiting_list_updated(goodcbfs.WaitingListUpdatedCB(verbose)) # connect try: trader.connect("initiator.cfg", my_password) except shift.IncorrectPasswordError as e: print(e) sys.exit(2) except shift.ConnectionTimeoutError as e: print(e) sys.exit(2) # subscribe to all available order books trader.sub_all_order_book() # trading strategy for i in range(1, num_trades): # trading_times[0] == 0 time.sleep(trading_times[i] - trading_times[i - 1]) if verbose: print() print(f"Trading Time: {trading_times[i]}") # cancel last order if it has not executed yet if trader.get_waiting_list_size() > 0: if verbose: print("Canceling Pending Orders!") trader.cancel_all_pending_orders() # for order in trader.get_waiting_list(): # trader.submit_cancellation(order) # while trader.get_waiting_list_size() > 0: # time.sleep(1) # robot should not trade anymore if i == (num_trades - 1): break target_rate = float( numpy.random.uniform(low=0.0, high=0.25 * confidence_level)) if verbose: print(f"Target Rate: {target_rate}") curr_last_price = trader.get_last_price(stock_ticker) last_price = last_price if curr_last_price == 0.0 else curr_last_price if numpy.random.binomial(n=1, p=0.5) == 0: # limit buy best_bid = trader.get_best_price(stock_ticker).get_bid_price() best_bid = best_bid if best_bid != 0.0 else last_price target_price = min(last_price, best_bid) if verbose: print(f"Last Price: {last_price:.2f}") print(f"Best Bid: {best_bid:.2f}") print(f"Target Price: {target_price:.2f}") order_price = round( target_price + minimum_dollar_change * float( numpy.random.normal(loc=0.0, scale=(0.5 * risk_appetite))), 2, ) if verbose: print(f"Bid Price: {order_price:.2f}") order_size = math.floor( (target_rate * trader.get_portfolio_summary().get_total_bp()) / (100 * order_price)) if verbose: print(f"Bid Size: {order_size}") if order_size == 0: if verbose: print(f"Not submitting order of size: : {order_size}") continue limit_buy = shift.Order(shift.Order.Type.LIMIT_BUY, stock_ticker, order_size, order_price) trader.submit_order(limit_buy) else: # limit sell best_ask = trader.get_best_price(stock_ticker).get_ask_price() best_ask = best_ask if best_ask != 0.0 else last_price target_price = max(last_price, best_ask) if verbose: print(f"Last Price: {last_price:.2f}") print(f"Best ask: {best_ask:.2f}") print(f"Target Price: {target_price:.2f}") order_price = round( target_price + minimum_dollar_change * float( numpy.random.normal(loc=0.0, scale=(0.5 * risk_appetite))), 2, ) if verbose: print(f"Ask Price: {order_price:.2f}") order_size = math.floor( target_rate * (trader.get_portfolio_item(stock_ticker).get_shares() / 100)) if verbose: print(f"Ask Size: {order_size}") if order_size == 0: if verbose: print(f"Not submitting order of size: : {order_size}") continue limit_sell = shift.Order(shift.Order.Type.LIMIT_SELL, stock_ticker, order_size, order_price) trader.submit_order(limit_sell) if verbose: print() # disconnect trader.disconnect()
def main(argv): ''' STEP 0 ''' # create trader object trader = shift.Trader("test001") #Change this? # connect and subscribe to all available order books try: trader.connect("initiator.cfg", "password") trader.subAllOrderBook() except shift.IncorrectPassword as e: print(e) except shift.ConnectionTimeout as e: print(e) ''' STEP 1 ''' # 6.5 hours = 23400 start = time.time() #Create PortfolioItems for each company? #Create PortfolioSummary ''' STEP 2 ''' #EXECUTE METHODS while time.time() - start < 500: # 22500 corresponds to 3:45 #Execute trades and stuff print("Transaction initiated") comp = random.randint(0, NUM_COMPANIES - 1) company = COMPANIES[comp] trader.submitOrder(shift.Order(shift.Order.MARKET_BUY,company,size=1)) printSummary(trader) time.sleep(60) trader.submitOrder(shift.Order(shift.Order.MARKET_SELL,company,size=1)) printSummary(trader) time.sleep(10) ''' STEP 3 ''' num_executed_transactions = trader.getSubmittedOrdersSize() - trader.getWaitingListSize() if num_executed_transactions < MIN_TRANSACTIONS: # getSubmittedOrdersSize returns # transactions both executed & not executed, excluding cancellation requests # getWaitingListSize returns # transactions not executed for i in range(int((MIN_TRANSACTIONS - num_executed_transactions)/2)): #buy and then sell, both at market price comp = random.randint(0, NUM_COMPANIES - 1) company = COMPANIES[comp] trader.submitOrder(shift.Order(shift.Order.MARKET_BUY, company,size=1)) time.sleep(10) printSummary(trader) trader.submitOrder(shift.Order(shift.Order.MARKET_SELL, company,size=1)) time.sleep(10) printSummary(trader) for company in COMPANIES: # Price? Long and short? portfolio_item = trader.getPortfolioItem(company) num_shares = portfolio_item.getShares() trader.submitOrder(shift.Order(shift.Order.MARKET_SELL,company,size=num_shares)) #Sell at market price #Update log with transaction #Do this at 3:59? cancelAllPendingOrders(trader) #Update log #Print summary printSummary(trader) #if time.time() - start >= 560: # 23328 corresponds to 3:59ish #trader.cancelAllPendingOrders() #Cancel all pending orders #demo05(trader) ''' STEP 4 ''' trader.disconnect() #Disconnect
def main(): my_username = "******" my_password = "******" trader = shift.Trader(my_username) # connect try: trader.connect("initiator.cfg", my_password) except shift.IncorrectPasswordError as e: print(e) sys.exit(2) except shift.ConnectionTimeoutError as e: print(e) sys.exit(2) # subscribe to all available order books trader.sub_all_order_book() print("started") time.sleep(30) smallTradeExecuteTime = np.random.randint(0, 450) currSmallTradeTime = trader.get_last_trade_time() print(currSmallTradeTime) nextSmallTradeTime = currSmallTradeTime + datetime.timedelta(seconds=3) available_bp = np.random.randint(10000, 200000) print(available_bp) print(nextSmallTradeTime) orders = [] while True: time.sleep(1) currSmallTradeTime = trader.get_last_trade_time() print(currSmallTradeTime) if currSmallTradeTime >= nextSmallTradeTime: print(currSmallTradeTime) smallTradeVals = smallTrader(available_bp) stock = trader.get_stock_list()[np.random.randint(0, 30)] print(stock) if smallTradeVals[0] == 0: x = trader.get_best_price(stock).get_ask_price() print(x) print(smallTradeVals[1]) submittedOrder = shift.Order( shift.Order.Type.MARKET_BUY, stock, int(smallTradeVals[1] // (x * 100))) trader.submit_order(submittedOrder) orders.append(submittedOrder.id) else: x = trader.get_best_price(stock).get_bid_price() print(x) print(smallTradeVals[1]) submittedOrder = shift.Order( shift.Order.Type.MARKET_SELL, stock, int(smallTradeVals[1] // (x * 100))) trader.submit_order(submittedOrder) orders.append(submittedOrder.id) smallTradeExecuteTime = np.random.randint(0, 450) currSmallTradeTime = trader.get_last_trade_time() nextSmallTradeTime = currSmallTradeTime + datetime.timedelta( minutes=smallTradeExecuteTime) available_bp = available_bp - trader.get_portfolio_item( stock).get_long_price() print(available_bp) print(nextSmallTradeTime) while available_bp <= 10000: index = np.random.randint(0, len(orders)) # make more efficient to delete orderClose = orders[index] if trader.get_order( orderClose).type == shift.Order.Type.MARKET_BUY: ticker = trader.get_order(orderClose).symbol size = trader.get_order(orderClose).size submittedOrder = shift.Order(shift.Order.Type.MARKET_SELL, ticker, size) else: ticker = trader.get_order(orderClose).symbol size = trader.get_order(orderClose).size submittedOrder = shift.Order(shift.Order.Type.MARKET_BUY, ticker, size) trader.submit_order(submittedOrder) available_bp = available_bp + trader.get_order( submittedOrder.id).executed_price * size del orders[index]
GAMMA = 0.95 EPSILON = 0.1 EPISODES = 500 # Process the loading files model_list = os.listdir('saved_models') trained_model_num = '0' if model_list: model_list.remove('checkpoint') for name in model_list: trained_model_num = max(name.split('.')[0], trained_model_num) load = True else: load = False # Trader connection trader = shift.Trader("democlient") try: trader.connect("initiator.cfg", "password") trader.sub_all_order_book() except shift.IncorrectPasswordError as e: print(e) except shift.ConnectionTimeoutError as e: print(e) symbol = "AAPL" commission = 0 sess = tf.Session() execute_time = 60 # total execution time (seconds) exe_times = 30 # steps exe_interval = execute_time / exe_times action_space = 51
import sys import shift import time from credentials import my_username, my_password from stockAndPortfolio import Stock, portfolioInfo, infoCollecting, clearAllPortfolioItems, cancelAllPendingOrders import datetime from dongxuRun import marketMaker ''' ******************************************************************************** Initial parameter settings ''' # Setup trader for accumulating information verbose = 1 trader = shift.Trader(my_username) # connect to the server try: trader.connect("initiator.cfg", my_password) except shift.IncorrectPassword as e: print(e) sys.exit(2) except shift.ConnectionTimeout as e: print(e) sys.exit(2) # subscribe to all available order books trader.subAllOrderBook() # simulation time simulation_duration = 380 # Time to stop the simulation timeToStop = datetime.time(15, 30)
def main(argv): ''' STEP 0 ''' # create trader object #trader = shift.Trader("test002") #Change this? trader = shift.Trader("wolves_of_wall_street") # connect and subscribe to all available order books try: #trader.connect("initiator.cfg", "password") trader.connect("initiator.cfg", "ubd7w26JahGS9p4A") trader.subAllOrderBook() except shift.IncorrectPassword as e: print(e) except shift.ConnectionTimeout as e: print(e) ''' STEP 1 ''' # 6.5 hours = 23400 global start start = time.time() ''' STEP 2 ''' #EXECUTE METHODS stock_data = [] for company in COMPANIES: stock_data.append(Stock(company)) request_prices( trader ) # Make the connection to get sample prices (requestSamplePrices) for all companies while time.time() - start < TIME_TO_STOP_BUY: for stk in stock_data: STATES_TRANSITION[stk.state]( stk, trader) # Execute the state diagram for each stock printSummary(trader) ''' STEP 3 ''' while time.time() - start < TIME_TO_SELL: start_selling( trader, stock_data ) # Start trying to sell at a profit before the end of the day trader.cancelAllSamplePricesRequests( ) # Cancel the sample prices connection cancel_all_buy_sell(trader) # Cancel all buy orders and sell orders for order in trader.getWaitingList(): print("%6s\t%21s\t%7.2f\t\t%4d\t%36s\t%26s" % (order.symbol, order.type, order.price, order.size, order.id, order.timestamp)) while trader.getWaitingListSize( ) != 0: # Wait for the orders to go through print("Waiting") time.sleep(3) # Close all positions # Market sell inventory and market buy shorted positions market_close_positions(trader) print("Printing submitted orders") for order in trader.getSubmittedOrders(): print("%6s\t%21s\t%7.2f\t\t%4d\t%36s\t%26s" % (order.symbol, order.type, order.price, order.size, order.id, order.timestamp)) for company in COMPANIES: portfolio_item = trader.getPortfolioItem(company) num_shares = portfolio_item.getShares() while num_shares != 0: portfolio_item = trader.getPortfolioItem(company) num_shares = portfolio_item.getShares() #Update log #Print summary printSummary(trader) time.sleep(10) print(trader.getPortfolioSummary().getTotalBP()) ''' STEP 4 ''' trader.disconnect() #Disconnect
import sys import time import shift import datetime trader = shift.Trader("tbd") try: trader.connect("initiator.cfg", "KDJKdym8uf4zu7bL") trader.sub_all_order_book() except shift.IncorrectPasswordError as e: print(e) except shift.ConnectionTimeoutError as e: print(e) print("Buying Power\tTotal Shares\tTotal P&L\tTimestamp") print("%12.2f\t%12d\t%9.2f\t%26s" % ( trader.get_portfolio_summary().get_total_bp(), trader.get_portfolio_summary().get_total_shares(), trader.get_portfolio_summary().get_total_realized_pl(), trader.get_portfolio_summary().get_timestamp(), )) tickets = ['CS1', 'CS2'] rangePERCENT = [0.0126, 0.0159, 0.0133, 0.0135] openPrice = [] increment = [0, 0.0001, 0.0005, 0.001, 0.0015, 0.002, 0.003, 0.04, 0.005, 0.07] time.sleep(5) for i in range(4): a = trader.get_best_price(tickets[i])