minor indentation and linting, also update to 1.0.8 for upgrading release.

Author: brean

CHANGELOG.md

@@ -1,3 +1,7 @@
+# 1.0.8
+## Performance
+- huge performance update by reducing lookup time for smallest entry in heapq. (see #53, thanks to @peterchenadded)
+
 # 1.0.7
 ## Bugfixes
 - fixed calculation of graph width (see #52)

pathfinding/core/heap.py

@@ -4,16 +4,18 @@
 from .grid import Grid
 from .world import World
 
+
 class SimpleHeap:
-    """Simple wrapper around open_list that keeps track of order and removed nodes automatically."""
+    """Simple wrapper around open_list that keeps track of order and removed
+    nodes automatically."""
 
     def __init__(self, node, grid):
         self.grid = grid
         self.open_list = [self._get_node_tuple(node, 0)]
         self.removed_node_tuples = set()
         self.heap_order = {}
         self.number_pushed = 0
-    
+
     def _get_node_tuple(self, node, heap_order):
         if isinstance(self.grid, Graph):
             return (node.f, heap_order, node.node_id)
@@ -23,7 +25,7 @@ def _get_node_tuple(self, node, heap_order):
             return (node.f, heap_order, node.x, node.y, node.grid_id)
         else:
             assert False, "unsupported heap node node=%s" % node
-        
+
     def _get_node_id(self, node):
         if isinstance(self.grid, Graph):
             return node.node_id
@@ -32,13 +34,13 @@ def _get_node_id(self, node):
         elif isinstance(self.grid, World):
             return (node.x, node.y, node.grid_id)
 
-
     def pop_node(self):
         """
         Pops node off the heap. i.e. returns the one with the lowest f.
 
         Notes:
-        1. Checks if that values is in removed_node_tuples first, if not tries again.
+        1. Checks if that values is in removed_node_tuples first, if not tries
+           again.
         2. We use this approach to avoid invalidating the heap structure.
         """
         node_tuple = heapq.heappop(self.open_list)
@@ -50,10 +52,11 @@ def pop_node(self):
         elif isinstance(self.grid, Grid):
             node = self.grid.node(node_tuple[2], node_tuple[3])
         elif isinstance(self.grid, World):
-            node = self.grid.grids[node_tuple[4]].node(node_tuple[2], node_tuple[3])
+            node = self.grid.grids[
+                node_tuple[4]].node(node_tuple[2], node_tuple[3])
 
         return node
-    
+
     def push_node(self, node):
         """
         Push node into heap.
@@ -67,12 +70,13 @@ def push_node(self, node):
         self.heap_order[node_id] = self.number_pushed
 
         heapq.heappush(self.open_list, node_tuple)
-    
+
     def remove_node(self, node, f):
         """
         Remove the node from the heap.
 
-        This just stores it in a set and we just ignore the node if it does get popped from the heap.
+        This just stores it in a set and we just ignore the node if it does
+        get popped from the heap.
 
         :param node: The node to remove.
         :param f: The old f value of the node.
@@ -81,7 +85,7 @@ def remove_node(self, node, f):
         heap_order = self.heap_order[node_id]
         node_tuple = self._get_node_tuple(node, heap_order)
         self.removed_node_tuples.add(node_tuple)
-    
+
     def __len__(self):
         """Returns the length of the open_list."""
-        return len(self.open_list)
+        return len(self.open_list)

setup.py

@@ -11,7 +11,7 @@
     long_description=long_description,
     long_description_content_type="text/markdown",
     url="https://github.com/brean/python-pathfinding",
-    version="1.0.7",
+    version="1.0.8",
     license="MIT",
     author="Andreas Bresser",
     packages=find_packages(),

test/test_heap.py

@@ -1,6 +1,7 @@
 from pathfinding.core.heap import SimpleHeap
 from pathfinding.core.grid import Grid
 
+
 def test_heap():
     grid = Grid(width=10, height=10)
     start = grid.node(0, 0)

test/test_performance.py

@@ -9,6 +9,7 @@ def _add_block(g: numpy.ndarray, x: int, y: int, padding: int):
         for j in range(y - padding, y + padding):
             g[j][i] = 0
 
+
 def test_a_star():
     """Test performance."""
     # Get a 500 x 500 grid
@@ -22,8 +23,8 @@ def test_a_star():
     end = finder_grid.node(400, 400)
 
     finder = AStarFinder(diagonal_movement=DiagonalMovement.never)
-    path, runs = finder.find_path(start, end, finder_grid)
+    path, _ = finder.find_path(start, end, finder_grid)
 
     assert path[0] == start
     assert path[-1] == end
-    assert len(path) == 801
+    assert len(path) == 801