Reformat CLI command implementations

Author: nicholasjng

pybm/command.py

@@ -9,6 +9,7 @@
 
 class CLICommand:
     """CLI command base class."""
+
     usage = ""
 
     def __init__(self, name: str, **parser_kwargs):
@@ -20,20 +21,26 @@ def __init__(self, name: str, **parser_kwargs):
             usage=self.usage,
             description=self.__doc__,
             formatter_class=argparse.RawDescriptionHelpFormatter,
-            **parser_kwargs
+            **parser_kwargs,
+        )
+
+        self.parser.add_argument(
+            self.parser.prefix_chars + "h",
+            self.parser.prefix_chars * 2 + "help",
+            action="help",
+            default=argparse.SUPPRESS,
+            help="Show this message and exit.",
+        )
+
+        self.parser.add_argument(
+            self.parser.prefix_chars + "v",
+            action="store_true",
+            default=False,
+            dest="verbose",
+            help="Enable verbose mode. Makes pybm "
+            "log information that might be useful "
+            "for debugging.",
         )
-        self.parser.add_argument(self.parser.prefix_chars + 'h',
-                                 self.parser.prefix_chars * 2 + "help",
-                                 action='help',
-                                 default=argparse.SUPPRESS,
-                                 help='Show this message and exit.')
-        self.parser.add_argument(self.parser.prefix_chars + "v",
-                                 action="store_true",
-                                 default=False,
-                                 dest="verbose",
-                                 help="Enable verbose mode. Makes pybm "
-                                      "log information that might be useful "
-                                      "for debugging.")
 
     def add_arguments(self):
         """Add arguments to class argument parser member."""
@@ -48,11 +55,7 @@ def format_call(self, args: List[str]) -> str:
     def run_wrapped(self, args: List[str]):
         try:
             return self.run(args)
-        except (
-                PybmError,
-                GitError,
-                BuilderError,
-        ) as e:
+        except (PybmError, GitError, BuilderError) as e:
             sys.stderr.write(f"Error: {e}")
             sys.stderr.write(os.linesep)
             sys.exit(ERROR)

pybm/commands/base.py

