def closePositions(trader: shift.Trader, ticker):
# Cancel pending orders
print("Waiting list size:", trader.get_waiting_list_size())
for order in trader.get_waiting_list():
if order.symbol == ticker:
trader.submit_cancellation(order)
print("All", ticker, "pending orders cancelled"
) # Cancel open orders before submitting closing orders
# Close / Cover all open positions
#portfolioSummary(trader) # Print summary of portfolio**************************************************************************Good for developing
item = trader.get_portfolio_item(ticker)
if item.get_shares() > 0:
closeLong = shift.Order(
shift.Order.Type.MARKET_SELL, item.get_symbol(),
int(item.get_shares() /
100)) # Order size in 100's of shares, strictly as an int
trader.submit_order(closeLong)
#print("Close all long positions")
elif item.get_shares() < 0:
coverShort = shift.Order(shift.Order.Type.MARKET_BUY,
item.get_symbol(),
int(item.get_shares() / -100))
trader.submit_order(coverShort)
#print("Close all short positions")
print("All", ticker, "closing orders submitted")
return
def demo_05(trader: shift.Trader):
"""
This method cancels all the orders in the waiting list.
:param trader:
:return:
"""
print(
"Symbol\t\t\t\tType\t Price\t\tSize\tExecuted\tID\t\t\t\t\t\t\t\t\t\t\t\t\t\t Status\t\tTimestamp"
)
for o in trader.get_waiting_list():
print(
"%6s\t%16s\t%7.2f\t\t%4d\t\t%4d\t%36s\t%23s\t\t%26s"
% (
o.symbol,
o.type,
o.price,
o.size,
o.executed_size,
o.id,
o.status,
o.timestamp,
)
)
print()
print("Waiting list size: " + str(trader.get_waiting_list_size()))
print("Canceling all pending orders...", end=" ")
# trader.cancel_all_pending_orders() also works
for o in trader.get_waiting_list():
trader.submit_cancellation(o)
i = 0
while trader.get_waiting_list_size() > 0:
i += 1
print(i, end=" ")
time.sleep(1)
print()
print("Waiting list size: " + str(trader.get_waiting_list_size()))
return
def waiting_list_updated_cb(trader: shift.Trader):
if trader.get_waiting_list_size() > 0:
waiting_list = trader.get_waiting_list()
print("Waiting List:")
for order in waiting_list:
print("%6s\t%21s\t%7.2f\t\t%4d\t\t%4d\t%36s\t%28s\t%26s" % (
order.symbol,
order.type,
order.price,
order.size,
order.executed_size,
order.id,
order.status,
order.timestamp,
))
else:
print("Waiting List Empty!")
def __call__(self, trader: shift.Trader):
if self.verbose:
if trader.get_waiting_list_size() > 0:
waiting_list = trader.get_waiting_list()
print("Waiting List:")
for order in waiting_list:
print(
"%6s\t%16s\t%7.2f\t\t%4d\t\t%4d\t%36s\t%23s\t\t%26s" %
(
order.symbol,
order.type,
order.price,
order.size,
order.executed_size,
order.id,
order.status,
order.timestamp,
))
else:
print("Waiting List Empty!")
def marketMaker(trader: shift.Trader,
ticker,
dayEnd,
allocation,
orderType,
lag=3,
fillTime=30,
spreadWiden=0.00):
# Datetime of simulation
rightNow = trader.get_last_trade_time()
fillTime = fillTime * 10
# While the time is before end of day...
while dayEnd > rightNow:
time.sleep(lag) # Give prices some time to change
"""
Make Trades Here:
"""
onHand = trader.get_portfolio_item(ticker).get_shares() * (
(trader.get_best_price(ticker).get_bid_price() +
trader.get_best_price(ticker).get_ask_price()) / 2
) # Portfolio value of the stock
maxAllowed = allocation * (
1000000 + trader.get_portfolio_summary().get_total_realized_pl()
) # Maximum portfolio allocation for this stock
print(ticker, "on hand:", round(onHand, 2), "max:", round(maxAllowed),
" P/L:",
round(trader.get_portfolio_summary().get_total_realized_pl(),
2), " Waiting list:", trader.get_waiting_list_size())
if onHand > maxAllowed and orderType == shift.Order.Type.LIMIT_BUY: # Holding too much
continue # Allow Sell side to catch up
elif onHand < -maxAllowed and orderType == shift.Order.Type.LIMIT_SELL: # Short too much
continue # Allow Buy side to catch up
time.sleep(lag) # Give prices some time to change
# Submit an order
bid = trader.get_best_price(ticker).get_bid_price()
ask = trader.get_best_price(ticker).get_ask_price()
spreadWiden = max(.01, (ask - bid) * .25)
if (ask - bid) < .05: # If spread is too tight, widen it
spreadWiden = -spreadWiden
if orderType == shift.Order.Type.LIMIT_BUY:
size = max(
1, round(trader.get_best_price(ticker).get_ask_size() / 5)
) # Only buy as much as you can sell. Divide by 5 so buying power lasts on high volume. At least 1
price = bid + spreadWiden # Can buy above bid if wide spread, or below bid if high volume
elif orderType == shift.Order.Type.LIMIT_SELL:
size = max(
1, round(trader.get_best_price(ticker).get_ask_size() / 5)
) # Only sell as much as you can buy back. Divide by 5 to decrease risk. At least 1
price = ask - spreadWiden # Can sell below ask if wide spread, or above ask if high volume
order = shift.Order(orderType, ticker, size, price)
trader.submit_order(order)
#print(orderType, size, ticker, "@", price)
# Give the order time to fill
waitCount = 1
while trader.get_order(
order.id
).status != shift.Order.Status.FILLED and waitCount <= fillTime and trader.get_order(
order.id).status != shift.Order.Status.REJECTED:
#print(waitCount, ticker, "Status:",trader.get_order(order.id).status)
time.sleep(.1)
waitCount = waitCount + 1
#print(waitCount, trader.get_order(order.id).status)
# Cancel the buy order if never filled and was not rejected
if trader.get_order(
order.id
).status != shift.Order.Status.REJECTED and trader.get_order(
order.id).status != shift.Order.Status.FILLED:
trader.submit_cancellation(order)
#print("Cancelled", ticker)
rightNow = trader.get_last_trade_time() # Reset datetime of right now
# 30 minutes till end of trading day
closePositions(trader, ticker)
# Done trading
return
def technicalStrat(trader: shift.Trader, ticker, lastTradeSell, dayEnd, lag=1):
rightNow = trader.get_last_trade_time() # Datetime of simulation
# While the time is before end of day...
while (dayEnd > rightNow):
print("P/L:",
trader.get_portfolio_summary().get_total_realized_pl(),
" Waiting list:", trader.get_waiting_list_size())
"""
Make Trades Here:
"""
priceSeries = pd.Series(trader.get_sample_prices(
ticker, True)) # ticker, mid-prices
time.sleep(lag) # Give prices some time to change
if priceSeries.size == 26:
mShort = priceSeries.ewm(span=12,
adjust=False).mean() # 12 period EMA
mLong = priceSeries.ewm(span=26,
adjust=False).mean() # 26 period EMA
MACD = mShort - mLong # Calculate convergence and divergence
mSignal = MACD.ewm(span=9,
adjust=False).mean() # 9 period EMA signal line
mHist = MACD - mSignal # Trade signal producer
SMA = priceSeries[:19].mean() # 20 second simple moving average
if lastTradeSell == True:
bUpper = SMA + (priceSeries[:19].std() * 3.0
) # Upper Bollinger Band
bLower = SMA - (
priceSeries[:19].std() * 1.5
) # Low Bollinger Band - more lenient, safer sell
else:
bUpper = SMA + (
priceSeries[:19].std() * 1.5
) # Upper Bollinger Band - more lenient, safer cover
bLower = SMA - (priceSeries[:19].std() * 3.0
) # Low Bollinger Band
#######!!!!!!possibly have a second band outside first..for too strong movement!!!!!!!!!!!!!!!!!!!!!!!!!!!!
# Open long position / Cover short position
if lastTradeSell == True and mHist.iloc[
-1] > 0 and trader.get_close_price(
ticker, True, 1) > bUpper: # ticker, Buy, Size
for i in range(
1, 20
): # should scale based on order book amount in competition..
openLong = shift.Order(shift.Order.Type.MARKET_BUY, ticker,
1)
trader.submit_order(openLong)
print("Tech - Buy", ticker)
lastTradeSell = False
# Close long positions for now / Open short position
elif lastTradeSell == False and mHist.iloc[
-1] < 0 and trader.get_close_price(
ticker, False, 1) < bLower: # ticker, Sell, Size
for i in range(
1, 20
): # should scale based on order book amount in competition..
closeLong = shift.Order(shift.Order.Type.MARKET_SELL,
ticker, 1)
trader.submit_order(closeLong)
print("Tech - Sell", ticker)
lastTradeSell = True
rightNow = trader.get_last_trade_time() # Reset datetime of right now
# 60 seconds till end of trading day
trader.cancel_all_sample_prices_requests(
) # Stop sampling prices on threads
closePositions(trader,
ticker) # Close out open positions so we don't get fined
# Done trading
return
