def trade_ledger(self):
instrument_queues = {}
order_pairs = {}
for o in self.orders:
if o.instrument not in instrument_queues:
instrument_queues[o.instrument] = (FifoQueue(), FifoQueue()
) # (longs, shorts)
longs, shorts = instrument_queues[o.instrument]
if o.quantity < 0:
shorts.put(o)
else:
longs.put(o)
# match up the longs and shorts
for inst in instrument_queues.keys():
longs, shorts = instrument_queues[inst]
open_close_order_pairs = []
while not longs.empty() and not shorts.empty():
long, short = longs.get(), shorts.get()
open_order, close_order = (long, short) if long.execution_end_time() < short.execution_end_time() \
else (short, long)
open_close_order_pairs.append((open_order, close_order))
# handle unmatched longs or shorts i.e. positions currently open
while not longs.empty() or not shorts.empty():
unclosed_open_order = longs.get(
) if not longs.empty() else shorts.get()
open_close_order_pairs.append((unclosed_open_order, None))
order_pairs[inst] = open_close_order_pairs
trade_df = []
for inst in order_pairs.keys():
for open_order, close_order in [(o, c)
for o, c in order_pairs[inst]]:
if close_order:
end_dt = close_order.execution_end_time()
end_value = close_order.executed_price
status = 'closed'
else:
end_dt = None
end_value = None
status = 'open'
start_dt, open_value = open_order.execution_end_time(
), open_order.executed_price
long_or_short = np.sign(open_order.quantity)
trade_df.append(
(inst, start_dt, end_dt, open_value, end_value,
long_or_short, status, (end_value - open_value) *
long_or_short if status == 'closed' else None))
return pd.DataFrame(trade_df,
columns=[
'Instrument', 'Open', 'Close', 'Open Value',
'Close Value', 'Long Short', 'Status',
'Trade PnL'
])
def test_peek_one_item_one_queue(self):
value = 5
queue = FifoQueue()
queue.enqueue(value)
peeked_value = queue.peek()
self.assertEqual(1, queue.size)
self.assertEqual(5, peeked_value)
def test_dequeue_one_item_on_queue(self):
value = 5
queue = FifoQueue()
queue.enqueue(value)
removed_item = queue.dequeue()
self.assertEqual(0, queue.size)
self.assertEqual(5, removed_item)
def test_enqueue_two_items(self):
value1, value2 = 5, 10
queue = FifoQueue()
queue.enqueue(value1)
queue.enqueue(value2)
self.assertEqual(2, queue.size)
self.assertEqual(5, queue.ll.head.value)
self.assertEqual(10, queue.ll.tail.value)
def test_peek_multiple_items_on_queue(self):
value1, value2, value3 = 5, 10, 15
queue = FifoQueue()
queue.enqueue(value1)
queue.enqueue(value2)
queue.enqueue(value3)
peeked_item = queue.peek()
self.assertEqual(3, queue.size)
self.assertEqual(5, peeked_item)
def test_enqueue_three_items(self):
value1, value2, value3 = 5, 10, 15
queue = FifoQueue()
queue.enqueue(value1)
queue.enqueue(value2)
queue.enqueue(value3)
self.assertEqual(3, queue.size)
self.assertEqual(5, queue.ll.head.value)
self.assertEqual(15, queue.ll.tail.value)
def __init__(self,
port=None,
queue_in_size=DEFAULT_IN_SIZE,
queue_out_size=DEFAULT_OUT_SIZE):
"""
Initialize.
port specifies the IP port to listen on.
queue_in_size and queue_out_size limit the maximum number of
queued elements. A size of zero specifies that there is no
limit. When the queues fill up a warning is generated and the
oldest element is dropped.
"""
asyncore.dispatcher.__init__(self)
self.connection_map = {} # connection => connection
self.clients = [] # connections that want messages
self.server_map = ServerMap()
self.trigger = None
self.trigger_magic = None # must be matched to accept trigger
# of (client, message, handler)
self.q_in = FifoQueue(queue_in_size)
# of (target, packet)
# where target is a client to send to, or None to send to all
self.q_out = FifoQueue(queue_out_size)
# PST: could possibly use UNIX sockets when not windows
self._init_server(("", port))
self._init_trigger(("127.0.0.1", port))
self.thread = None
# setup basic handlers
def message_rejected(client, message):
print "MessageRejected(Dummy Handler) {%s}" % message
def mapped_name(client, message):
print "MappedName: %s -> %d" % (message.name, message.id)
client.map.add_resolution(message.name, message.id)
self.server_map.set_handler(MessageRejected, message_rejected)
self.server_map.set_handler(MappedName, mapped_name)
def test_dequeue_multiple_items_on_queue(self):
value1, value2, value3 = 5, 10, 15
queue = FifoQueue()
queue.enqueue(value1)
queue.enqueue(value2)
queue.enqueue(value3)
removed_item1 = queue.dequeue()
removed_item2 = queue.dequeue()
removed_item3 = queue.dequeue()
self.assertEqual(0, queue.size)
self.assertEqual(5, removed_item1)
self.assertEqual(10, removed_item2)
self.assertEqual(15, removed_item3)
def breadth_first_search(self):
visited_nodes = []
# Use a queue to keep track of all the nodes you need to visit
node_queue = FifoQueue()
# Set starting point as no root node
current_node = self.edges[0].node_from
visited_nodes.append(current_node)
while current_node:
new_edge = self._return_new_edge(current_node, visited_nodes)
if new_edge:
visited_nodes.append(new_edge.node_to)
node_queue.enqueue(new_edge.node_to)
else:
current_node = node_queue.dequeue()
visited_node_values = [node.value for node in visited_nodes]
return visited_node_values
def __init__(self):
self.fifo_queue = FifoQueue()
self.priority_queue = PriorityQueue()
def test_peek_no_items_on_queue(self):
queue = FifoQueue()
peeked_value = queue.peek()
self.assertEqual(0, queue.size)
self.assertEqual(None, peeked_value)
def test_dequeue_no_items_on_queue(self):
queue = FifoQueue()
removed_item = queue.dequeue()
self.assertEqual(0, queue.size)
self.assertEqual(None, removed_item)
def test_enqueue_one_item(self):
value = 5
queue = FifoQueue()
queue.enqueue(value)
self.assertEqual(1, queue.size)
self.assertEqual(5, queue.ll.head.value)
def test_queue_create(self):
queue = FifoQueue()
self.assertEqual(0, queue.size)