@@ -16,17 +16,20 @@ class BaseCommand(CLICommand):
     report  - Report results of successful benchmarking runs.
     run     - Run specified benchmarks in different environments.
     """
+
     usage = "pybm <command> [<options>]"
 
     def __init__(self):
         super(BaseCommand, self).__init__(name="")
 
     def add_arguments(self):
         # special version action and version kwarg
-        self.parser.add_argument("--version",
-                                 action="version",
-                                 help="Show pybm version and exit.",
-                                 version=f"%(prog)s version {__version__}")
+        self.parser.add_argument(
+            "--version",
+            action="version",
+            help="Show pybm version and exit.",
+            version=f"%(prog)s version {__version__}",
+        )
 
     def run(self, args: List[str]):
         self.add_arguments()

pybm/commands/compare.py

@@ -13,36 +13,42 @@ class CompareCommand(CLICommand):
     """
     Report benchmark results from specified sources.
     """
+
     usage = "pybm compare <run> <anchor-ref> <compare-refs> [<options>]\n"
 
     def __init__(self):
         super(CompareCommand, self).__init__(name="compare")
         self.config = PybmConfig.load(".pybm/config.yaml")
 
     def add_arguments(self):
-        self.parser.add_argument("run",
-                                 type=str,
-                                 metavar="<run>",
-                                 help="Benchmark run to report results for. "
-                                      "To report the preceding run, use the "
-                                      "\"latest\" keyword. To report results "
-                                      "of the n-th preceding run "
-                                      "(i.e., n runs ago), "
-                                      "use the \"latest^{n}\" syntax.")
-        self.parser.add_argument("refs",
-                                 nargs="+",
-                                 metavar="<refs>",
-                                 help="Benchmarked refs to compare. The first "
-                                      "given ref will be treated as the "
-                                      "anchor ref, relative to which all "
-                                      "differences are reported. An error is "
-                                      "raised if any of the given "
-                                      "refs are not present in the run.")
+        self.parser.add_argument(
+            "run",
+            type=str,
+            metavar="<run>",
+            help="Benchmark run to report results for. "
+            "To report the preceding run, use the "
+            '"latest" keyword. To report results '
+            "of the n-th preceding run "
+            "(i.e., n runs ago), "
+            'use the "latest^{n}" syntax.',
+        )
+        self.parser.add_argument(
+            "refs",
+            nargs="+",
+            metavar="<refs>",
+            help="Benchmarked refs to compare. The first "
+            "given ref will be treated as the "
+            "anchor ref, relative to which all "
+            "differences are reported. An error is "
+            "raised if any of the given "
+            "refs are not present in the run.",
+        )
 
         reporter: BenchmarkReporter = get_reporter_class(config=self.config)
         reporter_name = self.config.get_value("reporter.className")
-        reporter_group_desc = f"Additional options from configured " \
-                              f"reporter class {reporter_name!r}"
+        reporter_group_desc = (
+            f"Additional options from configured reporter class {reporter_name!r}"
+        )
         reporter_group = self.parser.add_argument_group(reporter_group_desc)
         # add builder-specific options into the group
         for arg in reporter.add_arguments():
@@ -66,14 +72,18 @@ def run(self, args: List[str]) -> int:
         # TODO: Make this dynamic to support other run identifiers
         result = sorted(get_subdirs(result_dir))[-1]
         result_path = result_dir / result
+
         if result_path.exists():
-            reporter.compare(*refs,
-                             result=result,
-                             target_filter=options.target_filter,
-                             benchmark_filter=options.benchmark_filter,
-                             context_filter=options.context_filter)
+            reporter.compare(
+                *refs,
+                result=result,
+                target_filter=options.target_filter,
+                benchmark_filter=options.benchmark_filter,
+                context_filter=options.context_filter,
+            )
         else:
-            raise PybmError(f"No benchmark results found for the requested "
-                            f"run {run!r}.")
+            raise PybmError(
+                f"No benchmark results found for the requested run {run!r}."
+            )
 
         return SUCCESS

pybm/commands/config.py

@@ -12,56 +12,65 @@
 
 class ConfigCommand(CLICommand):
     """Display and manipulate configuration values."""
-    usage = "pybm config get <option>\n" \
-            "   or: pybm config set <option> <value>\n" \
-            "   or: pybm config list\n" \
-            "   or: pybm config describe <option>\n"
+
+    usage = (
+        "pybm config get <option>\n"
+        "   or: pybm config set <option> <value>\n"
+        "   or: pybm config list\n"
+        "   or: pybm config describe <option>\n"
+    )
 
     def __init__(self):
         super().__init__(name="config")
 
     def add_arguments(self, subcommand: str = None):
         # special version action and version kwarg
         if subcommand == "get":
-            self.parser.add_argument("option",
-                                     type=str,
-                                     metavar="<option>",
-                                     help="Config option to display. For a "
-                                          "comprehensive list of options, "
-                                          "run `pybm config list`.")
+            self.parser.add_argument(
+                "option",
+                type=str,
+                metavar="<option>",
+                help="Config option to display. For a "
+                "comprehensive list of options, "
+                "run `pybm config list`.",
+            )
         elif subcommand == "set":
-            self.parser.add_argument("option",
-                                     type=str,
-                                     metavar="<option>",
-                                     help="Config option to set. For a "
-                                          "comprehensive list of options, "
-                                          "run `pybm config list`.")
+            self.parser.add_argument(
+                "option",
+                type=str,
+                metavar="<option>",
+                help="Config option to set. For a "
+                "comprehensive list of options, "
+                "run `pybm config list`.",
+            )
             # TODO: Revise nargs value for this option
-            self.parser.add_argument("value",
-                                     metavar="<value>",
-                                     help="Config option to display. For a "
-                                          "comprehensive list of options, "
-                                          "run `pybm config list`.")
+            self.parser.add_argument(
+                "value",
+                metavar="<value>",
+                help="Config option to display. For a "
+                "comprehensive list of options, "
+                "run `pybm config list`.",
+            )
         elif subcommand == "describe":
-            self.parser.add_argument("option",
-                                     type=str,
-                                     metavar="<option>",
-                                     help="Config option to describe. For a "
-                                          "comprehensive list of options, "
-                                          "run `pybm config list`.")
+            self.parser.add_argument(
+                "option",
+                type=str,
+                metavar="<option>",
+                help="Config option to describe. For a "
+                "comprehensive list of options, "
+                "run `pybm config list`.",
+            )
 
     @contextlib.contextmanager
-    def context(self, op: str, attr: str, value: Optional[str],
-                verbose: bool = False):
+    def context(self, op: str, attr: str, value: Optional[str], verbose: bool = False):
         # TODO: This is BS
         is_group = "." not in attr
         expr = "value" + "s" * is_group + f" {value!r}" * (value is not None)
         try:
             if verbose:
                 opt_type = "group" if is_group else "option"
                 op = op.capitalize()
-                print(f"{op}ting {expr} for config {opt_type} {attr!r}"
-                      f".....", end="")
+                print(f"{op}ting {expr} for config {opt_type} {attr!r}.....", end="")
             yield
             if verbose:
                 print("done.")
@@ -72,58 +81,73 @@ def context(self, op: str, attr: str, value: Optional[str],
 
     def get(self, options: argparse.Namespace, verbose: bool) -> int:
         attr: str = options.option
+
         with self.context("get", attr, None, verbose):
             value = PybmConfig.load(".pybm/config.yaml").get_value(attr)
+
         if is_dataclass(value):
             for k, v in asdict(value).items():
                 print(f"{k} = {v}")
         else:
             print(f"{attr} = {value}")
+
         return SUCCESS
 
     def set(self, options: argparse.Namespace, verbose: bool) -> int:
         attr, value = options.option, options.value
         path = ".pybm/config.yaml"
+
         with self.context("set", attr, value, verbose):
             PybmConfig.load(path).set_value(attr, value).save(path)
+
         return SUCCESS
 
     @staticmethod
     def list(options: argparse.Namespace, verbose: bool) -> int:
         del verbose  # unused
         config = PybmConfig.load(".pybm/config.yaml")
+
         for name in get_all_names(config):
             group = config.get_value(name)
-            print(f"Config values for group \"{name}\":")
+            print(f"Config values for group {name!r}:")
+
             for k, v in asdict(group).items():
                 val = v if v != "" else "(empty string)"
                 print(f"{k} : {val}")
+
             print("")
         return SUCCESS
 
     @staticmethod
     def describe(options: argparse.Namespace, verbose: bool) -> int:
         del verbose  # unused
         attr = options.option
+
         if "__" in attr:
-            raise PybmError("Only unprivileged configuration attributes can "
-                            "be described via `pybm config describe`.")
+            raise PybmError(
+                "Only unprivileged configuration attributes can "
+                "be described via `pybm config describe`."
+            )
+
         config = PybmConfig.load(".pybm/config.yaml")
         config.describe(attr)
+
         return SUCCESS
 
     def run(self, args: List[str]):
         subcommand_handlers = {
             "set": self.set,
             "get": self.get,
             "list": self.list,
-            "describe": self.describe
+            "describe": self.describe,
         }
 
         if not args or args[0] not in subcommand_handlers:
             self.parser.print_help()
             return ERROR
+
         subcommand, *args = args
+
         self.add_arguments(subcommand=subcommand)
 
         # double hyphen prevents `config set` values to be mistaken for