Format files with black

Author: guilyx

jupyddl/data_analyst.py

@@ -2,19 +2,21 @@
 import glob
 import matplotlib as mpl
 import logging
+
 mpl.use("TkAgg")
 mpl.set_loglevel("WARNING")
 import matplotlib.pyplot as plt
+
 plt.style.use("ggplot")
 from .automated_planner import AutomatedPlanner
 from os import path
 import json
 
+
 class DataAnalyst:
     def __init__(self):
         logging.info("Instantiating data analyst...")
 
-
     def __get_all_pddl_from_data(self):
         tested_files = []
         domains_problems = []
@@ -29,29 +31,29 @@ def __get_all_pddl_from_data(self):
                 i += 1
         return domains_problems
 
-
     def __plot_data(self, times, total_nodes, plot_title):
         plt.plot(total_nodes, times, "b:o")
         plt.xlabel("Number of opened nodes")
         plt.ylabel("Planning computation time")
         plt.title(plot_title)
-        plt.xscale('symlog')
-        plt.yscale('log')
+        plt.xscale("symlog")
+        plt.yscale("log")
         plt.grid(True)
         plt.show(block=False)
 
-
     def __scatter_data(self, times, total_nodes, plot_title):
         plt.scatter(total_nodes, times)
         plt.xlabel("Number of opened nodes")
         plt.ylabel("Planning computation time")
         plt.title(plot_title)
-        plt.xscale('symlog')
-        plt.yscale('log')
+        plt.xscale("symlog")
+        plt.yscale("log")
         plt.grid(True)
         plt.show(block=False)
 
-    def __gather_data_astar(self, domain_path="", problem_path="", heuristic_key="goal_count"):
+    def __gather_data_astar(
+        self, domain_path="", problem_path="", heuristic_key="goal_count"
+    ):
         has_multiple_files_tested = True
         if not domain_path and not problem_path:
             has_multiple_files_tested = False
