reformat files

Author: guilyx

jupyddl/automated_planner.py

@@ -13,6 +13,7 @@
 
 logging.getLogger("julia").setLevel(logging.WARNING)
 
+
 class AutomatedPlanner:
     def __init__(self, domain_path, problem_path, log_level="DEBUG"):
         # Planning Tool
@@ -27,7 +28,7 @@ def __init__(self, domain_path, problem_path, log_level="DEBUG"):
             "basic/zero",
             "basic/goal_count",
             "delete_relaxation/h_add",
-            "delete_relaxation/h_max"
+            "delete_relaxation/h_max",
         ]
 
         # Logger
@@ -44,7 +45,6 @@ def __run_julia_once(self):
         actions = self.available_actions(self.initial_state)
         self.transition(self.initial_state, actions[0])
 
-
     def __init_logger(self, log_level):
         import os
 
@@ -133,7 +133,7 @@ def dijktra_best_first_search(self):
     def astar_best_first_search(self, heuristic_key="basic/goal_count"):
         if "basic" in heuristic_key:
             heuristic = BasicHeuristic(self, heuristic_key)
-        elif "delete_relaxation" in heuristic_key: 
+        elif "delete_relaxation" in heuristic_key:
             heuristic = DeleteRelaxationHeuristic(self, heuristic_key)
         else:
             logging.fatal("Not yet implemented")

jupyddl/data_analyst.py

@@ -19,7 +19,12 @@
 class DataAnalyst:
     def __init__(self):
         logging.info("Instantiating data analyst...")
-        self.available_heuristics = ["basic/goal_count", "basic/zero", "delete_relaxation/h_add", "delete_relaxation/h_max"]
+        self.available_heuristics = [
+            "basic/goal_count",
+            "basic/zero",
+            "delete_relaxation/h_add",
+            "delete_relaxation/h_max",
+        ]
 
     def __get_all_pddl_from_data(self, max_pddl_instances=-1):
         tested_files = []
