fixup! Format Python code with psf/black push

Author: github-actions

machine_learning/astar.py

@@ -1,4 +1,4 @@
-'''
+"""
 The A* algorithm combines features of uniform-cost search and pure
 heuristic search to efficiently compute optimal solutions.
 A* algorithm is a best-first search algorithm in which the cost
@@ -9,12 +9,12 @@
 regular graph-searching algorithm,
 essentially planning ahead at each step so a more optimal decision
 is made.A* also known as the algorithm with brains
-'''
+"""
 import numpy as np
 
 
 class Cell(object):
-    '''
+    """
     Class cell represents a cell in the world which have the property
     position : The position of the represented by  tupleof x and y
     co-ordinates initially set to (0,0)
@@ -23,7 +23,8 @@ class Cell(object):
     g,h,f : The parameters for constructing the heuristic function
     which can be any function. for simplicity used line
     distance
-    '''
+    """
+
     def __init__(self):
         self.position = (0, 0)
         self.parent = None
@@ -32,10 +33,11 @@ def __init__(self):
         self.h = 0
         self.f = 0
 
-    '''
+    """
     overrides equals method because otherwise cell assign will give
     wrong results
-    '''
+    """
+
     def __eq__(self, cell):
         return self.position == cell.position
 
@@ -44,11 +46,11 @@ def showcell(self):
 
 
 class Gridworld(object):
-    '''
+    """
     Gridworld class represents the  external world here a grid M*M
     matrix
     world_size: create a numpy array with the given world_size default is 5
-    '''
+    """
 
     def __init__(self, world_size=(5, 5)):
         self.w = np.zeros(world_size)
@@ -59,12 +61,19 @@ def show(self):
         print(self.w)
 
     def get_neigbours(self, cell):
-        '''
+        """
         Return the neighbours of cell
-        '''
+        """
         neughbour_cord = [
-            (-1, -1), (-1, 0), (-1, 1), (0, -1),
-            (0, 1), (1, -1), (1, 0), (1, 1)]
+            (-1, -1),
+            (-1, 0),
+            (-1, 1),
+            (0, -1),
+            (0, 1),
+            (1, -1),
+            (1, 0),
+            (1, 1),
+        ]
         current_x = cell.position[0]
         current_y = cell.position[1]
         neighbours = []
@@ -80,7 +89,7 @@ def get_neigbours(self, cell):
 
 
 def astar(world, start, goal):
-    '''
+    """
     Implementation of a start algorithm
     world : Object of the world object
     start : Object of the cell as  start position
@@ -93,7 +102,7 @@ def astar(world, start, goal):
     >>> goal.position = (4,4)
     >>> astar(p, start, goal)
     [(0, 0), (1, 1), (2, 2), (3, 3), (4, 4)]
-    '''
+    """
     _open = []
     _closed = []
     _open.append(start)
@@ -111,7 +120,7 @@ def astar(world, start, goal):
             n.g = current.g + 1
             x1, y1 = n.position
             x2, y2 = goal.position
-            n.h = (y2 - y1)**2 + (x2 - x1)**2
+            n.h = (y2 - y1) ** 2 + (x2 - x1) ** 2
             n.f = n.h + n.g
 
             for c in _open:
@@ -126,16 +135,16 @@ def astar(world, start, goal):
     return path[::-1]
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     world = Gridworld()
-#   stat position and Goal
+    #   stat position and Goal
     start = Cell()
     start.position = (0, 0)
     goal = Cell()
     goal.position = (4, 4)
     print(f"path from {start.position} to {goal.position}")
     s = astar(world, start, goal)
-#   Just for visual reasons
+    #   Just for visual reasons
     for i in s:
         world.w[i] = 1
     print(world.w)