Priorityq resubmit

.coveragerc

@@ -0,0 +1,32 @@
+[run]
+source = 
+    src/priorityq.py 
+omit = 
+    src/weighted_graph.py
+    src/weighted_traversal.py
+    src/deque.py
+    src/que_.py
+    src/stack.py
+    src/binheap.py
+    src/dijkstra.py
+    src/graph_1.py
+    src/graph_2.py
+    src/dll.py
+    src/linked_list.py
+    src/reverse_linked_list.py
+    src/test_dll.py
+    src/test_binheap.py
+    src/test_deque.py
+    src/test_dijkstra.py
+    src/test_graph.py
+    src/test_graph_2.py
+    src/test_linked_list.py
+    src/test_priority_que.py
+    src/test_que_.py
+    src/test_reverse_linked_list.py
+    src/test_stack.py
+    src/test_weighted_graph.py
+    src/test_weighted_traversal.py
+
+[report]
+show_missing = True

README.md

@@ -29,6 +29,11 @@ Data Structures for Python 401
 #Used the shift and pop methods from our double linked list in dll.py.
 
 
+##Deque Branch
+#Implement a dequeue data structure that has pop, popleft, append, appendleft,
+#peek, peekleft, and size methods. Implemented using a composition of double linked
+#list.
+
 ##Binary Heap Branch
 #Implement a pop() and push() function for this exercise.
 #Worked on initialization and implementation of our the data structure itself.

setup.py

@@ -3,7 +3,7 @@
 
 
 extra_packages = {
-    'testing': ['pytest', 'pytest-watch', 'pytest-cov', 'tox']
+    'testing': ['pytest-cov', 'tox']
 }
 
 
@@ -14,12 +14,6 @@
     author="Kurt Maurer" "Anna Shelby",
     author_email="bonanashelby@gmail.com",
     license="MIT",
-    py_modules=["server, client"],
-    package_dir={'': 'src'},
     install_requires=["ipython", "pytest"],
-    extras_require=extra_packages,
-    entry_points={
-        'console_scripts': [
-        ]
-    }
+    extras_require=extra_packages
 )

src/deque.py

@@ -25,14 +25,14 @@ def popleft(self):
         """Shift for popleft."""
         return self._new_dll.shift()
 
-    def peek(self):  # pragma no cover
+    def peek(self):
         """Return a new value without dequeuing it."""
-        print(self._new_dll.head.data)
+        return self._new_dll.head.data
 
-    def peekleft(self):  # pragma no cover
+    def peekleft(self):
         """Return a new value from the left without dequeing it."""
-        print(self._new_dll.tail.data)
+        return self._new_dll.tail.data
 
-    def __len__(self):
+    def size(self):
         """Length function for the queue."""
-        return len(self._new_dll)
+        return self._new_dll.size()

src/dll.py

@@ -24,29 +24,27 @@ def push(self, val):
         """Push a value to the head of the list."""
         if not val:
             raise TypeError('Please provide a not null value.')
-        self._length += 1
         if self.tail is None and self.head is None:
             new_node = Node(val)
-            self.tail = new_node
-            self.head = new_node
+            self.tail = self.head = new_node
         else:
             new_node = Node(val, None, self.head)
             self.head.next_node = new_node
             self.head = new_node
+        self._length += 1
 
     def append(self, val):
         """Append a val to the tail of a list."""
         if not val:
             raise TypeError('Please provide a not null value.')
-        self._length += 1
         if self.tail is None and self.head is None:
             new_node = Node(val)
-            self.tail = new_node
-            self.head = new_node
+            self.tail = self.head = new_node
         else:
             new_node = Node(val, self.tail, None)
             self.tail.prior_node = new_node
             self.tail = new_node
+        self._length += 1
 
     def pop(self):
         """Pop pops from the head of the list."""
@@ -56,55 +54,48 @@ def pop(self):
         self._length -= 1
         if self.head == self.tail:
             last_pop = self.head
-            self.head = None
-            self.tail = None
+            self.tail = self.head = None
             return last_pop.data
         popped = self.head
         self.head = self.head.prior_node
-        popped.prior_node = None
         self.head.next_node = None
         return popped.data
 
     def shift(self):
         """Remove the node from the tail of the list."""
