def balance_positions(exchange: Exchange, total_threshold: int = 100, individual_threshold: int = 350): positions = exchange.get_positions() pos_a, pos_b = positions["PHILIPS_A"], positions["PHILIPS_B"] total_position = pos_a + pos_b if balance_individual(exchange, positions, "PHILIPS_A", 200, individual_threshold) or \ balance_individual(exchange, positions, "PHILIPS_B", 200, individual_threshold): return True if total_position > total_threshold: sell_all_positions( exchange, positions, max_a=get_best_price(exchange.get_last_price_book("PHILIPS_A"), "sell"), max_b=get_best_price(exchange.get_last_price_book("PHILIPS_B"), "sell"), target=total_threshold / 4) elif total_position < -total_threshold: buy_all_positions( exchange, positions, min_a=get_best_price(exchange.get_last_price_book("PHILIPS_A"), "buy"), min_b=get_best_price(exchange.get_last_price_book("PHILIPS_B"), "buy"), target=total_threshold / 4) return False
class Bot: instruments = ["PHILIPS_A", "PHILIPS_B"] def __init__(self): self.e = Exchange() logging.info(self.e.connect()) logging.info("Setup was successful.") def get_out_of_positions(self): # Get out of all positions you are currently holding, regardless of the loss involved. That means selling whatever # you are long, and buying-back whatever you are short. Be sure you know what you are doing when you use this logic. print(self.e.get_positions()) for s, p in self.e.get_positions().items(): if p > 0: self.e.insert_order(s, price=1, volume=p, side='ask', order_type='ioc') elif p < 0: self.e.insert_order(s, price=100000, volume=-p, side='bid', order_type='ioc') print(self.e.get_positions()) # Logging functions def log_new_trade_ticks(self): logger.info("Polling new trade ticks") for i in self.instruments: tradeticks = self.e.poll_new_trade_ticks(i) for t in tradeticks: logger.info( f"[{t.instrument_id}] price({t.price}), volume({t.volume}), aggressor_side({t.aggressor_side}), buyer({t.buyer}), seller({t.seller})" ) def log_positions_cash(self): logger.info(self.e.get_positions_and_cash()) def log_all_outstanding_orders(self): for i in self.instruments: logger.info(self.e.get_outstanding_orders(i)) def wait_until_orders_complete(self): orders_outstanding = True while orders_outstanding: orders_outstanding = False for i in self.instruments: if len(self.e.get_outstanding_orders(i)) > 0: orders_outstanding = True self.log_all_outstanding_orders() #time.sleep(0.1) def mainloop(self): while True: # check for trade differences # m1 ask < m2 bid #logger.info("Checking for discrepancies:") books = [self.e.get_last_price_book(x) for x in self.instruments] for m1, m2 in [(0, 1), (1, 0)]: m1_id = self.instruments[m1] m2_id = self.instruments[m2] try: m1_ask = books[m1].asks[0] m2_bid = books[m2].bids[0] if m1_ask.price < m2_bid.price: logger.info( f"Can profit: buy {m1_id} at {m1_ask} and sell {m2_id} at {m2_bid}" ) self.e.insert_order(m1_id, price=m1_ask.price, volume=1, side='bid', order_type='limit') self.e.insert_order(m2_id, price=m2_bid.price, volume=1, side='ask', order_type='limit') self.log_all_outstanding_orders() self.wait_until_orders_complete() self.log_positions_cash() except Exception as e: print(logger.error(e)) continue time.sleep(1.0 / 25)
order_type='ioc') print(e.get_positions()) # bid, volume p, price 1 - 'I want to buy p units at price 1' # ask, volume p, price 1 - 'I want to sell p units at price 1' # print(e.get_trade_history(instrument_id)) #book = e.get_last_price_book(instrument_id) #print(book.bids) #print(book.asks) # current positions print(e.get_positions_and_cash()) processed_order_book = e.get_last_price_book(instrument_id) print("bid | price | ask") for level in processed_order_book: print(f"{level.bid_volume}|{level.price_level}|{level.ask_volume}") # e.insert_order(instrument_id, price=71.70, volume=1, side='bid', order_type='limit') """ # buy something e.insert_order(instrument_id, price=70, volume=1, side='bid', order_type='limit') print(e.get_positions_and_cash()) time.sleep(1) # sell something e.insert_order(instrument_id, price=71, volume=1, side='ask', order_type='limit')
start_pnl = e.get_pnl() new_pnl = e.get_pnl() timer = 0 #new_start_b = [average_b(20)]*10 #weighted_prices_b = new_start_b while timer < 2000: stats_a = get_range_a(10000) stats_b = get_range_b(10000) max_range_a = stats_a[0] - stats_a[1] low_range_b = stats_b[1] - stats_b[2] book_a = e.get_last_price_book(philips_a) book_b = e.get_last_price_book(philips_b) if len(book_a.asks) != 0 and len(book_a.bids) != 0: current_ask_a = book_a.asks[0].price current_bid_a = book_a.bids[0].price if len(book_b.asks) != 0 and len(book_b.bids) != 0: current_ask_b = book_b.asks[0].price current_bid_b = book_b.bids[0].price #print(current_ask) average = average_b(2000) #print(average) positions = e.get_positions_and_cash() volume_left_a = positions[philips_a]['volume'] volume_left_b = positions[philips_b]['volume']
from optibook.synchronous_client import Exchange from MainFunctions import getBestAsk import time e = Exchange() a = e.connect() instr_ids = ['PHILIPS_A', 'PHILIPS_B'] index = int(input()) # 0 or 1 instr = instr_ids[index] book = e.get_last_price_book(instr) positions = e.get_positions().values() totalPosition = sum(positions) if (book.asks[0].volume >= abs(totalPosition)): print("Estimated cash by end") cash = e.get_cash() bestAsk = getBestAsk(book) loss = bestAsk * abs(totalPosition) print(cash - loss) print("Proceed?") if (input() == "y"): e.insert_order(instr, price=bestAsk, volume=abs(totalPosition), side='bid', order_type='ioc') time.sleep(5)
# Returns all current positions positions = e.get_positions() for p in positions: print(p, positions[p]) # Returns all current positions with cash investedx positions = e.get_positions_and_cash() for p in positions: print(p, positions[p]) # Returns Current PnL based on last Traded Price pnl = e.get_pnl() print(pnl) book_A = e.get_last_price_book("PHILIPS_A") book_B = e.get_last_price_book("PHILIPS_B") print('bids_PHILIPS_A:') print("bid\tprice\task") for i in reversed(book_A.asks): print('\t' + str(round(i.price, 1)) + '\t' + str(i.volume)) for i in book_A.bids: print(str(i.volume) + '\t' + str(round(i.price, 1)) + '\t') # Returns all public tradeticks since the last time this function was called tradeticks = e.poll_new_trade_ticks(instrument_id) for t in tradeticks: print( f"[{t.instrument_id}] price({t.price}), volume({t.volume}), aggressor_side({t.aggressor_side}), buyer({t.buyer}), seller({t.seller})" )
#We track how our pnl changes start_pnl = e.get_pnl() new_pnl = e.get_pnl() #Timer to report pnl changes every 10 'actions' timer = 0 #new_start_b = [average_b(20)]*10 #weighted_prices_b = new_start_b while timer<2000: stats_a = get_range_a(10000) stats_b = get_range_b(10000) max_range_a = stats_a[0]-stats_a[1] #We scale our purchase volume over the range we expect a typical fluctuation to occur low_range_b = stats_b[1]-stats_b[2] book_a = e.get_last_price_book(philips_a) #Obtain current books each round book_b = e.get_last_price_book(philips_b) if len(book_a.asks)!=0 and len(book_a.bids)!=0: current_ask_a = book_a.asks[0].price current_bid_a = book_a.bids[0].price if len(book_b.asks)!=0 and len(book_b.bids)!=0: current_ask_b = book_b.asks[0].price current_bid_b = book_b.bids[0].price #print(current_ask) average = average_b(2000) #print(average) positions = e.get_positions_and_cash() volume_left_a = positions[philips_a]['volume'] #Obtain Current Positions volume_left_b = positions[philips_b]['volume']
a = e.connect() print(e.get_positions()) for s, p in e.get_positions().items(): if p > 0: e.insert_order(s, price=1, volume=p, side='ask', order_type='ioc') elif p < 0: e.insert_order(s, price=100000, volume=-p, side='bid', order_type='ioc') print(e.get_positions()) instrument_id = 'PHILIPS_A' book = e.get_last_price_book(instrument_id) print(book.bids) instrument_id = 'PHILIPS_A' #result = e.insert_order(instrument_id, price=98, volume=40, side='bid', order_type='limit') #print(f"Order Id: {result}") tradeticks = e.poll_new_trade_ticks(instrument_id) def moving_avg(price_book): average = [] t_end = time.time() + 10 count = 0 while time.time() < t_end: for i in price_book.bids: average.append(i.price)
INSTRUMENT = "PHILIPS_B" e.poll_new_trades(INSTRUMENT) diagonosticsOutput = "" firstTrader = Trader(exchange=e, instrument=INSTRUMENT, instrumentB="PHILIPS_A", orderVolume=ORDER_VOLUME, weightingFactor=WEIGHTING_FACTOR, volumeWeighting=VOLUME_WEIGHTING) executing = True count = 0 while executing: order_book = e.get_last_price_book(instrument_id="PHILIPS_A") # pnl.append(e.get_pnl) bidAskDict = firstTrader.trade() if count > TRADES: executing = False count += 1 sleep(TIME_PERIOD) for t in (e.poll_new_trades("PHILIPS_B")): ''' diagonosticsOutput += f"[TRADED {t.instrument_id}] price({t.price}), volume({t.volume}), side({t.side})\n" diagonosticsOutput += f"Asking in PHILIPS_B for {bidAskDict['ask']}, bidding in PHILIPS_B for {bidAskDict['bid']}\n" if order_book.asks and order_book.bids: diagonosticsOutput += f"Asking in PHILIPS_A for {order_book.asks[0].price}, bidding in PHILIPS_B for {order_book.bids[0].price}" ''' Thread(target=firstTrader.hedge, args=( t,
import time from optibook.synchronous_client import Exchange from MainFunctions import getBestBid, getBestAsk e = Exchange() a = e.connect() ABids = [] AAsks = [] BBids = [] BAsks = [] for i in range(300): ABook = e.get_last_price_book('PHILIPS_A') BBook = e.get_last_price_book('PHILIPS_B') ABids.append(getBestBid(ABook)) AAsks.append(getBestAsk(ABook)) BBids.append(getBestBid(BBook)) BAsks.append(getBestAsk(BBook)) time.sleep(1) f = open("ABids.txt", "a") for line in ABids: f.write(str(line) + "\n") f.close() f = open("BBids.txt", "a") for line in BBids: f.write(str(line) + "\n") f.close()
import logging logger = logging.getLogger('client') logger.setLevel('ERROR') print("Setup was successful.") import time import pandas as pd import os import numpy as np #CONNECT TO EXCHANGE e = Exchange() a = e.connect() instrument_id = 'PHILIPS_A' book = e.get_last_price_book('PHILIPS_A') print(book.asks) print(book.bids) prices = dict() # empty dict print([price_vol.price for price_vol in book.asks]) print([price_vol.price for price_vol in book.bids]) instrument_id1 = 'PHILIPS_A' instrument_id2 = 'PHILIPS_B' books = e.get_last_price_book(instrument_id) def print_table(books): print("bid | price | ask")
# Assume instrument A has higher liquidilty # Work out the time lag between Philips A and Philips B def get_lag(): return 5 #execute lowLiq = "PHILIPS_B" highLiq = "PHILIPS_A" count_trades = 0 while (count_trades < 10): hLBook = e.get_last_price_book(highLiq) bestAsk = getBestAsk(hLBook) if (bestAsk is not None): e.insert_order(highLiq, price=bestAsk + 0.1, volume=5, side='ask', order_type='limit') time.sleep(get_lag() - 2) currentTradeId = e.insert_order(lowLiq, price=bestAsk, volume=5, side='bid', order_type='limit') print("Sell to A") count_trades = count_trades + 1
get_info() # retreives the best bid/ask price from exchange. If the best bid price for B is greater than the best ask for A, sell to B and buy from A. for i in range(0, 10000): positions = e.get_positions() #print("test") try: #print("B Bid : ", e.get_last_price_book('PHILIPS_B').bids[0].price) #print("A Ask : ", e.get_last_price_book('PHILIPS_A').asks[0].price) #print("B Ask : ", e.get_last_price_book('PHILIPS_B').asks[0].price) #print("A Bid : ", e.get_last_price_book('PHILIPS_A').bids[0].price) #if (e.get_last_price_book('PHILIPS_B').asks[0].price > e.get_last_price_book('PHILIPS_A').asks[0].price and e.get_last_price_book('PHILIPS_B').bids[0].price < e.get_last_price_book('PHILIPS_A').bids[0].price and if ((e.get_last_price_book('PHILIPS_B').asks[0].price > e.get_last_price_book('PHILIPS_A').bids[0].price) and (e.get_last_price_book('PHILIPS_B').asks[0].price - e.get_last_price_book('PHILIPS_A').bids[0].price) > .30): #if (e.get_last_price_book('PHILIPS_B').asks[0].price > e.get_last_price_book('PHILIPS_A').bids[0].price) : #print(f"First set of Conditions for Entry 1-2-3-4") volume = e.get_last_price_book('PHILIPS_B').bids[0].volume price_B = round( e.get_last_price_book('PHILIPS_B').asks[0].price, 3) price_A = round( e.get_last_price_book('PHILIPS_A').bids[0].price, 3) #print("Check Spread B-mid : ", price_B - (round((price_A + price_B) / 2 ,3)), " A-mid : ", (round((price_A + price_B) / 2 ,3))-price_A ) mid_price = round((price_A + price_B) / 2, 3) diff = round(abs(price_A - mid_price), 3) if volume > 30: volume = 30
# this function could also export statistics and data for further analysis if it were nexessary last_trades_update = time.time() last_position = (0, 0) done = False while not done: try: while not e.is_connected(): print(timestamp() + 'disconnected, trying to reconnect...') time.sleep(1) e.connect() positions = e.get_positions() position = (positions.get(pha), positions.get(phb)) if position != last_position: last_position = position trades = e.poll_new_trades(pha) + e.poll_new_trades(phb) if trades: summarize_trades(trades) print(timestamp() + f"==> POSITION: PHA: {position[0]}, PHB: {position[1]}") books = e.get_last_price_book(pha), e.get_last_price_book(phb) try_to_trade(0, books, position) # buy PHA, sell PHB try_to_trade(1, books, position) # buy PHB, sell PHA except KeyboardInterrupt: done = True except Exception as exc: print(timestamp() + "error: " + str(exc))
class AutoTrader: """ This is the "main" class which houses our algorithm. You will see there are a few helper functions already here, as well as a main "trade" function which runs the algorithm. We've done some work for you already there, but you will need to write the bulk of the strategy yourself. """ def __init__(self): self.exchange_client = Exchange() def connect(self): """ Connect to the optibook exchange """ self.exchange_client.connect() def get_order_book_for_instrument(self, instrument): return self.exchange_client.get_last_price_book(instrument) def get_position_for_instrument(self, instrument): positions = self.exchange_client.get_positions() return positions[instrument] def get_top_of_book(self, order_book): """ Get the best bid and best ask of the order book you pass in as a parameter. """ best_bid_price = None best_bid_volume = None if len(order_book.bids) > 0: best_bid_price = round(order_book.bids[0].price, 2) best_bid_volume = round(order_book.bids[0].volume, 2) best_ask_price = None best_ask_volume = None if len(order_book.asks) > 0: best_ask_price = round(order_book.asks[0].price, 2) best_ask_volume = round(order_book.asks[0].volume, 2) return TopOfBook(best_bid_price, best_bid_volume, best_ask_price, best_ask_volume) def print_top_of_book(self, instrument, top_of_book): print( f'[{instrument}] bid({top_of_book.best_bid_volume}@{top_of_book.best_bid_price})-ask({top_of_book.best_ask_volume}@{top_of_book.best_ask_price})' ) def insert_buy_order(self, instrument, price, volume, order_type): """ Insert an order to buy. Note that volume must be positive. Also note that you have no guarantee that your order turns into a trade. instrument: str The name of the instrument to buy. price: float The price level at which to insert the order into the order book on the bid side. volume: int The volume to buy. order_type: int You can set this to 'limit' or 'ioc'. 'limit' orders stay in the book while any remaining volume of an 'ioc' that is not immediately matched is cancelled. return: an InsertOrderReply containing a request_id as well as an order_id, the order_id can be used to e.g. delete or amend the limit order later. """ return self.exchange_client.insert_order(instrument, price=price, volume=volume, side='bid', order_type=order_type) def insert_sell_order(self, instrument, price, volume, order_type): """ Insert an order to sell. Note that volume must be positive. Also note that you have no guarantee that your order turns into a trade. instrument: str The name of the instrument to sell. price: float The price level at which to insert the order into the order book on the ask side. volume: int The volume to sell. order_type: int You can set this to 'limit' or 'ioc'. 'limit' orders stay in the book while any remaining volume of an 'ioc' that is not immediately matched is cancelled. return: an InsertOrderReply containing a request_id as well as an order_id, the order_id can be used to e.g. delete or amend the limit order later. """ return self.exchange_client.insert_order(instrument, price=price, volume=volume, side='ask', order_type=order_type) def trade(self): """ This function is the main trading algorithm. It is called in a loop, and in every iteration of the loop we do the exact same thing. We start by getting the order books, formatting them a little bit and then you will have to make a trading decision based on the prices in the order books. """ # First we get the current order books of both instruments full_book_liquid = self.get_order_book_for_instrument( LIQUID_INSTRUMENT) full_book_illiquid = self.get_order_book_for_instrument( ILLIQUID_INSTRUMENT) # Then we extract the best bid and best ask from those order books top_book_liquid = self.get_top_of_book(full_book_liquid) top_book_illiquid = self.get_top_of_book(full_book_illiquid) # If either the bid side or ask side is missing, in the order books, then we stop right here and wait for the # next cycle, in the hopes that then the order books will have both the bid and ask sides present if not top_book_liquid.has_bid_and_ask( ) or not top_book_illiquid.has_bid_and_ask(): print( 'There are either no bids or no asks, skipping this trade cycle.' ) return # Print the top of each book, this will be very helpful to you when you want to understand what your # algorithm is doing. Feel free to add more logging as you see fit. self.print_top_of_book(LIQUID_INSTRUMENT, top_book_liquid) self.print_top_of_book(ILLIQUID_INSTRUMENT, top_book_illiquid) print('')
class AutoTrader: """ This is the "main" class which houses our algorithm. You will see there are a few helper functions already here, as well as a main "trade" function which runs the algorithm. We've done some work for you already there, but you will need to write the bulk of the strategy yourself. """ def __init__(self): self.exchange_client = Exchange() def connect(self): """ Connect to the optibook exchange """ self.exchange_client.connect() def get_order_book_for_instrument(self, instrument): return self.exchange_client.get_last_price_book(instrument) def get_position_for_instrument(self, instrument): positions = self.exchange_client.get_positions() return positions[instrument] def get_top_of_book(self, order_book): """ Get the best bid and best ask of the order book you pass in as a parameter. """ best_bid_price = None best_bid_volume = None if len(order_book.bids) > 0: best_bid_price = round(order_book.bids[0].price, 2) best_bid_volume = round(order_book.bids[0].volume, 2) best_ask_price = None best_ask_volume = None if len(order_book.asks) > 0: best_ask_price = round(order_book.asks[0].price, 2) best_ask_volume = round(order_book.asks[0].volume, 2) return TopOfBook(best_bid_price, best_bid_volume, best_ask_price, best_ask_volume) def print_top_of_book(self, instrument, top_of_book): print( f'[{instrument}] bid({top_of_book.best_bid_volume}@{top_of_book.best_bid_price})-ask({top_of_book.best_ask_volume}@{top_of_book.best_ask_price})' ) def insert_buy_order(self, instrument, price, volume, order_type): """ Insert an order to buy. Note that volume must be positive. Also note that you have no guarantee that your order turns into a trade. instrument: str The name of the instrument to buy. price: float The price level at which to insert the order into the order book on the bid side. volume: int The volume to buy. order_type: int You can set this to 'limit' or 'ioc'. 'limit' orders stay in the book while any remaining volume of an 'ioc' that is not immediately matched is cancelled. return: an InsertOrderReply containing a request_id as well as an order_id, the order_id can be used to e.g. delete or amend the limit order later. """ return self.exchange_client.insert_order(instrument, price=price, volume=volume, side='bid', order_type=order_type) def insert_sell_order(self, instrument, price, volume, order_type): """ Insert an order to sell. Note that volume must be positive. Also note that you have no guarantee that your order turns into a trade. instrument: str The name of the instrument to sell. price: float The price level at which to insert the order into the order book on the ask side. volume: int The volume to sell. order_type: int You can set this to 'limit' or 'ioc'. 'limit' orders stay in the book while any remaining volume of an 'ioc' that is not immediately matched is cancelled. return: an InsertOrderReply containing a request_id as well as an order_id, the order_id can be used to e.g. delete or amend the limit order later. """ return self.exchange_client.insert_order(instrument, price=price, volume=volume, side='ask', order_type=order_type) def increase(self, array): last = array[0] for element in array: if (element < last): return False last = element return True def decrease(self, array): last = array[0] for element in array: if (element > last): return False last = element return True def trade(self): """ This function is the main trading algorithm. It is called in a loop, and in every iteration of the loop we do the exact same thing. We start by getting the order books, formatting them a little bit and then you will have to make a trading decision based on the prices in the order books. """ # First we get the current order books of both instruments full_book_liquid = self.get_order_book_for_instrument( LIQUID_INSTRUMENT) full_book_illiquid = self.get_order_book_for_instrument( ILLIQUID_INSTRUMENT) # Then we extract the best bid and best ask from those order books top_book_liquid = self.get_top_of_book(full_book_liquid) top_book_illiquid = self.get_top_of_book(full_book_illiquid) # If either the bid side or ask side is missing, in the order books, then we stop right here and wait for the # next cycle, in the hopes that then the order books will have both the bid and ask sides present if not top_book_liquid.has_bid_and_ask( ) or not top_book_illiquid.has_bid_and_ask(): print( 'There are either no bids or no asks, skipping this trade cycle.' ) return # Print the top of each book, this will be very helpful to you when you want to understand what your # algorithm is doing. Feel free to add more logging as you see fit. self.print_top_of_book(LIQUID_INSTRUMENT, top_book_liquid) self.print_top_of_book(ILLIQUID_INSTRUMENT, top_book_illiquid) print('') # Trade! # Take if from here, and implement your actual strategy with the help of the pre-processing we have done for you # above. Note that this is very rudimentary, and there are things we have left out (e.g. position management is # missing, hedging is missing, and how much credit you ask for is also missing). # # Maybe a first step is to run this code as is, and see what it prints out to get some inspiration if you are # stuck. Otherwise, come to us, we are always happy to help. Check the client documentation for all the # functions that are at your disposal. # # ----------------------------------------- # TODO: Implement trade logic here ''' instruments = ['PHILIPS_A', 'PHILIPS_B'] SIZE = 5 for index, instrument in enumerate(instruments): asks[index].append(self.get_top_of_book(self.get_order_book_for_instrument(instrument)).best_ask_price) if len(asks[index]) > SIZE: asks[index].pop(0) bids[index].append(self.get_top_of_book(self.get_order_book_for_instrument(instrument)).best_bid_price) if len(bids[index]) > SIZE: bids[index].pop(0) print(asks) print(bids) positions = self.exchange_client.get_positions() stocks = positions[instrument] if (len(bids[index]) == SIZE and self.increase(bids[index])): print("stocks"+str(stocks)) doTrade = self.insert_sell_order(instrument, self.get_top_of_book(self.get_order_book_for_instrument(instrument)).best_bid_price, max(1, int(stocks * 1/5)), 'ioc') # come back and change volume print("sell") elif len(asks[index]) == SIZE and self.decrease(asks[index]) and (positions[instruments[1]] + positions[instruments[0]]) <200: print("positions: " + str(positions[instrument])) doTrade = self.insert_buy_order(instrument, self.get_top_of_book(self.get_order_book_for_instrument(instrument)).best_ask_price, 1, 'ioc') #change volvume print("buy") ''' ''' instruments = ['PHILIPS_A', 'PHILIPS_B'] SIZE = 100 for index, instrument in enumerate(instruments): aux = self.get_top_of_book(self.get_order_book_for_instrument(instrument)).best_ask_price if aux: asks[index].append(aux) if len(asks[index]) > SIZE: asks[index].pop(0) aux = self.get_top_of_book(self.get_order_book_for_instrument(instrument)).best_bid_price bids[index].append(aux) if len(bids[index]) > SIZE: bids[index].pop(0) if SIZE == len(asks[index]): averageAsk = sum(asks[index]) / len(asks) averageBid = sum(bids[index]) / len(bids) positions = self.exchange_client.get_positions() stocks = positions[instrument] if averageBid > self.get_top_of_book(self.get_order_book_for_instrument(instrument)).best_bid_price and abs(stocks) < 100: print(abs(stocks)) doTrade = self.insert_buy_order(instrument, self.get_top_of_book(self.get_order_book_for_instrument(instrument)).best_bid_price - 0.5, , 'ioc') print("buy") if averageAsk < self.get_top_of_book(self.get_order_book_for_instrument(instrument)).best_ask_price : doTrade = self.insert_sell_order(instrument, self.get_top_of_book(self.get_order_book_for_instrument(instrument)).best_ask_price + 0.5, max(1, int(stocks * 1/2)), 'ioc') # come back and change volume print("sell") ''' bidA = None askB = None instruments = ['PHILIPS_A', 'PHILIPS_B'] SIZE = 1 while (not askB) or (not bidA): bidA = self.get_top_of_book( self.get_order_book_for_instrument( instruments[0])).best_bid_price askB = self.get_top_of_book( self.get_order_book_for_instrument( instruments[1])).best_ask_price if bidA - askB > 0 and askB < 1000: doTrade = self.insert_sell_order(instruments[0], bidA, SIZE, 'ioc') doTrade = self.insert_buy_order(instruments[1], askB, SIZE, 'ioc') print("bidA and askB") bidB = None askA = None while (not askA) or (not bidB): bidB = self.get_top_of_book( self.get_order_book_for_instrument( instruments[1])).best_bid_price askA = self.get_top_of_book( self.get_order_book_for_instrument( instruments[0])).best_ask_price if bidB - askA > 0 and askA < 1000: doTrade = self.insert_sell_order(instruments[1], bidB, SIZE, 'ioc') doTrade = self.insert_buy_order(instruments[0], askA, SIZE, 'ioc') print("bidB and askA")
#CONNECT TO EXCHANGE e = Exchange() a = e.connect() # you can also define host/user/pass yourself # when not defined, it is taken from ~/.optibook file if it exists # if that file does not exists, an error is thrown #e = Exchange(host='host-to-connect-to') #a = e.connect(username='******', password='******') trades = e.poll_new_trades(instrument_id) for t in trades: print( f"[TRADED {t.instrument_id}] price({t.price}), volume({t.volume}), side({t.side})" ) positions = e.get_positions() for p in positions: print(p, positions[p]) print("\n") book = e.get_last_price_book('PHILIPS_A') book_b = e.get_last_price_book("PHILIPS_B") books = (book, book_b) # print(book.asks) # print(book.bids)
def whicheXchange(): if PA_BID != PB_BID && VA_BID < VB_BID : TradedBib = VA_BID TradedVol = VA_BID else TradedBib = VA_BID TradedVol = VA_BID """ for i in range(0, 10000): positions = e.get_positions() #print("test") try: PA_BID = round(e.get_last_price_book('PHILIPS_B').bids[0].price, 3) PA_ASK = round(e.get_last_price_book('PHILIPS_A').asks[0].price, 3) PB_BID = round(e.get_last_price_book('PHILIPS_A').bids[0].price, 3) PB_ASK = round(e.get_last_price_book('PHILIPS_B').asks[0].price, 3) VA_BID = e.get_last_price_book('PHILIPS_A').bids[0].volume VB_BID = e.get_last_price_book('PHILIPS_B').bids[0].volume VA_ASK = e.get_last_price_book('PHILIPS_A').asks[0].volume VA_ASK = e.get_last_price_book('PHILIPS_B').asks[0].volume whicheXchange() #if (e.get_last_price_book('PHILIPS_B').asks[0].price > e.get_last_price_book('PHILIPS_A').asks[0].price and e.get_last_price_book('PHILIPS_B').bids[0].price < e.get_last_price_book('PHILIPS_A').bids[0].price and if ((e.get_last_price_book('PHILIPS_B').asks[0].price > e.get_last_price_book('PHILIPS_A').bids[0].price) and (e.get_last_price_book('PHILIPS_B').asks[0].price - e.get_last_price_book('PHILIPS_A').bids[0].price) > .30): #if (e.get_last_price_book('PHILIPS_B').asks[0].price > e.get_last_price_book('PHILIPS_A').bids[0].price) :
e = Exchange() a = e.connect() # Returns all current positions # positions = e.get_positions() # for p in positions: # print(p, positions[p]) # print("-----------------------------") # # print(e.get_outstanding_orders(p)) # # print("-----------------------------") # print(e.get_last_price_book(p).asks) # print(e.get_last_price_book(p).bids) while True: if len(e.get_last_price_book(instrument_id1).bids) == 0 or \ len(e.get_last_price_book(instrument_id1).asks) == 0 or \ len(e.get_last_price_book(instrument_id2).bids) == 0 or \ len(e.get_last_price_book(instrument_id2).asks) == 0: time.sleep(0.25) else: A_best_bid = e.get_last_price_book(instrument_id1).bids[0].price A_best_ask = e.get_last_price_book(instrument_id1).asks[0].price B_best_bid = e.get_last_price_book(instrument_id2).bids[0].price B_best_ask = e.get_last_price_book(instrument_id2).asks[0].price # print(A_best_bid, A_best_ask, B_best_bid, B_best_ask) if A_best_bid > B_best_ask: A_best_bid_vol = e.get_last_price_book(instrument_id1).bids[0].volume B_best_ask_vol = e.get_last_price_book(instrument_id2).asks[0].volume