@@ -90,7 +92,6 @@ def __gather_data_astar(self, domain_path="", problem_path="", heuristic_key="go
             return [0], [0], has_multiple_files_tested
         return [total_time], [total_nodes], has_multiple_files_tested
 
-
     def plot_astar_data(self, heuristic_key="goal_count", domain="", problem=""):
         if bool(not problem) != bool(not domain):
             logging.warning(
@@ -106,7 +107,6 @@ def plot_astar_data(self, heuristic_key="goal_count", domain="", problem=""):
         else:
             self.__scatter_data(times, total_nodes, title)
 
-
     def __gather_data_bfs(self, domain_path="", problem_path=""):
         has_multiple_files_tested = True
         if not domain_path and not problem_path:
@@ -130,7 +130,6 @@ def __gather_data_bfs(self, domain_path="", problem_path=""):
         _, total_time, opened_nodes = apla.breadth_first_search()
         return [total_time], [total_nodes], has_multiple_files_tested
 
-
     def plot_bfs(self, domain="", problem=""):
         title = "BFS Statistics"
         if bool(not problem) != bool(not domain):
@@ -146,7 +145,6 @@ def plot_bfs(self, domain="", problem=""):
         else:
             self.__scatter_data(times, total_nodes, title)
 
-
     def __gather_data_dfs(self, domain_path="", problem_path=""):
         has_multiple_files_tested = True
         if not domain_path and not problem_path:
@@ -170,7 +168,6 @@ def __gather_data_dfs(self, domain_path="", problem_path=""):
         _, total_time, opened_nodes = apla.depth_first_search()
         return [total_time], [total_nodes], has_multiple_files_tested
 
-
     def plot_dfs(self, problem="", domain=""):
         title = "DFS Statistics"
         if bool(not problem) != bool(not domain):
@@ -209,7 +206,6 @@ def __gather_data_dijkstra(self, domain_path="", problem_path=""):
         _, total_time, opened_nodes = apla.dijktra_best_first_search()
         return [total_time], [total_nodes], has_multiple_files_tested
 
-
     def plot_dijkstra(self, problem="", domain=""):
         title = "Dijkstra Statistics"
         if bool(not problem) != bool(not domain):
@@ -225,7 +221,6 @@ def plot_dijkstra(self, problem="", domain=""):
         else:
             self.__scatter_data(times, total_nodes, title)
 
-
     def __gather_data(
         self,
         heuristic_key="goal_count",
@@ -239,7 +234,7 @@ def __gather_data(
         gatherers = []
         xdata = dict()
         ydata = dict()
-        
+
         if bfs:
             gatherers.append(("BFS", self.__gather_data_bfs))
         if dfs:
@@ -249,19 +244,22 @@ def __gather_data(
         if astar:
             gatherers.append(("A*", self.__gather_data_astar))
 
-        _, _, _ = self.__gather_data_bfs(domain_path=domain, problem_path=problem) # Dummy line to do first parsing and get rid of static loading
+        _, _, _ = self.__gather_data_bfs(
+            domain_path=domain, problem_path=problem
+        )  # Dummy line to do first parsing and get rid of static loading
         for name, g in gatherers:
             if g == self.__gather_data_astar:
                 times, nodes, _ = self.__gather_data_astar(
-                    domain_path=domain, problem_path=problem, heuristic_key=heuristic_key
+                    domain_path=domain,
+                    problem_path=problem,
+                    heuristic_key=heuristic_key,
                 )
             else:
                 times, nodes, _ = g(domain_path=domain, problem_path=problem)
             ydata[name] = times
             xdata[name] = nodes
         return xdata, ydata
 
-
     def comparative_data_plot(
         self,
         astar=True,
@@ -317,11 +315,14 @@ def comparative_data_plot(
         plt.ylabel("Planning computation time (s)")
         for planner in json_dict["xdata"].keys():
             ax.plot(
-                sorted(json_dict["xdata"][planner]), sorted(json_dict["ydata"][planner]), '-o', label=planner
+                sorted(json_dict["xdata"][planner]),
+                sorted(json_dict["ydata"][planner]),
+                "-o",
+                label=planner,
             )
         plt.title("Planners complexity comparison")
         plt.legend(loc="upper left")
-        plt.xscale('symlog')
-        plt.yscale('log')
+        plt.xscale("symlog")
+        plt.yscale("log")
         plt.grid(True)
         plt.show(block=False)

scripts/astar_data_plot.py

@@ -1,6 +1,7 @@
 from common import get_all_pddl_from_data, plot_data, scatter_data
 from os import path
 import sys
+
 sys.path.append(path.dirname(path.dirname(path.abspath(__file__))))
 import logging
 from jupyddl.automated_planner import AutomatedPlanner

scripts/bfs_data_plot.py

@@ -48,4 +48,4 @@ def plot_bfs(domain="", problem=""):
 
 
 if __name__ == "__main__":
-   plot_bfs()
+    plot_bfs()

scripts/common.py

@@ -29,8 +29,8 @@ def plot_data(times, total_nodes, plot_title):
     plt.xlabel("Number of opened nodes")
     plt.ylabel("Planning computation time")
     plt.title(plot_title)
-    plt.xscale('symlog')
-    plt.yscale('log')
+    plt.xscale("symlog")
+    plt.yscale("log")
     plt.grid(True)
     plt.show()
 
@@ -40,8 +40,8 @@ def scatter_data(times, total_nodes, plot_title):
     plt.xlabel("Number of opened nodes")
     plt.ylabel("Planning computation time")
     plt.title(plot_title)
-    plt.xscale('symlog')
-    plt.yscale('log')
+    plt.xscale("symlog")
+    plt.yscale("log")
     plt.grid(True)
     plt.show()
 

scripts/planners_data_plot.py

@@ -20,7 +20,7 @@ def gather_data(
     gatherers = []
     xdata = dict()
     ydata = dict()
-    
+
     if bfs:
         gatherers.append(("BFS", gather_data_bfs))
     if dfs:
@@ -30,7 +30,9 @@ def gather_data(
     if astar:
         gatherers.append(("A*", gather_data_astar))
 
-    _, _, _ = gather_data_bfs(domain_path=domain, problem_path=problem) # Dummy line to do first parsing and get rid of static loading
+    _, _, _ = gather_data_bfs(
+        domain_path=domain, problem_path=problem
+    )  # Dummy line to do first parsing and get rid of static loading
     for name, g in gatherers:
         if g == gather_data_astar:
             times, nodes, _ = gather_data_astar(
@@ -97,12 +99,15 @@ def comparative_data_plot(
     plt.ylabel("Planning computation time (s)")
     for planner in json_dict["xdata"].keys():
         ax.plot(
-            sorted(json_dict["xdata"][planner]), sorted(json_dict["ydata"][planner]), '-o', label=planner
+            sorted(json_dict["xdata"][planner]),
+            sorted(json_dict["ydata"][planner]),
+            "-o",
+            label=planner,
         )
     plt.title("Planners complexity comparison")
     plt.legend(loc="upper left")
-    plt.xscale('symlog')
-    plt.yscale('log')
+    plt.xscale("symlog")
+    plt.yscale("log")
     plt.grid(True)
     plt.show()
 

tests/test_data_analyst.py

@@ -6,73 +6,91 @@
 sys.path.append(path.dirname(path.dirname(path.abspath(__file__))))
 from jupyddl.data_analyst import DataAnalyst
 
+
 def test_data_analyst_constructor():
     _ = DataAnalyst()
-    assert(True)
+    assert True
+
 
 def test_data_analyst_plot_dfs():
     da = DataAnalyst()
     da.plot_dfs()
-    assert(True)
+    assert True
+
 
 def test_data_analyst_plot_bfs():
     da = DataAnalyst()
     da.plot_bfs()
-    assert(True)
+    assert True
+
 
 def test_data_analyst_plot_dijkstra():
     da = DataAnalyst()
     da.plot_dijkstra()
-    assert(True)
+    assert True
+
 
 def test_data_analyst_plot_astar_h_goal_count():
     da = DataAnalyst()
     da.plot_astar_data()
-    assert(True)
+    assert True
+
 
 def test_data_analyst_plot_astar_h_zero():
     da = DataAnalyst()
     da.plot_astar_data(heuristic_key="zero")
-    assert(True)
+    assert True
+
 
 def test_comparative_no_restrictions():
     da = DataAnalyst()
     da.comparative_data_plot()
-    assert(True)
+    assert True
+
 
 def test_comparative_no_astar():
     da = DataAnalyst()
     da.comparative_data_plot(astar=False)
-    assert(True)
+    assert True
+
 
 def test_comparative_no_bfs():
     da = DataAnalyst()
     da.comparative_data_plot(bfs=False)
-    assert(True)
+    assert True
+
 
 def test_comparative_no_dijkstra():
     da = DataAnalyst()
     da.comparative_data_plot(dijkstra=False)
-    assert(True)
+    assert True
+
 
 def test_comparative_no_dfs():
     da = DataAnalyst()
     da.comparative_data_plot(dfs=False)
-    assert(True)
+    assert True
+
 
 def test_comparative_one_pddl():
     da = DataAnalyst()
-    da.comparative_data_plot(dfs=False, bfs=False, domain="data/domain.pddl", problem="data/problem.pddl")
-    assert(True)
+    da.comparative_data_plot(
+        dfs=False, bfs=False, domain="data/domain.pddl", problem="data/problem.pddl"
+    )
+    assert True
+
 
 def test_comparative_use_data_json():
     da = DataAnalyst()
-    da.comparative_data_plot(domain="data/domain.pddl", problem="data/problem.pddl", collect_new_data=False)
-    assert(True)
+    da.comparative_data_plot(
+        domain="data/domain.pddl", problem="data/problem.pddl", collect_new_data=False
+    )
+    assert True
+
 
 def test_comparative_zero_h():
     da = DataAnalyst()
-    da.comparative_data_plot(domain="data/domain.pddl", problem="data/problem.pddl", heuristic_key="zero")
-    assert(True)
-
-
+    da.comparative_data_plot(
+        domain="data/domain.pddl", problem="data/problem.pddl", heuristic_key="zero"
+    )
+    assert True