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])