-        if not self.head:
+        if not self.tail:
             raise IndexError(
                 'There\'s nothing to remove from the linked list.')
         self._length -= 1
         if self.head == self.tail:
             last_pop = self.head
-            self.head = None
-            self.tail = None
+            self.tail = self.head = None
             return last_pop.data
         shifted = self.tail
         self.tail = self.tail.next_node
-        shifted.next_node = None
         self.tail.prior_node = None
         return shifted.data
 
-    def __len__(self):
+    def size(self):
         """Return the length of the double linked list."""
         return self._length
 
     def remove(self, val):
         """Remove a node with the value provided."""
-        if val is None:
-            raise TypeError(
-                'That value is not in this particular linked list.')
         if self.head.data == val:
             self.pop()
+            return
         elif self.tail.data == val:
             self.shift()
+            return
         current_node = self.head
         while current_node is not None:
             if current_node.data != val:
                 current_node = current_node.prior_node
             else:
                 new_next_node = current_node.next_node
                 new_prior_node = current_node.prior_node
-                current_node.next_node.prior_node = new_prior_node
-                current_node.prior_node.next_node = new_next_node
-                current_node.next_node = None
-                current_node.prior_node = None
+                new_next_node.prior_node = new_prior_node
+                new_prior_node.next_node = new_next_node
                 self._length -= 1
                 break

src/linked_list.py

@@ -43,10 +43,14 @@ def pop(self):
         self._length -= 1
         return popped.data
 
-    def __len__(self):
+    def size(self):
         """Return the length of the linked list."""
         return self._length
 
+    def __len__(self):
+        """Interact with built-in len() function."""
+        return self.size()
+
     def search(self, val):
         """Search the nodes for the value provided."""
         current_node = self.head
@@ -56,7 +60,7 @@ def search(self, val):
             else:
                 return current_node.data
         else:
-            return None
+            return
 
     def remove(self, val):
         """Removenode from anywhere in the linked list with the given value."""
@@ -65,26 +69,34 @@ def remove(self, val):
                 'That value is not in this particular linked list.')
         if self.head.data == val:
             self.pop()
-            return None
+            return
         current_node = self.head
+        previous_node = self.head
         while current_node is not None:
-            if current_node.next_node.data != val:
+            if current_node.data != val:
+                previous_node = current_node
                 current_node = current_node.next_node
+                continue
             else:
-                removed_node = current_node.next_node
-                current_node.next_node = current_node.next_node.next_node
+                previous_node.next_node = current_node.next_node
                 self._length -= 1
-                if removed_node.next_node is not None:
-                    removed_node.next_node = None
                 break
+        else:
+            raise ValueError('Value not found.')
 
     def display(self):
         """Present a visual representation of the linked list."""
         node = self.head
         display_str = ' '
         while node is not None:
                 display_str += ' '
+                display_str += '\''
                 display_str += str(node.data)
+                display_str += '\''
                 node = node.next_node
         display_str = ', '.join(display_str.split())
         return '{}{}{}'.format('(', display_str, ')')
+
+    def __str__(self):
+        """Interact with built-in print function."""
+        return self.display()

src/priorityq.py

@@ -1,71 +1,68 @@
 """Implement a priority queue using binary heap."""
 
-#  [{1: 0}, {100: 1}, {33: 2}, {44: 3}, {2: 0}]
-
 
 class PriorityQueue(object):
     """Implement a priority queue."""
 
     def __init__(self):
         """Initialize our priority queue."""
         self._heap = []
+        self._length = 0
 
     def heapify(self, iterable):
         """Function to heapify our dictionary in self._heap."""
         heap_list = iterable
+
+        def bubble_up(parent, current_node):
+            """Helper function to reduce clutter."""
+            current_node = parent
+            parent = (current_node - 1) // 2
+            return (parent, current_node)
+
         for item in heap_list[::-1]:
