fix linter errors

Author: SchwartzCode

PathPlanning/TimeBasedPathPlanning/GridWithDynamicObstacles.py

@@ -3,8 +3,7 @@
 from enum import Enum
 from typing import Tuple, TypeAlias
 
-Numpy2DArray: TypeAlias = np.ndarray[Tuple[int, int], np.dtype[np.int_]]
-Numpy1DArray: TypeAlias = np.ndarray[np.dtype[np.int_]]
+Numpy3DArray: TypeAlias = np.ndarray[Tuple[int, int, int], np.dtype[np.int_]]
 
 class Position:
     x: int
@@ -14,7 +13,7 @@ def __init__(self, x: int, y: int):
         self.x = x
         self.y = y
 
-    def as_ndarray(self) -> Numpy1DArray:
+    def as_ndarray(self) -> np.ndarray:
         return np.array([self.x, self.y])
 
     def __add__(self, other):
@@ -49,11 +48,11 @@ class ObstacleArrangement(Enum):
 
 class Grid:
     # Set in constructor
-    grid_size: Numpy1DArray
-    grid: Numpy2DArray
+    grid_size: np.ndarray
+    grid: Numpy3DArray
     obstacle_paths: list[list[Position]] = []
     # Obstacles will never occupy these points. Useful to avoid impossible scenarios
-    obstacle_avoid_points = []
+    obstacle_avoid_points: list[Position] = []
 
     # Number of time steps in the simulation
     time_limit: int
@@ -63,7 +62,7 @@ class Grid:
 
     def __init__(
         self,
-        grid_size: Numpy1DArray,
+        grid_size: np.ndarray,
         num_obstacles: int = 40,
         obstacle_avoid_points: list[Position] = [],
         obstacle_arrangement: ObstacleArrangement = ObstacleArrangement.RANDOM,

PathPlanning/TimeBasedPathPlanning/SpaceTimeAStar.py

@@ -5,7 +5,6 @@
     Reference: https://www.davidsilver.uk/wp-content/uploads/2020/03/coop-path-AIWisdom.pdf
 """
 
-from __future__ import annotations  # For typehints of a class within itself
 import numpy as np
 import matplotlib.pyplot as plt
 from PathPlanning.TimeBasedPathPlanning.GridWithDynamicObstacles import (
@@ -17,6 +16,7 @@
 from collections.abc import Generator
 import random
 from functools import total_ordering
+from typing import Optional
 
 # Seed randomness for reproducibility
 RANDOM_SEED = 50
@@ -42,10 +42,14 @@ def __init__(
     This is what is used to drive node expansion. The node with the lowest value is expanded next.
     This comparison prioritizes the node with the lowest cost-to-come (self.time) + cost-to-go (self.heuristic)
     """
-    def __lt__(self, other: Node):
+    def __lt__(self, other: object):
+        if not isinstance(other, Node):
+            return NotImplementedError(f"Cannot compare Node with object of type: {type(other)}")
         return (self.time + self.heuristic) < (other.time + other.heuristic)
 
-    def __eq__(self, other: Node):
+    def __eq__(self, other: object):
+        if not isinstance(other, Node):
+            return NotImplementedError(f"Cannot compare Node with object of type: {type(other)}")
         return self.position == other.position and self.time == other.time
 
     def __repr__(self):
@@ -64,7 +68,7 @@ def __init__(self, path: list[Node]):
     """
     Get the position of the path at a given time
     """
-    def get_position(self, time: int) -> Position:
+    def get_position(self, time: int) -> Optional[Position]:
         return self.positions_at_time.get(time)
 
     """
@@ -91,12 +95,12 @@ def __init__(self, grid: Grid, start: Position, goal: Position):
         self.goal = goal
 
     def plan(self, verbose: bool = False) -> NodePath:
-        open_set = []
+        open_set: list[Node] = []
         heapq.heappush(
             open_set, Node(self.start, 0, self.calculate_heuristic(self.start), -1)
         )
 
-        expanded_set = []
+        expanded_set: list[Node] = []
         while open_set:
             expanded_node: Node = heapq.heappop(open_set)
             if verbose: