Fix mypy errors at bidirectional_bfs

Author: mhihasan

graphs/bidirectional_breadth_first_search.py

@@ -5,6 +5,9 @@
 from __future__ import annotations
 
 import time
+from typing import Optional
+
+Path = list[tuple[int, int]]
 
 grid = [
     [0, 0, 0, 0, 0, 0, 0],
@@ -16,11 +19,13 @@
     [0, 0, 0, 0, 1, 0, 0],
 ]
 
-delta = [[-1, 0], [0, -1], [1, 0], [0, 1]]  # up, left, down, right
+direction = [[-1, 0], [0, -1], [1, 0], [0, 1]]  # up, left, down, right
 
 
 class Node:
-    def __init__(self, pos_x, pos_y, goal_x, goal_y, parent):
+    def __init__(
+        self, pos_x: int, pos_y: int, goal_x: int, goal_y: int, parent: Optional[Node]
+    ):
         self.pos_x = pos_x
         self.pos_y = pos_y
         self.pos = (pos_y, pos_x)
@@ -32,11 +37,11 @@ def __init__(self, pos_x, pos_y, goal_x, goal_y, parent):
 class BreadthFirstSearch:
     """
     >>> bfs = BreadthFirstSearch((0, 0), (len(grid) - 1, len(grid[0]) - 1))
-    >>> (bfs.start.pos_y + delta[3][0], bfs.start.pos_x + delta[3][1])
+    >>> (bfs.start.pos_y + direction[3][0], bfs.start.pos_x + direction[3][1])
     (0, 1)
     >>> [x.pos for x in bfs.get_successors(bfs.start)]
     [(1, 0), (0, 1)]
-    >>> (bfs.start.pos_y + delta[2][0], bfs.start.pos_x + delta[2][1])
+    >>> (bfs.start.pos_y + direction[2][0], bfs.start.pos_x + direction[2][1])
     (1, 0)
     >>> bfs.retrace_path(bfs.start)
     [(0, 0)]
@@ -45,14 +50,14 @@ class BreadthFirstSearch:
      (5, 1), (5, 2), (5, 3), (5, 4), (5, 5), (6, 5), (6, 6)]
     """
 
-    def __init__(self, start, goal):
+    def __init__(self, start: tuple[int, int], goal: tuple[int, int]):
         self.start = Node(start[1], start[0], goal[1], goal[0], None)
         self.target = Node(goal[1], goal[0], goal[1], goal[0], None)
 
         self.node_queue = [self.start]
         self.reached = False
 
-    def search(self) -> list[tuple[int]]:
+    def search(self) -> Optional[Path]:
         while self.node_queue:
             current_node = self.node_queue.pop(0)
 
@@ -65,15 +70,16 @@ def search(self) -> list[tuple[int]]:
             for node in successors:
                 self.node_queue.append(node)
 
-        if not (self.reached):
-            return [(self.start.pos)]
+        if not self.reached:
+            return [self.start.pos]
+        return None
 
     def get_successors(self, parent: Node) -> list[Node]:
         """
         Returns a list of successors (both in the grid and free spaces)
         """
         successors = []
-        for action in delta:
+        for action in direction:
             pos_x = parent.pos_x + action[1]
             pos_y = parent.pos_y + action[0]
             if not (0 <= pos_x <= len(grid[0]) - 1 and 0 <= pos_y <= len(grid) - 1):
@@ -87,7 +93,7 @@ def get_successors(self, parent: Node) -> list[Node]:
             )
         return successors
 
-    def retrace_path(self, node: Node) -> list[tuple[int]]:
+    def retrace_path(self, node: Optional[Node]) -> Path:
         """
         Retrace the path from parents to parents until start node
         """
@@ -119,7 +125,7 @@ def __init__(self, start, goal):
         self.bwd_bfs = BreadthFirstSearch(goal, start)
         self.reached = False
 
-    def search(self) -> list[tuple[int]]:
+    def search(self) -> Optional[Path]:
         while self.fwd_bfs.node_queue or self.bwd_bfs.node_queue:
             current_fwd_node = self.fwd_bfs.node_queue.pop(0)
             current_bwd_node = self.bwd_bfs.node_queue.pop(0)
@@ -144,10 +150,9 @@ def search(self) -> list[tuple[int]]:
 
         if not self.reached:
             return [self.fwd_bfs.start.pos]
+        return None
 
-    def retrace_bidirectional_path(
-        self, fwd_node: Node, bwd_node: Node
-    ) -> list[tuple[int]]:
+    def retrace_bidirectional_path(self, fwd_node: Node, bwd_node: Node) -> Path:
         fwd_path = self.fwd_bfs.retrace_path(fwd_node)
         bwd_path = self.bwd_bfs.retrace_path(bwd_node)
         bwd_path.pop()