-            item_index = heap_list.index(item)
-            parent = (item_index - 1) // 2
-            while item_index > 0:
-                if list(heap_list[parent].values())[0] is 0 and list(heap_list[item_index].values())[0] is 0:
-                    if list(heap_list[item_index].keys())[0] < list(heap_list[parent].keys())[0]:
+            current_node = heap_list.index(item)
+            parent = (current_node - 1) // 2
+            while current_node > 0:
+                parent_priority = list(heap_list[parent].values())[0]
+                current_node_priority = list(
+                    heap_list[current_node].values())[0]
+                if current_node_priority > 0:
+                    if parent_priority is 0 or parent_priority > current_node_priority:
                         curr_val = heap_list[parent]
-                        heap_list[parent] = heap_list[item_index]
-                        heap_list[item_index] = curr_val
-                        item_index = parent
-                        parent = (item_index - 1) // 2
+                        heap_list[parent] = heap_list[current_node]
+                        heap_list[current_node] = curr_val
+                        parent, current_node = bubble_up(parent, current_node)
                     else:
-                        item_index = parent
-                        parent = (item_index - 1) // 2
-                elif list(heap_list[parent].values())[0] > 0 and list(heap_list[item_index].values())[0] is 0:
-                    item_index = parent
-                    parent = (item_index - 1) // 2
-                elif list(heap_list[parent].values())[0] is 0 and list(heap_list[item_index].values())[0] > 0:
-                    curr_val = heap_list[parent]
-                    heap_list[parent] = heap_list[item_index]
-                    heap_list[item_index] = curr_val
-                    item_index = parent
-                    parent = (item_index - 1) // 2
-                elif list(heap_list[parent].values())[0] > 0 and list(heap_list[item_index].values())[0] > 0:
-                    if list(heap_list[item_index].values())[0] < list(heap_list[parent].values())[0]:
-                        curr_val = heap_list[parent]
-                        heap_list[parent] = heap_list[item_index]
-                        heap_list[item_index] = curr_val
-                        item_index = parent
-                        parent = (item_index - 1) // 2
-                    else:
-                        item_index = parent
-                        parent = (item_index - 1) // 2
+                        parent, current_node = bubble_up(parent, current_node)
                 else:
-                    break
+                    parent, current_node = bubble_up(parent, current_node)
+
         return heap_list
 
     def insert(self, value, priority=0):
         """Insert a value into the priority queue with an optional priority."""
-        if not isinstance(value, int) or not isinstance(priority, int):
-            raise TypeError("Must provide an integer for value and priority.")
+        if not isinstance(priority, int):
+            raise TypeError("Must provide an integer for priority.")
         if priority < 0:
-            raise ValueError("You may not use a negative priority. Priority must be 0 or greater.")
+            raise ValueError(
+                "You may not use a negative priority."
+                "Priority must be 0 or greater.")
         self._heap.append({value: priority})
         if len(self._heap) > 1:
             self._heap = self.heapify(self._heap)
+        self._length += 1
 
     def pop(self):
         """Pop function for removing highest priority item from queue."""
         pop_it = self._heap.pop(0)
         self.heapify(self._heap)
+        self._length -= 1
         return list(pop_it.keys())[0]
 
     def peek(self):
         """Return the highest priority item without removing from queue."""
         return list(self._heap[0].keys())[0]
+
+    def size(self):
+        """Return the size of our priority queue."""
+        return self._length

src/que_.py

@@ -23,6 +23,6 @@ def peek(self):
         """Return a new value without dequeuing it."""
         print(self._new_dll.tail.data)
 
-    def __len__(self):
+    def size(self):
         """Length function for the queue."""
-        return len(self._new_dll)
+        return self._new_dll.size()

src/stack.py

@@ -12,13 +12,16 @@ def __init__(self, data=None):
         self._new_linked_list = LinkedList(data)
 
     def push(self, val):
-        """Push function for stack."""
-        return self._new_linked_list.push(val)
+        """Add a value to the top of the stack."""
+        self._new_linked_list.push(val)
 
     def pop(self):
-        """Pop function for stack."""
+        """Remove and return the top of the stack."""
+        if len(self) == 0:
+            raise IndexError(
+                'Cannot pop from empty stack.')
         return self._new_linked_list.pop()
 
     def __len__(self):
-        """Length function for stack."""
-        return len(self._new_linked_list)
+        """Return the number of items in the stack."""
+        return self._new_linked_list.size()