reformat with black

Author: guilyx

src/astar.py

@@ -1,7 +1,7 @@
-class AStarBestFirstSearch():
+class AStarBestFirstSearch:
     def __init__(self, automated_planner):
         self.automated_planner = automated_planner
-    
+
     def search(self):
         print("-/!\- No path found -/!\-")
         return []

src/automated_planner.py

@@ -16,6 +16,7 @@
 from julia import PDDL
 from time import time as now
 
+
 class AutomatedPlanner:
     def __init__(self, domain_path, problem_path):
         self.pddl = PDDL
@@ -28,7 +29,7 @@ def __execute_action(self, action, state):
 
     def transition(self, state, action):
         return self.pddl.transition(self.domain, state, action, check=False)
-        
+
     def available_actions(self, state):
         return self.pddl.available(state, self.domain)
 
@@ -66,7 +67,7 @@ def get_state_def_from_path(self, path):
         trimmed_path = []
         for node in path:
             trimmed_path.append(node.state)
-        return trimmed_path 
+        return trimmed_path
 
     def breadth_first_search(self, time_it=False):
         if time_it:

src/bfs.py

@@ -1,24 +1,34 @@
 from .node import Node
 
-class BreadthFirstSearch():
+
+class BreadthFirstSearch:
     def __init__(self, automated_planner):
         self.visited = []
         self.automated_planner = automated_planner
         self.init = Node(self.automated_planner.initial_state, automated_planner)
         self.queue = [self.init]
-    
+
     def search(self):
         while self.queue:
             current_node = self.queue.pop(0)
             if current_node not in self.visited:
                 self.visited.append(current_node)
 
-                if self.automated_planner.satisfies(self.automated_planner.problem.goal, current_node.state):
+                if self.automated_planner.satisfies(
+                    self.automated_planner.problem.goal, current_node.state
+                ):
                     return current_node
-                
+
                 actions = self.automated_planner.available_actions(current_node.state)
                 for act in actions:
-                    child = Node(state=self.automated_planner.transition(current_node.state, act), automated_planner=self.automated_planner, parent_action=act, parent=current_node)
+                    child = Node(
+                        state=self.automated_planner.transition(
+                            current_node.state, act
+                        ),
+                        automated_planner=self.automated_planner,
+                        parent_action=act,
+                        parent=current_node,
+                    )
                     if child in self.visited:
                         continue
                     self.queue.append(child)

src/dfs.py

@@ -1,7 +1,7 @@
-class DepthFirstSearch():
+class DepthFirstSearch:
     def __init__(self, automated_planner):
         self.automated_planner = automated_planner
-    
+
     def search(self):
         print("-/!\- No path found -/!\-")
         return []

src/dijkstra.py

@@ -2,10 +2,16 @@
 import math
 from .heuristics import zero_heuristic
 
-class DijkstraBestFirstSearch():
+
+class DijkstraBestFirstSearch:
     def __init__(self, automated_planner):
         self.automated_planner = automated_planner
-        self.init = Node(self.automated_planner.initial_state, automated_planner, is_closed=False, is_open=True)
+        self.init = Node(
+            self.automated_planner.initial_state,
+            automated_planner,
+            is_closed=False,
+            is_open=True,
+        )
         self.open_nodes_n = 1
         self.nodes = dict()
         self.nodes[self.__hash(self.init)] = self.init
@@ -17,19 +23,32 @@ def __hash(self, node):
 
     def search(self):
         while self.open_nodes_n > 0:
-            current_key = min([n for n in self.nodes if self.nodes[n].is_open], key=(lambda  k: self.nodes[k].f_cost))
+            current_key = min(
+                [n for n in self.nodes if self.nodes[n].is_open],
+                key=(lambda k: self.nodes[k].f_cost),
+            )
             current_node = self.nodes[current_key]
 
-            if self.automated_planner.satisfies(self.automated_planner.problem.goal, current_node.state):
-                    return current_node
+            if self.automated_planner.satisfies(
+                self.automated_planner.problem.goal, current_node.state
+            ):
+                return current_node
 
             current_node.is_closed = True
             current_node.is_open = False
             self.open_nodes_n -= 1
-            
+
             actions = self.automated_planner.available_actions(current_node.state)
             for act in actions:
-                child = Node(state=self.automated_planner.transition(current_node.state, act), automated_planner=self.automated_planner, parent_action=act, parent=current_node, heuristic=zero_heuristic, is_closed=False, is_open=True)
+                child = Node(
+                    state=self.automated_planner.transition(current_node.state, act),
+                    automated_planner=self.automated_planner,
+                    parent_action=act,
+                    parent=current_node,
+                    heuristic=zero_heuristic,
+                    is_closed=False,
+                    is_open=True,
+                )
                 child_hash = self.__hash(child)
                 if child_hash in self.nodes:
                     if self.nodes[child_hash].is_closed:

src/node.py

@@ -1,5 +1,15 @@
-class Node():
-    def __init__(self, state, automated_planner, is_closed=None, is_open=None, parent_action=None, parent=None, g_cost=0, heuristic=None):
+class Node:
+    def __init__(
+        self,
+        state,
+        automated_planner,
+        is_closed=None,
+        is_open=None,
+        parent_action=None,
+        parent=None,
+        g_cost=0,
+        heuristic=None,
+    ):
         self.state = state
         self.parent_action = parent_action
         self.parent = parent
@@ -19,7 +29,6 @@ def __init__(self, state, automated_planner, is_closed=None, is_open=None, paren
                 self.h_cost = 0
             self.f_cost = self.g_cost + self.h_cost
 
-    
         self.is_closed = is_closed
         self.is_open = is_open
 

tests/test_automated_planner.py

@@ -18,15 +18,17 @@ def test_available_actions():
 
     apla = AutomatedPlanner("data/domain.pddl", "data/problem.pddl")
     actions = apla.available_actions(apla.initial_state)
-    assert(len(actions) > 0)
+    assert len(actions) > 0
+
 
 def test_execute_action():
     from src.automated_planner import AutomatedPlanner
 
     apla = AutomatedPlanner("data/domain.pddl", "data/problem.pddl")
     actions = apla.available_actions(apla.initial_state)
     new_state = apla.transition(apla.initial_state, actions[0])
-    assert(str(new_state) != str(apla.initial_state))
+    assert str(new_state) != str(apla.initial_state)
+
 
 def test_state_assertion():
     from src.automated_planner import AutomatedPlanner