def __init__(self):
Strategy.__init__(self)
# our order book
self._book = OfTrader()
# our order queue
self._orderQueue = Queue(self._book, side = self.side)
# we are going to track best price changes
self._source = self._orderQueue.BestPrice
event.subscribe(self._source, _(self)._wakeUp, self)
# deque containing issued orders
self._orders = None
# how many orders can be issued
self._size = self.initialSize
self._suspended = False
def Queue(self, side = None):
from marketsim.gen._out.orderbook._queue import Queue
return Queue(self,side)
class OneSide_Impl(Strategy, OneSide_Base):
""" Ladder strategy for one side
"""
def __init__(self):
Strategy.__init__(self)
# our order book
self._book = OfTrader()
# our order queue
self._orderQueue = Queue(self._book, side = self.side)
# we are going to track best price changes
self._source = self._orderQueue.BestPrice
event.subscribe(self._source, _(self)._wakeUp, self)
# deque containing issued orders
self._orders = None
# how many orders can be issued
self._size = self.initialSize
self._suspended = False
@property
def suspended(self):
return self._suspended
@suspended.setter
def suspended(self, value):
if value and self._orders:
# if we are asked to suspend, cancel all our orders
for o in self._orders:
self._send(request.Cancel(o))
self._orders = None
self._suspended = value
def extend(self):
""" Adds an order with price one tick better
"""
if self._orders and not self.suspended:
self._orders.appendleft(self._makeOrder(self._first.ticks - 1))
self._send(self._first)
self._size += 1
def _makeOrder(self, t):
""" Creates an order with price equivalent to 't' ticks
"""
p = self._orderQueue.ticksToPrice(t)
order = self.orderFactory(self.side, constant(p))()
order.ticks = t
order.source = self
return order
@property
def _first(self):
""" Best order in our deque
"""
return self._orders[0]
@property
def _last(self):
""" Worst order in our queue
"""
return self._orders[len(self._orders) - 1]
def _wakeUp(self, _):
if self.suspended:
return
# best price in our queue
price = self._source()
if price is not None:
# translate it into ticks
ticks, _ = self._orderQueue.ticks(price)
if self._orders is None: # if we haven't created orders
self._orders = deque()
# let's create orders with ticks [ticks, ticks + self._size)
for i in range(0, self._size):
self._orders.append(self._makeOrder(ticks + i))
self._send(self._last)
else:
orderTicks = self._orders[0].ticks # ticks of the best order
if orderTicks == ticks or self._orderQueue.best.owner == self._first.owner:
pass
else:
# if new price is worse than our best order price
# (it means that our orders traded)
if ticks > orderTicks:
# let's remove matched orders
while self._orders and self._first.ticks < ticks:
order = self._first
if not order.cancelled: # should be always False
self._send(request.Cancel(order))
self._orders.popleft()
# and add new ones to the end of the queue
while len(self._orders) < self._size:
t = self._last.ticks + 1 if self._orders else ticks
self._orders.append(self._makeOrder(t))
self._send(self._last)
# if new price is better than our best order price
elif ticks < orderTicks:
# let's remove bad orders
while self._orders and self._last.ticks > ticks + self._size:
self._send(request.Cancel(self._last))
self._orders.pop()
# calculate how many orders we should insert
num_created = self._size - len(self._orders)
# create better orders
while len(self._orders) < self._size:
t = self._first.ticks - 1 if self._orders else ticks + (self._size - 1)
self._orders.appendleft(self._makeOrder(t))
# and send them to the market
for i in range(num_created):
self._send(self._orders[i])
