def api_calls(self):
"""Inital and coin specific api calls"""
worker = Worker(self.api_history)
worker.signals.progress.connect(self.mw.live_data.batch_history)
self.mw.threadpool.start(worker)
worker = Worker(self.api_depth)
worker.signals.progress.connect(self.mw.live_data.batch_orderbook)
worker.signals.finished.connect(self.mw.limit_pane.t_complete)
self.mw.threadpool.start(worker)
self.get_trade_history(self.mw.cfg_manager.pair)
def cancel_order_byId(self, order_id, symbol):
"""Cancel an order by id from within a separate thread."""
worker = Worker(
partial(self.mw.api_manager.api_cancel_order, app.client, order_id,
symbol))
# worker.signals.progress.connect(self.cancel_callback)
self.threadpool.start(worker)
def trade_callback(self, msg):
self.mw.trade_history.insert(
0, {
"price": msg["p"],
"quantity": msg["q"],
"maker": bool(msg["m"]),
"time": msg["T"]
})
if len(self.mw.trade_history) > 50:
self.mw.trade_history.pop()
# make a copy to track changes later
# val["tradeHistory"] = self.mw.trade_history[:]
history = {
"price": msg["p"],
"quantity": msg["q"],
"maker": bool(msg["m"]),
"time": msg["T"]
}
worker = Worker(partial(self.socket_history, history))
worker.signals.progress.connect(self.mw.live_data.progress_history)
# worker.signals.finished.connect(self.t_complete)
self.threadpool.start(worker)
self.api_updates += 1
def schedule_kline_check(self, progress_callback):
print("schedule kline check")
maxThreads = self.threadpool.maxThreadCount()
if maxThreads <= 2:
sleepTime = 1
elif maxThreads <= 4:
sleepTime = 0.33
longSleep = 30
elif maxThreads <= 8:
sleepTime = 0.15
longSleep = 15
else:
sleepTime = 0.1
longSleep = 1
# kline api call loop
while True:
# print("Spawning api call workers")
for coin in val["coins"]:
time.sleep(sleepTime)
worker = Worker(partial(self.mw.api_manager.get_kline, coin))
worker.signals.progress.connect(self.klines_received)
self.threadpool.tryStart(worker)
time.sleep(longSleep)
def schedule_websockets(self):
# Pass the function to execute
worker = Worker(self.start_sockets)
# worker.signals.progress.connect(self.mw.live_data.progress_fn)
# Execute
self.threadpool.start(worker)
def initialize(self):
print("open orders init")
self.cellClicked.connect(self.open_orders_cell_clicked)
worker = Worker(self.mw.api_manager.api_all_orders)
worker.signals.progress.connect(self.build_open_orders)
self.mw.threadpool.start(worker)
self.verticalHeader().setSectionResizeMode(QtWidgets.QHeaderView.Fixed)
self.verticalHeader().setDefaultSectionSize(30)
self.set_width()
def schedule_work(self):
# Pass the function to execute
worker = Worker(self.check_for_update)
# Any other args, kwargs are passed to the run function
# worker.signals.result.connect(self.print_output)
worker.signals.progress.connect(self.tick)
# start thread
self.threadpool.start(worker)
def depth_callback(self, msg):
old_bids = val["bids"]
old_asks = val["asks"]
val["bids"] = msg["bids"]
val["asks"] = msg["asks"]
# if old_bids != val["bids"]:
worker = Worker(partial(self.socket_orderbook, msg))
worker.signals.progress.connect(self.mw.live_data.progress_orderbook)
# worker.signals.finished.connect(self.t_complete)
self.threadpool.tryStart(worker)
# if old_asks != val["asks"]:
# worker = Worker(partial(self.socket_orderbook, msg["asks"]))
# # worker.signals.progress.connect(self.mw.live_data.progress_orderbook)
# # worker.signals.finished.connect(self.t_complete)
# self.threadpool.tryStart(worker)
self.api_updates += 1
def get_trade_history(self, pair):
worker = Worker(partial(self.api_order_history, pair))
worker.signals.progress.connect(self.mw.history_table.orders_received)
self.mw.threadpool.start(worker)
def start_kline_iterator(self):
worker = Worker(self.iterate_through_klines)
worker.signals.progress.connect(self.final_draw)
self.threadpool.start(worker)
def start_kline_check(self):
print("start kline check")
worker = Worker(self.schedule_kline_check)
# worker.signals.progress.connect(self.rec_func)
self.threadpool.start(worker)
def create_signal(self):
worker = Worker(self.func_to_call)
worker.signals.progress.connect(self.receiver)
self.threadpool.start(worker)
self.counter = 5
def user_callback(self, msg):
# print("user callback")
# print("####################")
# print(str(self))
# print(msg)
userMsg = dict()
self.api_updates += 1
for key, value in msg.items():
userMsg[key] = value
if userMsg["e"] == "outboundAccountInfo":
for i in range(len(userMsg["B"])):
# put account info in accHoldings dictionary. Access
# free and locked holdings like so: accHoldings["BTC"]["free"]
val["accHoldings"][userMsg["B"][i]["a"]] = {
"free": userMsg["B"][i]["f"],
"locked": userMsg["B"][i]["l"]
}
# update holdings table in a separate thread
worker = Worker(self.socket_update_holdings)
# update values in holdings table
worker.signals.finished.connect(
self.mw.holdings_table.holding_updated)
self.threadpool.start(worker)
elif userMsg["e"] == "executionReport":
# prepare order dictionary
order = dict()
order = {
"symbol": userMsg["s"],
"price": userMsg["p"],
"origQty": userMsg["q"],
"side": userMsg["S"],
"orderId": userMsg["i"],
"status": userMsg["X"],
"time": userMsg["T"],
"type": userMsg["o"],
"executedQty": userMsg["z"]
}
# propagate order
worker = Worker(partial(self.socket_order, order))
if userMsg["X"] == "NEW":
worker.signals.progress.connect(
self.mw.open_orders.add_to_open_orders)
# worker.signals.progress.connect(self.play_sound_effect)
elif userMsg["X"] == "CANCELED":
worker.signals.progress.connect(
self.mw.open_orders.remove_from_open_orders)
# if order was canceled but partially filled, add to history
if float(order["executedQty"]) > 0:
worker.signals.progress.connect(
self.mw.history_table.add_to_history)
elif userMsg["X"] == "PARTIALLY_FILLED":
worker.signals.progress.connect(
self.mw.open_orders.update_open_order)
worker.signals.progress.connect(
self.mw.holdings_table.check_add_to_holdings)
elif userMsg["X"] == "FILLED":
worker.signals.progress.connect(
self.mw.open_orders.remove_from_open_orders)
worker.signals.progress.connect(
self.mw.history_table.add_to_history)
worker.signals.progress.connect(
self.mw.holdings_table.check_add_to_holdings)
else:
print(msg)
self.threadpool.start(worker)
else:
print(msg)