def market_maker_one(trader: shift.Trader, ticker: str):
tickSize = 0.01
# james code need to change maybe?
today = trader.get_last_trade_time()
endTime = dt.time(15, 30, 0)
dayEnd = dt.datetime.combine(today, dt.datetime(endTime))
rightNow = trader.get_last_trade_time()
#right < the end of day at 3:50
while today < dayEnd:
'''
check inventory here
'''
trader.sub_all_order_book()
lastPrice = trader.get_last_price("AAPL")
limitBuyPrice = lastPrice - tickSize
limitSellPrice = lastPrice + tickSize
limit_buy = shift.Order(shift.Order.Type.LIMIT_BUY, "AAPL", 1,
limitBuyPrice)
limit_sell = shift.Order(shift.Order.Type.LIMIT_SELL, "AAPL", 1,
limitSellPrice)
# market_buy = shift.Order(shift.Order.Type.MARKET_BUY, "AAPL", 1)
# trader.submit_order(market_buy)
trader.submit_order(limit_buy)
trader.submit_order(limit_sell)
time.sleep(10)
return
def zero(stk, trader):
global NUM_TRADES
if time.time() - start > TIME_TO_STOP_BUY:
return
pressure = get_pressure(stk.name, trader)
if (-1.0/3.0) <= pressure <= (1.0/3.0):
return
prediction = get_prediction(stk, trader)
purchase_size = purchasing_size(stk,trader)
current_holding = trader.getPortfolioItem(stk.name).getShares()
if current_holding < 0:
purchase_size = purchase_size + abs(current_holding)
purchase_size = int(purchase_size)
stk.current_price = get_current_price(stk.name, trader)
if (prediction - stk.current_price) / stk.current_price >= THRESHOLD and pressure < 0.0:
limit_buy = shift.Order(shift.Order.LIMIT_BUY, stk.name, purchase_size, prediction)
trader.submitOrder(limit_buy)
stk.BO = True
stk.predicted_price = prediction
stk.state = 1
return
# SHORTING PORTION
if (prediction - stk.current_price) / stk.current_price <= -1.5 * THRESHOLD and pressure > 0.0:
trader.submitOrder(shift.Order(shift.Order.MARKET_SELL, stk.name, size=2))
stk.S = True
stk.H = True
stk.state = 4
stk.predicted_price = prediction
limit_buy = shift.Order(shift.Order.LIMIT_BUY, stk.name, 3, stk.predicted_price)
trader.submitOrder(limit_buy)
stk.BO = True
NUM_TRADES+=1
return
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 market_close_positions(trader):
'''
:param trader: The trader object
:return: N/A
'''
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
def upDateOrder(trader, signal, ticker):
# Get the waiting list to see the current order for this particular ticker
Order = [order for order in trader.getWaitingList() if order.symbol == ticker]
# If there is no order for this ticker, there are two possibilities
if len(Order) == 0:
# Order got executed and there is share in the portfolio
item = trader.getPortfolioItem(ticker)
if item.getShares() != 0:
if item.getShares() > 0 and signal <= 0:
setupSellOrder(trader, ticker, signal)
elif item.getShares() < 0 and signal >= 0:
setupBuyOrder(trader, ticker, signal)
else:
# No order gets executed, so setup the initial buy and sell
if signal > 0:
setupBuyOrder(trader, ticker, signal)
elif signal < 0:
setupSellOrder(trader, ticker, signal)
# If there is a sell or buy order pending, check the signal.
elif len(Order) == 1:
if signal > 0:
for order in Order:
if order.type == shift.Order.LIMIT_BUY:
trader.submitCancellation(order)
setupBuyOrder(trader, ticker, signal)
else:
trader.submitCancellation(order)
elif signal < 0:
for order in Order:
if order.type == shift.Order.LIMIT_BUY:
trader.submitCancellation(order)
else:
trader.submitCancellation(order)
setupSellOrder(trader, ticker, signal)
else:
for order in Order:
trader.submitCancellation(order)
else:
# write this part just as protection
item = trader.getPortfolioItem(ticker)
if item.getShares() != 0:
if item.getShares() > 0 and signal <= 0:
setupSellOrder(trader, ticker, signal)
elif item.getShares() < 0 and signal >= 0:
setupBuyOrder(trader, ticker, signal)
time.sleep(1)
for order in Order:
trader.submitCancellation(order)
# patch
item = trader.getPortfolioItem(ticker)
if item.getShares() >= 300:
closeOrder = shift.Order(shift.Order.MARKET_SELL, ticker, int(item.getShares() / 100))
trader.submitOrder(closeOrder)
elif item.getShares() <= -300:
closeOrder = shift.Order(shift.Order.MARKET_BUY, ticker, int(-item.getShares() / 100))
trader.submitOrder(closeOrder)
def limit_order(trader: shift.Trader, order_type, symbol, contract_size, limit_price):
if order_type == "buy":
limit_buy = shift.Order(shift.Order.Type.LIMIT_BUY, symbol, contract_size, limit_price)
trader.submit_order(limit_buy)
if order_type == "sell":
limit_sell = shift.Order(shift.Order.Type.LIMIT_SELL, symbol, contract_size, limit_price)
trader.submit_order(limit_sell)
return
def market_order(trader: shift.Trader, order_type, symbol, contract_size):
if order_type == "buy":
market_buy = shift.Order(shift.Order.Type.MARKET_BUY, symbol, contract_size)
trader.submit_order(market_buy)
if order_type == "sell":
market_sell = shift.Order(shift.Order.Type.MARKET_SELL, symbol, contract_size)
trader.submit_order(market_sell)
return
def clearAllPortfolioItems(trader, tickers):
# clear all the portfolio items with market sell
for ticker in tickers:
item = trader.getPortfolioItem(ticker)
if item.getShares() > 0:
closeOrder = shift.Order(shift.Order.MARKET_SELL, ticker,
int(item.getShares() / 100))
trader.submitOrder(closeOrder)
elif item.getShares() < 0:
closeOrder = shift.Order(shift.Order.MARKET_BUY, ticker,
int(-item.getShares() / 100))
trader.submitOrder(closeOrder)
time.sleep(60)
print("Clear portfolio!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!\n")
def demo_02(trader: shift.Trader):
"""
This method submits 2 limit buy orders by indicating order type, symbol, size, and limit price.
:param trader:
:return:
"""
aapl_limit_buy = shift.Order(shift.Order.Type.LIMIT_BUY, "AAPL", 10, 10.00)
trader.submit_order(aapl_limit_buy)
xom_limit_buy = shift.Order(shift.Order.Type.LIMIT_BUY, "XOM", 10, 10.00)
trader.submit_order(xom_limit_buy)
return
def demo_08(trader: shift.Trader):
"""
This method shows how to submit market sell orders.
:param trader:
:return:
"""
aapl_market_sell = shift.Order(shift.Order.Type.MARKET_SELL, "AAPL", 1)
trader.submit_order(aapl_market_sell)
xom_market_sell = shift.Order(shift.Order.Type.MARKET_SELL, "XOM", 1)
trader.submit_order(xom_market_sell)
return
def demo_06(trader: shift.Trader):
"""
This method shows how to submit market buy orders.
:param trader:
:return:
"""
aapl_market_buy = shift.Order(shift.Order.Type.MARKET_BUY, "AAPL", 1)
trader.submit_order(aapl_market_buy)
xom_market_buy = shift.Order(shift.Order.Type.MARKET_BUY, "XOM", 1)
trader.submit_order(xom_market_buy)
return
def longer(trader: shift.Trader, tickers):
today = trader.get_last_trade_time()
endTime = dt.time(15, 50, 0)
dayEnd = dt.datetime.combine(today, endTime)
tickSize = 0.01
bp = (trader.get_portfolio_summary().get_total_bp())
dpa = bp / float(len(tickers))
for t in tickers:
lastPrice = trader.get_last_price(t)
while lastPrice == 0:
lastPrice = trader.get_last_price(t)
s = int((dpa / lastPrice) / 100)
for i in range(0, s):
# limitBuyPrice = lastPrice - tickSize
limit_sell = shift.Order(shift.Order.Type.MARKET_BUY, t, 1)
trader.submit_order(limit_sell)
while trader.get_last_trade_time() < dayEnd:
time.sleep(1)
for order in trader.get_waiting_list():
trader.submit_cancellation(order)
for t in tickers:
print(t)
lastPrice = trader.get_last_price(t)
item = trader.get_portfolio_item(t)
if item.get_shares() > 0:
sell = shift.Order(
shift.Order.Type.MARKET_SELL, t,
int(item.get_shares() /
100)) # Order size in 100's of shares, strictly as an int
trader.submit_order(sell)
elif item.get_shares() < 0:
buy = shift.Order(
shift.Order.Type.MARKET_BUY, t,
int(-1 * item.get_shares() /
100)) # Order size in 100's of shares, strictly as an int
trader.submit_order(buy)
print(f'submitted buy for {t}')
time.sleep(15)
utils.print_portfolio_information(trader)
utils.print_all_submitted_order(trader)
print(trader.get_last_trade_time())
return
def buy_ticker(self, trader: shift.Trader, tickers, buy_order_size):
lg.debug('buy_tickers :' + str(tickers))
for ticker in tickers:
ticker_buy = shift.Order(shift.Order.Type.MARKET_BUY, ticker,
buy_order_size)
trader.submit_order(ticker_buy)
lg.debug('ticker bought:' + str(ticker))
def run_stop_loss_check(trader: shift.Trader, state: Dict[str, Any]) -> None:
"""
check for stop loss hit
"""
stop_loss_interval = 5 # seconds
acceptable_loss = .2 # percent
if stop_loss_key not in state:
state[stop_loss_key] = {}
while True:
sleep(stop_loss_interval)
for item in trader.get_portfolio_items().values():
ticker = item.get_symbol()
current_price = state[prices_key][ticker][-1]
new_stop_loss = current_price * ((100 - acceptable_loss) / 100.)
has_stop_loss = ticker in state[stop_loss_key]
if not has_stop_loss or new_stop_loss > state[stop_loss_key][
ticker]:
if has_stop_loss:
for order in trader.get_waiting_list():
if order.symbol == ticker and order.type == shift.Order.Type.LIMIT_SELL:
trader.submit_cancellation(order)
limit_sell = shift.Order(shift.Order.Type.LIMIT_SELL, ticker,
item.get_shares())
trader.submit_order(limit_sell)
state[stop_loss_key][ticker] = new_stop_loss, limit_sell
def two(stk, trader):
global THRESHOLD
global NUM_TRADES
price_current = get_current_price(stk.name, trader)
if (stk.current_price - price_current) / stk.current_price >= .01:
stop_loss(stk.name, trader)
stk.H = False
stk.state = 0
NUM_TRADES += 1
return
pressure = get_pressure(stk.name, trader)
if (-1.0 / 3.0) <= pressure <= (1.0 / 3.0):
return
prediction = get_prediction(stk, trader)
# if time.time() - start > TIME_TO_STOP_BUY:
# THRESHOLD /= 1.5
purchase_size = trader.getPortfolioItem(stk.name).getShares()
if purchase_size < 0:
return
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
return
def start_selling(trader, stock_data):
'''
:param trader: The trader object
:param stock_data: The list of stock objects
:return: N/A
'''
for stk in stock_data:
global THRESHOLD
global NUM_TRADES
# price_current = get_current_price(stk.name, trader)
pressure = get_pressure(stk.name, trader)
prediction = get_prediction(stk, trader)
# 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
def sell_ticker(self, trader: shift.Trader, tickers, sell_order_size):
lg.debug('sell_tickers :' + str(tickers))
for ticker in tickers:
# if ticker == 'VIXY':
# order_size = 100
ticker_sell = shift.Order(shift.Order.Type.MARKET_SELL, ticker,
sell_order_size)
trader.submit_order(ticker_sell)
lg.debug('ticker sold:' + str(ticker))
def run_trades(trader: shift.Trader, state: Dict[str, Any]) -> None:
"""
run buy / sell trades
"""
run_trades_interval = 60 # seconds
while True:
sleep(run_trades_interval)
unsorted_differences: List[float] = []
unsorted_tickers: List[str] = []
for ticker in tickers:
prices = np.array(list(state[prices_key][ticker]))
ema_difference, price_minus_bollinger = get_should_long(prices)
unsorted_differences.append(ema_difference)
unsorted_tickers.append(ticker)
_, ranked_tickers = map(
list, zip(*sorted(zip(unsorted_differences, unsorted_tickers))))
for ticker in ranked_tickers:
prices = np.array(list(state[prices_key][ticker]))
ema_difference, price_minus_bollinger = get_should_long(prices)
item = trader.get_portfolio_item(ticker)
if item.get_shares() > 0:
# check to sell
if price_minus_bollinger > 0 or ema_difference < 0:
sell = shift.Order(
shift.Order.Type.MARKET_SELL, ticker,
int(math.ceil((item.get_shares() / 2) / 100.0)))
trader.submit_order(sell)
else:
for order in trader.get_waiting_list():
if order.symbol == ticker and order.type == shift.Order.Type.MARKET_BUY:
trader.submit_cancellation(order)
if ema_difference > 0:
bp = trader.get_portfolio_summary().get_total_bp()
amount = 200e3
if bp >= amount:
lastPrice = trader.get_last_price(ticker)
s = int((amount / lastPrice) / 100.)
buy = shift.Order(shift.Order.Type.MARKET_BUY, ticker,
s)
trader.submit_order(buy)
def stop_loss(stock, trader):
'''
:param stock: The stock symbol
:param trader: The trader object
:return: N/A
'''
cancel_sell_order(stock,trader)
portfolio_item = trader.getPortfolioItem(stock)
num_shares = int(portfolio_item.getShares()/100)
trader.submitOrder(shift.Order(shift.Order.MARKET_SELL, stock, size=num_shares))
def demo_01(trader: shift.Trader):
"""
This method submits a limit buy order by indicating order type, symbol, size, and limit price.
:param trader:
:return:
"""
limit_buy = shift.Order(shift.Order.Type.LIMIT_BUY, "AAPL", 1, 10.00)
trader.submit_order(limit_buy)
return
def demo01(trader):
"""
This method submits a limit buy order by indicating symbol, limit price, limit size and order type.
:param trader:
:return:
"""
limitBuy = shift.Order(shift.Order.LIMIT_BUY, "AAPL", 1, 10.00)
trader.submitOrder(limitBuy)
return
def execute_trade(self):
stock = self._trader.get_stock_list()[np.random.randint(0, 30)]
if np.random.binomial(n=1, p=0.5) == 0:
typ = shift.Order.Type.MARKET_BUY
else:
typ = shift.Order.Type.MARKET_SELL
order = shift.Order(typ, stock, self._get_trade_size(stock, typ))
self._orders.append(order)
self._trader.submit_order(order)
time.sleep(1)
if self._verbose:
print(f"BP: {self._trader.get_portfolio_summary().get_total_bp()}")
def update_sell_order(stk, trader, price):
'''
:param stk: The stock object
:param trader: The trader object
:param price: The price for the new sell order
:return: N/A
'''
for order in trader.getWaitingList():
if order.symbol == stk.name and order.type == shift.Order.LIMIT_SELL:
order.type = shift.Order.CANCEL_ASK
trader.submitOrder(order)
PURCHASE_SIZE = trader.getPortfolioItem(stk.name).getShares()
limit_sell = shift.Order(shift.Order.LIMIT_SELL, stk.name, PURCHASE_SIZE, price)
trader.submitOrder(limit_sell)
return
stk.SO = False
stk.H = False
stk.state = 0
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 update_buy_order(stk, trader, price):
'''
:param stk: The stock object
:param trader: The trader object
:param price: The price for the new buy order
:return: N/A
'''
for order in trader.getWaitingList():
if order.symbol == stk.name and order.type == shift.Order.LIMIT_BUY:
order.type = shift.Order.CANCEL_BID
trader.submitOrder(order)
PURCHASE_SIZE = purchasizing_size(stk, trader)
limit_buy = shift.Order(shift.Order.LIMIT_BUY, stk.name, PURCHASE_SIZE, price)
trader.submitOrder(limit_buy)
return
stk.current_price = stk.predicted_price
stk.BO = False
stk.H = True
stk.state = 2
def place_orders(order_type: shift.Order.Type, ticker: str, size: int):
order = shift.Order(order_type, ticker, size)
trader.submit_order(order)
# orders_to_place = []
#78 => 7x10 + 1x8
# placed = 0
# for i in range(size):
# order = shift.Order(order_type, ticker, 1)
# trader.submit_order(order)
# orders_to_place.append(order)
# placed += 10
# sleep(1)
# left = size - placed
# if left > 0:
# # left < 10
# for i in range(left):
# order = shift.Order(order_type, ticker, 1)
# trader.submit_order(order)
# orders_to_place.append(order)
# sleep(1)
return [order]
def demo_01(trader: shift.Trader):
# We haven't developed a strategy yet.
# We only want to test whether we could
# get through the market/limit orders
limit_buy = shift.Order(shift.Order.Type.LIMIT_BUY, "AAPL", 10, 165.00)
trader.submit_order(limit_buy)
xom_limit_buy = shift.Order(shift.Order.Type.LIMIT_BUY, "XOM", 10, 10.00)
trader.submit_order(xom_limit_buy)
aapl_market_buy = shift.Order(shift.Order.Type.MARKET_BUY, "AAPL", 1)
trader.submit_order(aapl_market_buy)
xom_market_buy = shift.Order(shift.Order.Type.MARKET_BUY, "XOM", 1)
trader.submit_order(xom_market_buy)
aapl_market_sell = shift.Order(shift.Order.Type.MARKET_SELL, "AAPL", 1)
trader.submit_order(aapl_market_sell)
xom_market_sell = shift.Order(shift.Order.Type.MARKET_SELL, "XOM", 1)
trader.submit_order(xom_market_sell)
print("AAPL:")
print(" Price\t\tSize\t Dest\t\tTime")
for order in trader.get_order_book("AAPL", shift.OrderBookType.LOCAL_BID):
print("%7.2f\t\t%4d\t%6s\t\t%19s" %
(order.price, order.size, order.destination, order.time))
print()
print("XOM:")
print(" Price\t\tSize\t Dest\t\tTime")
for order in trader.get_order_book("XOM", shift.OrderBookType.LOCAL_BID):
print("%7.2f\t\t%4d\t%6s\t\t%19s" %
(order.price, order.size, order.destination, order.time))
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(),
))
return
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]
def main(trader: shift.Trader) -> None:
"""
main entrypoint
"""
# {
# "prices": {
# "AAPL": [234]
# },
# }
manager = Manager()
list_of_shared_dicts = manager.list()
list_of_shared_dicts.append({})
# prices_state = list_of_shared_dicts[0]
# stop_losses_state = list_of_shared_dicts[1]
state = list_of_shared_dicts[0]
keys_in_state = [prices_key, stop_loss_key, target_key]
for key in keys_in_state:
state[key] = manager.dict()
for ticker in tickers:
if key == prices_key:
state[key].setdefault(key, [])
elif key == target_key:
state[key].setdefault(key, [0,0])
# if key == stop_loss_key:
# state[trader_key] = trader
# trader_obj = state
check_time = 1 # minutes
current = trader.get_last_trade_time()
start_time = datetime.combine(current, dt.time(10,0,0))
end_time = datetime.combine(current, dt.time(15, 30, 0))
print(trader.get_last_trade_time())
pre_processes = []
for ticker in tickers:
# 1 thread per ticker getting price data & saving it
pre_processes.append(Thread(target=run_save_prices, args=(ticker, trader, state)))
# run_save_prices(ticker, trader, state)
for process in pre_processes:
process.start()
print(f"{len(pre_processes)} processes created for run_save_prices")
while trader.get_last_trade_time() < start_time:
print(f"Waiting for Market Open @ {trader.get_last_trade_time()}")
sleep(check_time * 60)
processes = pre_processes.extend(run_processes(trader, state))
while trader.get_last_trade_time() < end_time:
print(f"Waiting for Market Close @ {trader.get_last_trade_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 run_stop_loss_check(trader: shift.Trader, state: Dict[str, Any]) -> None:
"""
check for stop loss hit
"""
stop_loss_interval = 5 # seconds
acceptable_loss = .2 # percent
# if stop_loss_key not in stop_losses_state:
# stop_losses_state = {}
'''
Set original stop loss when originally buying to -.2%
Set original target when originally buying to the bollinger band
Update target every minute to the most recent bollinger band
First time you hit target:
remove half position
update stop loss to original buy prices and make this a trailing stop
Keep updating target
Scenario:
Buy 100 at 100
Set stop loss to 99.8 and target to 101
We hit 101 so we sell 50 (left with 50) and update stop loss to 100
101 - 100 = stop loss
Next minute upper band changes to 102: change target to 102
Next minute upper band changes to 99: sell everything
ALREADY HIT TARGET ONCE: We hit 102 so we sell 25 (left with 25) and update stop loss to 101
price goes to 101.50, stop loss is 101
price hits target at 104, stop loss is 103.50
begin position
initial_buy_price = ...
target = upper_bollinger_band[-1]
stop_loss = initial_buy_price*-.002
first target hits
stop_loss = (1 - ((first_target_sell - initial_buy_price) / initial_buy_price))*current_price
price goes up
stop_loss = (1 - ((first_target_sell - initial_buy_price) / initial_buy_price))*current_price
second target hits - just half, and reapply trailing stop loss
stop_loss = (1 - ((first_target_sell - initial_buy_price) / initial_buy_price))*current_price
price goes down
stop_loss = stop_loss
'''
while True:
sleep(stop_loss_interval)
for item in trader.get_portfolio_items().values():
ticker = item.get_symbol()
current_price = state[prices_key][ticker][-1]
new_stop_loss = current_price * ((100 - acceptable_loss) / 100.)
has_stop_loss = ticker in state[stop_loss_key]
if not has_stop_loss or new_stop_loss > state[stop_loss_key][ticker]:
if has_stop_loss:
for order in trader.get_waiting_list():
if order.symbol == ticker and order.type == shift.Order.Type.LIMIT_SELL:
trader.submit_cancellation(order)
limit_sell = shift.Order(shift.Order.Type.LIMIT_SELL, ticker, item.get_shares())
trader.submit_order(limit_sell)
state[stop_loss_key][ticker] = new_stop_loss, limit_sell
