Feature/priorityq jonathan

priorityq.py

@@ -0,0 +1,106 @@
+from __future__ import unicode_literals
+from functools import total_ordering
+
+from binary_heap import BinaryHeap
+
+
+@total_ordering  # Will build out the remaining comparison methods
+class QNode(object):
+    """A class for a queue node."""
+    def __init__(self, val, priority=None, order=None):
+        """Initialize a QNode with a value and an optional priority.
+
+        args:
+            val: the value to store
+            priority: an integer with 0 being most important
+            order: integer to store queue insertion order
+        """
+        self.val = val
+        self.priority = priority
+        self.order = order
+
+    def __repr__(self):
+        """Print representation of node."""
+        return "{val}".format(val=self.val)
+
+    def __str__(self):
+        """Pretty print node value and priority."""
+        return "Value:{val}, Order:{o} Priority:{p}".format(
+            val=self.val, o=self.order, p=self.priority
+        )
+
+    def __eq__(self, other):
+        """Overloads equality comparison to check priority, then order."""
+        if self.priority == other.priority:
+            return self.order == other.order
+        else:
+            return self.priority == other.priority
+
+    def __lt__(self, other):
+        """Overloads lesser than comparison to check priority, then order."""
+        if self.priority == other.priority:
+            return self.order < other.order
+        elif self.priority is None:
+            return False
+        elif other.priority is None:
+            return True
+        else:
+            return self.priority < other.priority
+
+
+class PriorityQ(object):
+    """A class for a priority queue."""
+    def __init__(self, iterable=()):
+        """Initialize a priority queue, optionally with items from iterable.
+
+        The items in the priority queue are stored in a binary minheap. Items
+        are first sorted by priority, then queue insertion order. Priority is
+        expressed as an integer with 0 being the most important.
+
+        args:
+            iterable: an optional iterable to add to the priority queue. Items
+                      added this way will be given a priority of None.
+        """
+        self.heap = BinaryHeap(iterable=())
+        for item in iterable:
+            self.insert(item)
+
+    def __repr__(self):
+        return repr(self.heap)
+
+    def __len__(self):
+        return len(self.heap)
+
+    def __iter__(self):
+        return iter(self.heap)
+
+    def __getitem__(self, index):
+        return self.heap[index]
+
+    def __setitem__(self, index, value):
+        self.heap[index] = value
+
+    def insert(self, item, priority=None):
+        """Insert an item into the priority queue.
+
+        If the item is a QNode object, it will be added tracking queue order.
+        If not, a new QNode object is created to hold the item with queue order
+        and optional priority assigned.
+
+        args:
+            item: the item to add (QNode or other value)
+            priority: the optional integer priority (0 is most important)
+        """
+        if isinstance(item, QNode):
+            item.order = len(self)
+            self.heap.push(item)
+        else:
+            self.heap.push(QNode(item, priority=priority, order=len(self)))
+
+    def pop(self):
+        """Remove and return the most important item from the queue."""
+        return self.heap.pop().val
+
+    def peek(self):
+        """Return the most important item from queue without removal."""
+        return self.heap[0].val

test_priorityq.py

@@ -0,0 +1,124 @@
+from __future__ import unicode_literals
+import pytest
+
+from priorityq import PriorityQ, QNode
+
+
+@pytest.fixture()
+def QNode_list():
+    QNode_list = [
+        QNode(10),
+        QNode(5, priority=2),
+        QNode(100, priority=1)
+    ]
+    return QNode_list
+
+
+@pytest.fixture()
+def base_pqueue(QNode_list):
+    return PriorityQ(QNode_list)
+
+
+def test_QNode_init_no_priority():
+    node1 = QNode(10)
+    assert node1.val == 10
+    assert node1.priority is None
+
+
+def test_QNode_init_with_priority():
+    node1 = QNode(10, priority=0)
+    assert node1.val == 10
+    assert node1.priority == 0
+
+
+def test_QNode_order_comparison():
+    node1 = QNode(10, order=1)
+    node2 = QNode(5, order=2)
+    assert node1 < node2
+
+
+def test_QNode_priority_comparison():
+    node1 = QNode(10, priority=0)
+    node2 = QNode(10)
+    assert node1 < node2
+
+
+def test_QNode_equal_priority_comparison():
+    node1 = QNode(10, priority=1, order=1)
+    node2 = QNode(5, priority=1, order=2)
+    assert node1 < node2
+
+
+def test_QNode_equality_comparison():
+    node1 = QNode(10, priority=10)
+    node2 = QNode(10, priority=10)
+    assert node1 == node2
+
+
+def test_PriorityQ_init_empty():
+    pqueue = PriorityQ()
+    assert isinstance(pqueue, PriorityQ)
+    assert len(pqueue) == 0
+
+
+def test_PriorityQ_init_iterable_no_QNodes():
+    pqueue = PriorityQ([10, 9, 8, 7, 6, 5])
+    assert len(pqueue) == 6
+    assert pqueue[0].val == 10
+    assert pqueue[0].priority is None
+
+
+def test_PriorityQ_init_iterable_with_QNodes(QNode_list):
+    pqueue = PriorityQ(QNode_list)
+    assert len(pqueue) == 3
+    assert pqueue[0].val == 100
+    assert pqueue[0].priority == 1
+
+
+def test_insert_item_not_QNode_to_empty():
+    queue = PriorityQ()
+    queue.insert(50)
+    assert len(queue) == 1
+    assert queue[0].val == 50
+    assert queue[0].priority is None
+
+
+def test_insert_item_QNode_to_empty():
+    node1 = QNode(10, priority=0)
+    pqueue = PriorityQ()
+    pqueue.insert(node1)
+    assert len(pqueue) == 1
+    assert pqueue[0].val == 10
+    assert pqueue[0].priority == 0
+
+
+def test_insert_item_not_QNode_to_filled(base_pqueue):
+    base_pqueue.insert(500, priority=0)
+    assert len(base_pqueue) == 4
+    assert base_pqueue[0].val == 500
+    assert base_pqueue[0].order == 3
+    assert base_pqueue[0].priority == 0
+
+
+def test_insert_QNode_to_filled(base_pqueue):
+    node1 = QNode(10, priority=0)
+    base_pqueue.insert(node1)
+    assert len(base_pqueue) == 4
+    assert base_pqueue[0].val == 10
+    assert base_pqueue[0].order == 3
+    assert base_pqueue[0].priority == 0
+
+
+def test_pop(base_pqueue):
+    top_priority = QNode(9000, priority=0)
+    length = len(base_pqueue)
+    base_pqueue.insert(top_priority)
+    assert base_pqueue.pop() == top_priority.val
+    assert len(base_pqueue) == length
+
+
+def test_peek(base_pqueue):
+    top_priority = QNode(9000, priority=0)
+    base_pqueue.insert(top_priority)
+    assert base_pqueue.peek() == top_priority.val
+    assert base_pqueue[0] is top_priority