@@ -84,7 +89,11 @@ def __gather_data_astar(
             for problem, domain in self.__get_all_pddl_from_data(
                 max_pddl_instances=max_pddl_instances
             ):
-                logging.debug("Loading new PDDL instance planned with A* [ " + heuristic_key + " ]")
+                logging.debug(
+                    "Loading new PDDL instance planned with A* [ "
+                    + heuristic_key
+                    + " ]"
+                )
                 logging.debug("Domain: " + domain)
                 logging.debug("Problem: " + problem)
                 apla = AutomatedPlanner(domain, problem)
@@ -124,7 +133,11 @@ def __gather_data_astar(
         return [0], [0], has_multiple_files_tested
 
     def plot_astar(
-        self, heuristic_key="basic/goal_count", domain="", problem="", max_pddl_instances=-1
+        self,
+        heuristic_key="basic/goal_count",
+        domain="",
+        problem="",
+        max_pddl_instances=-1,
     ):
         if bool(not problem) != bool(not domain):
             logging.warning(
@@ -354,10 +367,7 @@ def comparative_astar_heuristic_plot(
                 times_y.append(data[node_opened])
 
             ax.plot(
-                nodes_sorted,
-                times_y,
-                "-o",
-                label=h,
+                nodes_sorted, times_y, "-o", label=h,
             )
 
         plt.title("A* heuristics complexity comparison")
@@ -429,10 +439,7 @@ def comparative_data_plot(
             for node_opened in nodes_sorted:
                 times_y.append(data[node_opened])
             ax.plot(
-                nodes_sorted,
-                times_y,
-                "-o",
-                label=planner,
+                nodes_sorted, times_y, "-o", label=planner,
             )
         plt.title("Planners complexity comparison")
         plt.legend(loc="upper left")

jupyddl/dijkstra.py

@@ -4,8 +4,11 @@
 from datetime import datetime as timestamp
 from time import time as now
 
+
 def zero_heuristic():
     return 0
+
+
 class DijkstraBestFirstSearch:
     def __init__(self, automated_planner):
         self.automated_planner = automated_planner

jupyddl/heuristics.py

@@ -1,14 +1,17 @@
 import logging
 
+
 class BasicHeuristic:
     def __init__(self, automated_planner, heuristic_key):
         self.automated_planner = automated_planner
         self.heuristic_keys = {
             "basic/zero": self.__zero_heuristic,
-            "basic/goal_count": self.__goal_count_heuristic
+            "basic/goal_count": self.__goal_count_heuristic,
         }
         if heuristic_key not in list(self.heuristic_keys.keys()):
-            logging.warning("Heuristic key isn't registered, forcing it to [basic/goal_count]")
+            logging.warning(
+                "Heuristic key isn't registered, forcing it to [basic/goal_count]"
+            )
             heuristic_key = "basic/goal_count"
 
         self.current_h = heuristic_key
@@ -31,19 +34,21 @@ class DeleteRelaxationHeuristic:
     def __init__(self, automated_planner, heuristic_key):
         class DRHCache:
             def __init__(self, domain=None, axioms=None, preconds=None, additions=None):
-                self.domain = domain 
+                self.domain = domain
                 self.axioms = axioms
                 self.preconds = preconds
                 self.additions = additions
-        
+
         self.automated_planner = automated_planner
         self.cache = DRHCache()
         self.heuristic_keys = {
             "delete_relaxation/h_add": self.__h_add,
-            "delete_relaxation/h_max": self.__h_max
+            "delete_relaxation/h_max": self.__h_max,
         }
         if heuristic_key not in list(self.heuristic_keys.keys()):
-            logging.warning("Heuristic key isn't registered, forcing it to [delete_relaxation/h_add]")
+            logging.warning(
+                "Heuristic key isn't registered, forcing it to [delete_relaxation/h_add]"
+            )
             heuristic_key = "delete_relaxation/h_add"
 
         self.current_h = heuristic_key
@@ -56,25 +61,30 @@ def compute(self, state):
             self.__pre_compute()
         domain = self.cache.domain
         goals = self.automated_planner.goals
-        types = state.types 
-        facts = state.facts 
+        types = state.types
+        facts = state.facts
         fact_costs = self.automated_planner.pddl.init_facts_costs(facts)
-        while not(len(fact_costs) == self.automated_planner.pddl.length(facts) and self.__facts_eq(fact_costs, facts)):
-            facts, state = self.automated_planner.pddl.get_facts_and_state(fact_costs, types)
+        while not (
+            len(fact_costs) == self.automated_planner.pddl.length(facts)
+            and self.__facts_eq(fact_costs, facts)
+        ):
+            facts, state = self.automated_planner.pddl.get_facts_and_state(
+                fact_costs, types
+            )
             if self.automated_planner.satisfies(goals, state):
                 costs = []
-                fact_costs_str = dict( [(str(k), val) for k, val in fact_costs.items()] )
+                fact_costs_str = dict([(str(k), val) for k, val in fact_costs.items()])
                 for g in goals:
                     if str(g) in fact_costs_str:
                         costs.append(fact_costs_str[str(g)])
                 costs.insert(0, 0)
                 return self.heuristic_keys[self.current_h](costs)
-            
+
             for ax in self.cache.axioms:
                 fact_costs = self.automated_planner.pddl.compute_costs_one_step_derivation(
                     facts, fact_costs, ax, self.current_h
                 )
-            
+
             actions = self.automated_planner.available_actions(state)
             if not actions:
                 break
@@ -93,13 +103,14 @@ def __pre_compute(self):
         additions = dict()
         self.automated_planner.pddl.cache_global_preconditions(domain)
         for name, definition in domain.actions.items():
-            additions[name] = self.automated_planner.pddl.effect_diff(definition.effect).add
+            additions[name] = self.automated_planner.pddl.effect_diff(
+                definition.effect
+            ).add
         self.cache.additions = additions
         self.cache.preconds = self.automated_planner.pddl.g_preconditions
         self.cache.domain = domain
         self.cache.axioms = axioms
         self.has_been_precomputed = True
-        
 
     def __h_add(self, costs):
         return sum(costs)
@@ -109,7 +120,6 @@ def __h_max(self, costs):
 
     def __facts_eq(self, facts_dict, facts_set):
         for f in facts_set:
-            if not(f in facts_dict.keys()):
+            if not (f in facts_dict.keys()):
                 return False
         return True
-

main.py

@@ -14,9 +14,7 @@ def main():
     args = args_parser.parse_args()
     apla_tbx = AutomatedPlanner(args.domain, args.problem)
     apla_tbx.logger.info("Starting the planning script")
-    apla_tbx.logger.debug(
-        "Available heuristics: " + str(apla_tbx.available_heuristics)
-    )
+    apla_tbx.logger.debug("Available heuristics: " + str(apla_tbx.available_heuristics))
 
     path, computation_time, _ = apla_tbx.dijktra_best_first_search()
     apla_tbx.logger.debug(apla_tbx.get_actions_from_path(path))

tests/test_astar.py

@@ -8,6 +8,7 @@
 from jupyddl.a_star import AStarBestFirstSearch
 from jupyddl.heuristics import DeleteRelaxationHeuristic, BasicHeuristic
 
+
 def test_astar_basic():
     apla = AutomatedPlanner(
         "pddl-examples/dinner/domain.pddl", "pddl-examples/dinner/problem.pddl"
@@ -16,6 +17,7 @@ def test_astar_basic():
     astar = AStarBestFirstSearch(apla, heuristic.compute)
     assert astar.init.h_cost == heuristic.compute(apla.initial_state)
 
+
 def test_astar_delete_relaxation():
     apla = AutomatedPlanner(
         "pddl-examples/dinner/domain.pddl", "pddl-examples/dinner/problem.pddl"
@@ -24,6 +26,7 @@ def test_astar_delete_relaxation():
     astar = AStarBestFirstSearch(apla, heuristic.compute)
     assert astar.init.h_cost == heuristic.compute(apla.initial_state)
 
+
 def test_astar_goal():
     apla = AutomatedPlanner(
         "pddl-examples/dinner/domain.pddl", "pddl-examples/dinner/problem.pddl"

tests/test_heuristics.py

@@ -31,6 +31,7 @@ def test_goal_count_heuristic():
     h = heuristic.compute(apla.initial_state)
     assert h != 0
 
+
 def test_delete_relaxation_add_heuristic():
     apla = AutomatedPlanner(
         "pddl-examples/tsp/domain.pddl", "pddl-examples/tsp/problem.pddl"

tests/test_main.py

@@ -1,5 +1,6 @@
 import main
 
+
 def test_main():
     x = main.main()
     assert x == 0

tests/test_search.py

@@ -47,6 +47,7 @@ def test_search_astar_basic():
     assert res[1] != 0  # Assert that it took time to compute
     assert res[-1] > 0  # Assert that it visited at least one node
 
+
 def test_search_astar_delete_relaxation():
     apla = AutomatedPlanner(
         "pddl-examples/dinner/domain.pddl", "pddl-examples/dinner/problem.pddl"
@@ -56,4 +57,3 @@ def test_search_astar_delete_relaxation():
     res = astar.search()  # Goal, computation_time, opened_nodes(in this order)
     assert res[1] != 0  # Assert that it took time to compute
     assert res[-1] > 0  # Assert that it visited at least one node
-

tests/test_temp.py

@@ -8,11 +8,12 @@
 from jupyddl.a_star import AStarBestFirstSearch
 from jupyddl.heuristics import DeleteRelaxationHeuristic
 
+
 def test_astar_delete_relaxation():
     apla = AutomatedPlanner(
         "pddl-examples/tsp/domain.pddl", "pddl-examples/tsp/problem.pddl"
     )
     heuristic = DeleteRelaxationHeuristic(apla, "delete_relaxation/h_max")
-    astar = AStarBestFirstSearch(apla, heuristic.compute)   
+    astar = AStarBestFirstSearch(apla, heuristic.compute)
     astar.search()
     assert astar.init.h_cost == heuristic.compute(apla.initial_state)