def commitOrderExecution(self, order, price, quantity, dateTime):
if order.getAction() in [broker.Order.Action.BUY, broker.Order.Action.BUY_TO_COVER]:
cost = price * quantity * -1
assert(cost < 0)
sharesDelta = quantity
elif order.getAction() in [broker.Order.Action.SELL, broker.Order.Action.SELL_SHORT]:
cost = price * quantity
assert(cost > 0)
sharesDelta = quantity * -1
else: # Unknown action
assert(False)
ret = False
commission = self.getCommission().calculate(order, price, quantity)
cost -= commission
resultingCash = self.getCash() + cost
# Check that we're ok on cash after the commission.
if resultingCash >= 0 or self.__allowNegativeCash:
# Commit the order execution.
self.setCash(resultingCash)
self.__shares[order.getInstrument()] = self.getShares(order.getInstrument()) + sharesDelta
ret = True
# Update the order.
orderExecutionInfo = broker.OrderExecutionInfo(price, quantity, commission, dateTime)
order.setExecuted(orderExecutionInfo)
else:
logger.debug("Not enough money to fill order %s" % (order))
return ret
def stop(self):
try:
if self.__wsClient is not None:
logger.debug("Stopping websocket client")
self.__wsClient.stopClient()
except Exception as e:
logger.error("Error stopping websocket client: %s" % e)
def run(self):
logger.debug("Thread started.")
while not self.__stopped:
self.__wait()
if not self.__stopped:
try:
self.doCall()
except Exception, e:
logger.critical("Unhandled exception", exc_info=e)
def run(self, *args, **kwargs):
assert self.__current_state is not None
new_state = self.__states[self.__current_state](*args, **kwargs)
self.__last_state = self.__current_state
if new_state != self.__current_state:
logger.debug('Switch state [%s] -> [%s]' % (self.__current_state,
new_state))
assert new_state in self.__states
self.__current_state = new_state
def run(self):
logger.debug("Thread started.")
while not self.__stopped:
self.__wait()
if not self.__stopped:
try:
self.doCall()
except Exception, e:
logger.critical("Unhandled exception", exc_info=e)
def onDayEnd(self):
# Cancel non-GTC orders on day end
activeOrders = copy.copy(self.__activeOrders)
for order in activeOrders:
if order.isAccepted() and not order.getGoodTillCanceled(): #and not order.getType() == Order.Type.MARKET:
logger.debug("Cancelling non-GTC order: %s" % order)
order.setState(broker.Order.State.CANCELED)
self.__activeOrders.remove(order)
self.getOrderUpdatedEvent().emit(self, order)
def run(self):
# We create the WebSocketClient right in the thread, instead of doing so in the constructor,
# because it has thread affinity.
try:
self.__wsClient = self.__wsCls(self.__queue, *self.__args,
**self.__kwargs)
logger.debug("Running websocket client")
self.__wsClient.startClient()
except Exception as e:
logger.exception("Unhandled exception %s" % e)
self.__wsClient.stopClient()
def run(self):
logger.debug("Thread started.")
ret = True
while not self.__stopped:
if ret:
self.__wait()
if not self.__stopped:
ret = False
try:
ret = self.doCall()
except Exception, e:
logger.critical("Unhandled exception", exc_info=e)
def doCall(self):
endDateTime = self.__nextBarClose
self.__updateNextBarClose()
barDict = {}
for indentifier in self.__identifiers:
try:
logger.debug("Requesting bars with precision %s and period %s for %s" % (self.__precision, self.__period, indentifier))
response = api.XigniteGlobalRealTime_GetBar(self.__apiToken, indentifier, "Symbol", endDateTime, self.__precision, self.__period)
# logger.debug(response)
barDict[indentifier] = build_bar(response["Bar"], indentifier, self.__frequency)
except api.XigniteError, e:
logger.error(e)
class PollingThread(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.__stopped = False
def __wait(self):
# Wait until getNextCallDateTime checking for cancelation every 0.5 second.
nextCall = self.getNextCallDateTime()
# nextCall = self.getNextCallDateTime() - datetime.timedelta(seconds=3600)
print("----nextTime:%s" % liveUtils.utcToLocal(nextCall))
while not self.__stopped and liveUtils.utcnow() < nextCall:
time.sleep(0.5)
def stop(self):
self.__stopped = True
def stopped(self):
return self.__stopped
def run(self):
logger.debug("Thread started.")
ret = True
while not self.__stopped:
if ret:
self.__wait()
if not self.__stopped:
ret = False
try:
ret = self.doCall()
except Exception, e:
logger.critical("Unhandled exception", exc_info=e)
logger.debug("Thread finished.")
class PollingThread(threading.Thread):
def __init__(self):
threading.Thread.__init__(self)
self.__stopped = False
def __wait(self):
# Wait until getNextCallDateTime checking for cancelation every 0.5 second.
nextCall = self.getNextCallDateTime()
while not self.__stopped and utcnow() < nextCall:
time.sleep(0.5)
def stop(self):
self.__stopped = True
def stopped(self):
return self.__stopped
def run(self):
logger.debug("Thread started.")
while not self.__stopped:
self.__wait()
if not self.__stopped:
try:
self.doCall()
except Exception, e:
logger.critical("Unhandled exception", exc_info=e)
logger.debug("Thread finished.")
def doCall(self):
endDateTime = self.__nextBarClose
self.__updateNextBarClose()
barDict = {}
for indentifier in self.__identifiers:
try:
logger.debug("Requesting bars with precision %s and period %s for %s" % (self.__precision, self.__period, indentifier))
response = api.XigniteGlobalRealTime_GetBar(self.__apiToken, indentifier, "Symbol", endDateTime, self.__precision, self.__period)
# logger.debug(response)
barDict[indentifier] = build_bar(response["Bar"], indentifier, self.__frequency)
except api.XigniteError as e:
logger.error(e)
if len(barDict):
bars = bar.Bars(barDict)
self.__queue.put((GetBarThread.ON_BARS, bars))
def commitOrderExecution(self, order, dateTime, fillInfo):
price = fillInfo.getPrice()
quantity = fillInfo.getQuantity()
if order.isBuy():
cost = price * quantity * -1
assert(cost < 0)
sharesDelta = quantity
elif order.isSell():
cost = price * quantity
assert(cost > 0)
sharesDelta = quantity * -1
else: # Unknown action
assert(False)
commission = self.getCommission().calculate(order, price, quantity)
cost -= commission
resultingCash = self.getCash() + cost
# Check that we're ok on cash after the commission.
if resultingCash >= 0 or self.__allowNegativeCash:
# Update the order before updating internal state since addExecutionInfo may raise.
# addExecutionInfo should switch the order state.
orderExecutionInfo = broker.OrderExecutionInfo(price, quantity, commission, dateTime)
order.addExecutionInfo(orderExecutionInfo)
# Commit the order execution.
self.__cash = resultingCash
self.__shares[order.getInstrument()] = self.getShares(order.getInstrument()) + sharesDelta
# Let the strategy know that the order was filled.
self.__fillStrategy.onOrderFilled(order)
# Notify the order update
if order.isFilled():
del self.__activeOrders[order.getId()]
self.notifyOrderEvent(broker.OrderEvent(order, broker.OrderEvent.Type.FILLED, orderExecutionInfo))
elif order.isPartiallyFilled():
self.notifyOrderEvent(broker.OrderEvent(order, broker.OrderEvent.Type.PARTIALLY_FILLED, orderExecutionInfo))
else:
assert(False)
else:
logger.debug("Not enough money to fill order %s" % (order))
def commitOrderExecution(self, order, price, quantity, dateTime):
if order.getAction() in [
broker.Order.Action.BUY, broker.Order.Action.BUY_TO_COVER
]:
cost = price * quantity * -1
assert (cost < 0)
sharesDelta = quantity
elif order.getAction() in [
broker.Order.Action.SELL, broker.Order.Action.SELL_SHORT
]:
cost = price * quantity
assert (cost > 0)
sharesDelta = quantity * -1
else: # Unknown action
assert (False)
ret = False
commission = self.getCommission().calculate(order, price, quantity)
cost -= commission
resultingCash = self.getCash() + cost
# Check that we're ok on cash after the commission.
if resultingCash >= 0:
# Commit the order execution.
self.setCash(resultingCash)
self.__shares[order.getInstrument()] = self.getShares(
order.getInstrument()) + sharesDelta
ret = True
# Update the order.
orderExecutionInfo = broker.OrderExecutionInfo(
price, quantity, commission, dateTime)
order.setExecuted(orderExecutionInfo)
else:
logger.debug("Not enough money to fill order %s" % (order))
return ret
def commitOrderExecution(self, order, price, quantity, dateTime):
if order.getAction() in [broker.Order.Action.BUY, broker.Order.Action.BUY_TO_COVER]:
cost = price * quantity * -1
assert(cost < 0)
sharesDelta = quantity
elif order.getAction() in [broker.Order.Action.SELL, broker.Order.Action.SELL_SHORT]:
cost = price * quantity
assert(cost > 0)
sharesDelta = quantity * -1
else: # Unknown action
assert(False)
ret = False
instrument = order.getInstrument()
commission = self.getCommission().calculate(order, price, quantity)
cost -= commission
resultingCash = self.getCash() + cost
# Check that we're ok on cash after the commission.
if resultingCash >= 0 or self.__allowNegativeCash:
# Commit the order execution.
self.setCash(resultingCash)
self.__shares[instrument] = self.getShares(instrument) + sharesDelta
if self.__shares[instrument] == 0:
self.__totalCost[instrument] = 0
else:
self.__totalCost[instrument] = self.getTotalCost(instrument) + cost
ret = True
# Update the order.
orderExecutionInfo = broker.OrderExecutionInfo(price, quantity, commission, dateTime)
order.setExecuted(orderExecutionInfo)
logger.debug("%s Order filled: %s" % (instrument, orderExecutionInfo))
logger.debug("%s shares owned. Total cost: %s" % (self.__shares[instrument], self.__totalCost[instrument]))
else:
logger.debug("Not enough cash to fill the order for %s @ %.2f. Avail: %.2f, Req: %.2f" %
(instrument, price, self.getCash(), cost * -1))
return ret
def __threadMain(self):
logger.debug("Thread started.")
self.__wsClient.startClient()
logger.debug("Thread finished.")
def handleResponse(self, msg):
ret = msg.get("table") == "pong"
if ret:
logger.debug("Received pong.")
return ret
def stop(self):
self.__stopped = True
def stopped(self):
return self.__stopped
def run(self):
logger.debug("Thread started.")
while not self.__stopped:
self.__wait()
if not self.__stopped:
try:
self.doCall()
except Exception, e:
logger.critical("Unhandled exception", exc_info=e)
logger.debug("Thread finished.")
# Must return a non-naive datetime.
def getNextCallDateTime(self):
raise NotImplementedError()
def doCall(self):
raise NotImplementedError()
class TushareBarFeedThread(TuSharePollingThread):
# Events
ON_BARS = 1
def __init__(self, queue, identifiers, frequency):
super(TushareBarFeedThread, self).__init__(identifiers)
def __register_state(self, name, function):
logger.debug('Registering state [%s]' % name)
if name in self.__states:
raise Exception("Duplicate state %s" % name)
self.__states[name] = function
def __set_initial_state(self, name):
assert name in self.__states
logger.debug('Initial state [%s]' % name)
self.__current_state = name
def handleResponse(self, msg):
ret = msg.get("event") == "pusher:pong"
if ret:
logger.debug("Received pusher:pong.")
return ret
def sendKeepAlive(self):
logger.debug("Sending pusher:ping.")
self.getWSClient().sendPing()
def handleResponse(self, msg):
ret = msg.get("event") == "pusher:pong"
if ret:
logger.debug("Received pusher:pong.")
return ret
def __on_error(self, ws, error):
logger.debug("Error : %s" % error)
def stop(self):
self.__stopped = True
def stopped(self):
return self.__stopped
def run(self):
logger.debug("Thread started.")
while not self.__stopped:
self.__wait()
if not self.__stopped:
try:
self.doCall()
except Exception, e:
logger.critical("Unhandled exception", exc_info=e)
logger.debug("Thread finished.")
# Must return a non-naive datetime.
def getNextCallDateTime(self):
raise NotImplementedError()
def doCall(self):
raise NotImplementedError()
class TushareBarFeedThread(TuSharePollingThread):
# Events
ON_BARS = 1
def __init__(self, queue, identifiers, frequency):
super(TushareBarFeedThread, self).__init__(identifiers)
def __threadMain(self):
logger.debug("Thread started.")
self.__wsClient.startClient()
logger.debug("Thread finished.")
def sendKeepAlive(self):
logger.debug("Sending pusher:ping.")
self.getWSClient().sendPing()
