fix linting

Author: guilyx

jupyddl/automated_planner.py

@@ -27,9 +27,13 @@ def __init__(self, domain_path, problem_path, log_level="DEBUG"):
         self.initial_state = self.pddl.initialize(self.problem)
         self.goals = self.__flatten_goal()
         self.available_heuristics = [
-            "basic/zero", "basic/goal_count",
-            "delete_relaxation/h_add", "delete_relaxation/h_max",
-            "critical_path/1", "critical_path/2", "critical_path/3",
+            "basic/zero",
+            "basic/goal_count",
+            "delete_relaxation/h_add",
+            "delete_relaxation/h_max",
+            "critical_path/1",
+            "critical_path/2",
+            "critical_path/3",
         ]
 
         # Logger
@@ -47,7 +51,9 @@ def __run_julia_once(self):
         if actions:
             self.transition(self.initial_state, actions[0])
             return
-        logging.warning("No actions from initial state, a path probably (definitely) won't be found")
+        logging.warning(
+            "No actions from initial state, a path probably (definitely) won't be found"
+        )
 
     def __init_logger(self, log_level):
         import os

jupyddl/data_analyst.py

@@ -509,10 +509,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")
@@ -544,10 +541,7 @@ def comparative_greedy_bfs_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("Greedy Best First heuristics complexity comparison")
@@ -622,10 +616,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")
@@ -753,9 +744,7 @@ def compute_planners_efficiency(self):
         plt.ylabel("Cost to goal")
         for key, val in costs.items():
             ax.plot(
-                val,
-                "-o",
-                label=key,
+                val, "-o", label=key,
             )
             costs[key] = [i for i in costs[key] if i != 0]
         plt.title("Planners efficiency (costs)")

jupyddl/heuristics.py

@@ -29,6 +29,7 @@ def __goal_count_heuristic(self, state):
                 count += 1
         return count
 
+
 class DeleteRelaxationHeuristic:
     def __init__(self, automated_planner, heuristic_key):
         class DRHCache:
@@ -77,10 +78,8 @@ def compute(self, state):
                 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
-                    )
+                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)
@@ -127,10 +126,7 @@ def __facts_eq(self, facts_dict, facts_set):
                 return False
         return True
 
-<<<<<<< HEAD
-=======
 
->>>>>>> b0a6f7114bd56e8d05402ea32199a4ae7bd498bd
 class CriticalPathHeuristic:
     def __init__(self, automated_planner, critical_path_level=1):
         class CPCache:
@@ -143,10 +139,14 @@ def __init__(self, domain=None, axioms=None, preconds=None, additions=None):
         self.automated_planner = automated_planner
         self.cache = CPCache()
         if critical_path_level > 3:
-            logging.warning("Critical Path level is only implemented until 3, forcing it to 3.")
+            logging.warning(
+                "Critical Path level is only implemented until 3, forcing it to 3."
+            )
             self.critical_path_level = 3
         if critical_path_level < 1:
-            logging.warning("Critical Path level has to be at least 1, forcing it to 1.")
+            logging.warning(
+                "Critical Path level has to be at least 1, forcing it to 1."
+            )
             self.critical_path_level = 1
         else:
             self.critical_path_level = critical_path_level
@@ -174,17 +174,6 @@ def compute(self, state):
                         if str(g) in fact_costs_str:
                             costs.append(fact_costs_str[str(g)])
                 if self.critical_path_level == 2:
-<<<<<<< HEAD
-                    pairs_of_goals = [(g1, g2) for g1 in goals for g2 in goals if g1 != g2]
-                    for gs in pairs_of_goals:
-                        if str(gs[0]) in fact_costs_str and str(gs[1]) in fact_costs_str:
-                            costs.append(fact_costs_str[str(gs[0])] + fact_costs_str[str(gs[1])])
-                if self.critical_path_level == 3:
-                    triplets_of_goals = [(g1, g2, g3) for g1 in goals for g2 in goals for g3 in goals if g1 != g2 and g1 != g3 and g2 != g3]
-                    for gs in triplets_of_goals:
-                        if str(gs[0]) in fact_costs_str and str(gs[1]) in fact_costs_str and str(gs[2]) in fact_costs_str:
-                            costs.append(fact_costs_str[str(gs[0])] + fact_costs_str[str(gs[1])] + fact_costs_str[str(gs[2])])
-=======
                     pairs_of_goals = [
                         (g1, g2) for g1 in goals for g2 in goals if g1 != g2
                     ]
@@ -215,15 +204,12 @@ def compute(self, state):
                                 + fact_costs_str[str(gs[1])]
                                 + fact_costs_str[str(gs[2])]
                             )
->>>>>>> b0a6f7114bd56e8d05402ea32199a4ae7bd498bd
                 costs.insert(0, 0)
                 return max(costs)
 
             for ax in self.cache.axioms:
-                fact_costs = (
-                    self.automated_planner.pddl.compute_costs_one_step_derivation(
-                        facts, fact_costs, ax, "max"
-                    )
+                fact_costs = self.automated_planner.pddl.compute_costs_one_step_derivation(
+                    facts, fact_costs, ax, "max"
                 )
 
             actions = self.automated_planner.available_actions(state)

jupyddl/metrics.py

@@ -22,14 +22,17 @@ def __str__(self):
         else:
             av = 0
             w = 0
-        return "Expanded %d state(s).\nOpened %d state(s).\nReopened %d state(s).\nEvaluated %d state(s).\nGenerated %d state(s).\nDead ends: %d state(s).\nRuntime: %.2fs.\nTotal heuristic runtime: %.2fs\nComputational weight of heuristic in the search: %.2f%%" % (
-            self.n_expended,
-            self.n_opened,
-            self.n_reopened,
-            self.n_evaluated,
-            self.n_generated,
-            self.deadend_states,
-            self.runtime,
-            av,
-            w,
+        return (
+            "Expanded %d state(s).\nOpened %d state(s).\nReopened %d state(s).\nEvaluated %d state(s).\nGenerated %d state(s).\nDead ends: %d state(s).\nRuntime: %.2fs.\nTotal heuristic runtime: %.2fs\nComputational weight of heuristic in the search: %.2f%%"
+            % (
+                self.n_expended,
+                self.n_opened,
+                self.n_reopened,
+                self.n_evaluated,
+                self.n_generated,
+                self.deadend_states,
+                self.runtime,
+                av,
+                w,
+            )
         )

tests/test_automated_planner.py

@@ -2,6 +2,7 @@
 
 import sys
 from os import path
+
 sys.path.append(path.dirname(path.dirname(path.abspath(__file__))))
 from jupyddl.automated_planner import AutomatedPlanner