Don't hide debug behind an option

Author: treykeown

arguably/__init__.py

@@ -934,7 +934,6 @@ class _ContextOptions:
 
     :ivar name: Name of the script/program. Defaults to the filename or module name (depending on invocation method).
 
-    :ivar debug: Normally false. If true, will log all calls to argparse and will log how commands are called.
     :ivar call_ancestors: Normally false. If true, `git init` will first call `git()`, then `git__init()`. Calls all
         members of the hierarchy. This allows parents to handle options. Parents can determine if they are actually the
         target command (instead of being called through the heirarchy) through the `is_target()` method.
@@ -959,7 +958,6 @@ class _ContextOptions:
     name: Optional[str]
 
     # Behavior options
-    debug: bool
     call_ancestors: bool
     always_subcommand: bool
     auto_alias_cmds: bool
@@ -1239,15 +1237,14 @@ def _set_up_args(self, cmd: _Command) -> None:
                     )
                 parser.set_defaults(**{arg_.arg_name: arg_.default})
                 for entry in _info_for_flags(arg_.arg_name, arg_.arg_value_type):
-                    if self._options.debug:
-                        logger.debug(
-                            f'Parser({parser.prog.partition(" ")[2]!r}).add_argument('
-                            f"*{entry.option!r}, "
-                            f"action={_EnumFlagAction!r}, "
-                            f"const={entry!r}, "
-                            f"nargs={0!r}, "
-                            f"help={entry.description!r},)"
-                        )
+                    logger.debug(
+                        f'Parser({parser.prog.partition(" ")[2]!r}).add_argument('
+                        f"*{entry.option!r}, "
+                        f"action={_EnumFlagAction!r}, "
+                        f"const={entry!r}, "
+                        f"nargs={0!r}, "
+                        f"help={entry.description!r},)"
+                    )
                     parser.add_argument(
                         *entry.option,
                         action=_EnumFlagAction,
@@ -1332,12 +1329,9 @@ def _set_up_args(self, cmd: _Command) -> None:
                 modifier.modify_arg_dict(cmd, arg_, add_arg_kwargs)
 
             # Add the argument to the parser
-            if self._options.debug:
-                logger.debug(
-                    f'Parser({parser.prog.partition(" ")[2]!r}).add_argument('
-                    f"*{arg_names!r}, "
-                    f"**{add_arg_kwargs!r})"
-                )
+            logger.debug(
+                f'Parser({parser.prog.partition(" ")[2]!r}).add_argument(' f"*{arg_names!r}, " f"**{add_arg_kwargs!r})"
+            )
             parser.add_argument(*arg_names, **add_arg_kwargs)
 
     def _build_subparser_tree(self, command_decorator_info: _CommandDecoratorInfo) -> str:
@@ -1356,14 +1350,13 @@ def _build_subparser_tree(self, command_decorator_info: _CommandDecoratorInfo) -
             if ancestor not in self._parsers:
                 # Dummy parser - since there's nothing to run, require the subparser.
                 required_subparser = True
-                if self._options.debug:
-                    logger.debug(
-                        f"Subparsers({prev_ancestor!r}).add_parser("
-                        f'{ancestor.split(" ")[-1]!r}, '
-                        f'help={""!r}, '
-                        f"formatter_class={self._formatter!r}, "
-                        f"**{self._extra_argparser_options!r},)"
-                    )
+                logger.debug(
+                    f"Subparsers({prev_ancestor!r}).add_parser("
+                    f'{ancestor.split(" ")[-1]!r}, '
+                    f'help={""!r}, '
+                    f"formatter_class={self._formatter!r}, "
+                    f"**{self._extra_argparser_options!r},)"
+                )
                 self._parsers[ancestor] = self._subparsers[prev_ancestor].add_parser(
                     ancestor.split(" ")[-1],
                     help="",
@@ -1377,14 +1370,13 @@ def _build_subparser_tree(self, command_decorator_info: _CommandDecoratorInfo) -
                     raise ArguablyException(
                         f"Command `{ancestor}` cannot have both subcommands and positional arguments."
                     )
-                if self._options.debug:
-                    logger.debug(
-                        f"Parser({ancestor!r}).add_subparsers("
-                        f"parser_class={_ArgumentParser!r}, "
-                        f"dest={ancestor_cmd.get_subcommand_metavar(self._options.command_metavar)!r}, "
-                        f"metavar={self._options.command_metavar!r}, "
-                        f"required={required_subparser!r},)"
-                    )
+                logger.debug(
+                    f"Parser({ancestor!r}).add_subparsers("
+                    f"parser_class={_ArgumentParser!r}, "
+                    f"dest={ancestor_cmd.get_subcommand_metavar(self._options.command_metavar)!r}, "
+                    f"metavar={self._options.command_metavar!r}, "
+                    f"required={required_subparser!r},)"
+                )
                 self._subparsers[ancestor] = self._parsers[ancestor].add_subparsers(
                     parser_class=_ArgumentParser,
                     dest=ancestor_cmd.get_subcommand_metavar(self._options.command_metavar),
@@ -1406,7 +1398,6 @@ def error(self, message: str) -> None:
     def run(
         self,
         name: Optional[str] = None,
-        debug: bool = False,
         call_ancestors: bool = False,
         always_subcommand: bool = False,
         auto_alias_cmds: bool = False,
@@ -1433,14 +1424,13 @@ def run(
         description = "" if __main__.__doc__ is None else __main__.__doc__.partition("\n\n\n")[0]
 
         # Set up the root parser
-        if self._options.debug:
-            logger.debug(
-                f'Initializing {"__root__"!r} parser: _ArgumentParser('
-                f"prog={self._options.name!r}, "
-                f"description={description!r}, "
-                f"formatter_class={self._formatter!r}, "
-                f"**{self._extra_argparser_options!r})"
-            )
+        logger.debug(
+            f'Initializing {"__root__"!r} parser: _ArgumentParser('
+            f"prog={self._options.name!r}, "
+            f"description={description!r}, "
+            f"formatter_class={self._formatter!r}, "
+            f"**{self._extra_argparser_options!r})"
+        )
         root_parser = _ArgumentParser(
             prog=self._options.name,
             description=description,
@@ -1459,13 +1449,12 @@ def run(
             else:
                 argparse_version_flags = ("--version",)
             version_string = f"%(prog)s {__main__.__version__}"
-            if self._options.debug:
-                logger.debug(
-                    f'Parser({"__root__"!r}).add_argument('
-                    f"*{argparse_version_flags!r}, "
-                    f'action={"version"!r}, '
-                    f"version={version_string!r})"
-                )
+            logger.debug(
+                f'Parser({"__root__"!r}).add_argument('
+                f"*{argparse_version_flags!r}, "
+                f'action={"version"!r}, '
+                f"version={version_string!r})"
+            )
             root_parser.add_argument(*argparse_version_flags, action="version", version=version_string)
 
         # Check the number of commands we have
@@ -1503,16 +1492,15 @@ def run(
 
             # Add the parser for the command
             if not only_one_cmd and cmd.name != "__root__":
-                if self._options.debug:
-                    logger.debug(
-                        f"Subparsers({parent_name!r}).add_parser("
-                        f'{cmd.name.split(" ")[-1]!r}, '
-                        f"aliases={[cmd.alias] if cmd.alias is not None else []!r}, "
-                        f"help={cmd.description!r}, "
-                        f"description={cmd.description!r}, "
-                        f"formatter_class={self._formatter!r}, "
-                        f"**{self._extra_argparser_options!r})"
-                    )
+                logger.debug(
+                    f"Subparsers({parent_name!r}).add_parser("
+                    f'{cmd.name.split(" ")[-1]!r}, '
+                    f"aliases={[cmd.alias] if cmd.alias is not None else []!r}, "
+                    f"help={cmd.description!r}, "
+                    f"description={cmd.description!r}, "
+                    f"formatter_class={self._formatter!r}, "
+                    f"**{self._extra_argparser_options!r})"
+                )
                 self._parsers[cmd.name] = self._subparsers[parent_name].add_parser(
                     cmd.name.split(" ")[-1],
                     aliases=[cmd.alias] if cmd.alias is not None else [],

arguably/util.py

@@ -123,7 +123,7 @@ def _load_and_run_inner(file: Path, *args: str, debug: bool) -> LoadAndRunResult
     sys.argv.extend(args)
 
     # Run and return success
-    arguably.run(name=file.stem, always_subcommand=True, show_types=True, show_defaults=True, debug=debug)
+    arguably.run(name=file.stem, always_subcommand=True, show_types=True, show_defaults=True)
     return LoadAndRunResult()