cmd2 2.5.6__py3-none-any.whl → 2.5.8__py3-none-any.whl

cmd2/ansi.py

@@ -1042,9 +1042,6 @@ def style(
 # Default styles for printing strings of various types.
 # These can be altered to suit an application's needs and only need to be a
 # function with the following structure: func(str) -> str
-style_output = functools.partial(style)
-"""Partial function supplying arguments to :meth:`cmd2.ansi.style()` which colors text for normal output"""
-
 style_success = functools.partial(style, fg=Fg.GREEN)
 """Partial function supplying arguments to :meth:`cmd2.ansi.style()` which colors text to signify success"""
 

cmd2/cmd2.py

@@ -218,6 +218,81 @@ else:
     ClassArgParseBuilder = classmethod
 
 
+class _CommandParsers:
+    """
+    Create and store all command method argument parsers for a given Cmd instance.
+
+    Parser creation and retrieval are accomplished through the get() method.
+    """
+
+    def __init__(self, cmd: 'Cmd') -> None:
+        self._cmd = cmd
+
+        # Keyed by the fully qualified method names. This is more reliable than
+        # the methods themselves, since wrapping a method will change its address.
+        self._parsers: Dict[str, argparse.ArgumentParser] = {}
+
+    @staticmethod
+    def _fully_qualified_name(command_method: CommandFunc) -> str:
+        """Return the fully qualified name of a method or None if a method wasn't passed in."""
+        try:
+            return f"{command_method.__module__}.{command_method.__qualname__}"
+        except AttributeError:
+            return ""
+
+    def __contains__(self, command_method: CommandFunc) -> bool:
+        """
+        Return whether a given method's parser is in self.
+
+        If the parser does not yet exist, it will be created if applicable.
+        This is basically for checking if a method is argarse-based.
+        """
+        parser = self.get(command_method)
+        return bool(parser)
+
+    def get(self, command_method: CommandFunc) -> Optional[argparse.ArgumentParser]:
+        """
+        Return a given method's parser or None if the method is not argparse-based.
+
+        If the parser does not yet exist, it will be created.
+        """
+        full_method_name = self._fully_qualified_name(command_method)
+        if not full_method_name:
+            return None
+
+        if full_method_name not in self._parsers:
+            if not command_method.__name__.startswith(COMMAND_FUNC_PREFIX):
+                return None
+            command = command_method.__name__[len(COMMAND_FUNC_PREFIX) :]
+
+            parser_builder = getattr(command_method, constants.CMD_ATTR_ARGPARSER, None)
+            parent = self._cmd.find_commandset_for_command(command) or self._cmd
+            parser = self._cmd._build_parser(parent, parser_builder)
+            if parser is None:
+                return None
+
+            # argparser defaults the program name to sys.argv[0], but we want it to be the name of our command
+            from .decorators import (
+                _set_parser_prog,
+            )
+
+            _set_parser_prog(parser, command)
+
+            # If the description has not been set, then use the method docstring if one exists
+            if parser.description is None and hasattr(command_method, '__wrapped__') and command_method.__wrapped__.__doc__:
+                parser.description = strip_doc_annotations(command_method.__wrapped__.__doc__)
+
+            self._parsers[full_method_name] = parser
+
+        return self._parsers.get(full_method_name)
+
+    def remove(self, command_method: CommandFunc) -> None:
+        """Remove a given method's parser if it exists."""
+        full_method_name = self._fully_qualified_name(command_method)
+        if full_method_name in self._parsers:
+            del self._parsers[full_method_name]
+
+
 class Cmd(cmd.Cmd):
     """An easy but powerful framework for writing line-oriented command interpreters.
 
@@ -537,11 +612,7 @@ class Cmd(cmd.Cmd):
         self.matches_sorted = False
 
         # Command parsers for this Cmd instance.
-        self._command_parsers: Dict[str, argparse.ArgumentParser] = {}
-
-        # Locates the command parser template or factory and creates an instance-specific parser
-        for command in self.get_all_commands():
-            self._register_command_parser(command, self.cmd_func(command))  # type: ignore[arg-type]
+        self._command_parsers = _CommandParsers(self)
 
         # Add functions decorated to be subcommands
         self._register_subcommands(self)
@@ -657,11 +728,11 @@ class Cmd(cmd.Cmd):
 
         installed_attributes = []
         try:
-            for method_name, method in methods:
-                command = method_name[len(COMMAND_FUNC_PREFIX) :]
+            for cmd_func_name, command_method in methods:
+                command = cmd_func_name[len(COMMAND_FUNC_PREFIX) :]
 
-                self._install_command_function(command, method, type(cmdset).__name__)
-                installed_attributes.append(method_name)
+                self._install_command_function(cmd_func_name, command_method, type(cmdset).__name__)
+                installed_attributes.append(cmd_func_name)
 
                 completer_func_name = COMPLETER_FUNC_PREFIX + command
                 cmd_completer = getattr(cmdset, completer_func_name, None)
@@ -677,8 +748,8 @@ class Cmd(cmd.Cmd):
 
                 self._cmd_to_command_sets[command] = cmdset
 
-                if default_category and not hasattr(method, constants.CMD_ATTR_HELP_CATEGORY):
-                    utils.categorize(method, default_category)
+                if default_category and not hasattr(command_method, constants.CMD_ATTR_HELP_CATEGORY):
+                    utils.categorize(command_method, default_category)
 
             self._installed_command_sets.add(cmdset)
 
@@ -718,33 +789,31 @@ class Cmd(cmd.Cmd):
             parser = copy.deepcopy(parser_builder)
         return parser
 
-    def _register_command_parser(self, command: str, command_method: Callable[..., Any]) -> None:
-        if command not in self._command_parsers:
-            parser_builder = getattr(command_method, constants.CMD_ATTR_ARGPARSER, None)
-            parent = self.find_commandset_for_command(command) or self
-            parser = self._build_parser(parent, parser_builder)
-            if parser is None:
-                return
-
-            # argparser defaults the program name to sys.argv[0], but we want it to be the name of our command
-            from .decorators import (
-                _set_parser_prog,
-            )
+    def _install_command_function(self, command_func_name: str, command_method: CommandFunc, context: str = '') -> None:
+        """
+        Install a new command function into the CLI.
 
-            _set_parser_prog(parser, command)
+        :param command_func_name: name of command function to add
+                                  This points to the command method and may differ from the method's
+                                  name if it's being used as a synonym. (e.g. do_exit = do_quit)
+        :param command_method: the actual command method which runs when the command function is called
+        :param context: optional info to provide in error message. (e.g. class this function belongs to)
+        :raises CommandSetRegistrationError: if the command function fails to install
+        """
 
-            # If the description has not been set, then use the method docstring if one exists
-            if parser.description is None and hasattr(command_method, '__wrapped__') and command_method.__wrapped__.__doc__:
-                parser.description = strip_doc_annotations(command_method.__wrapped__.__doc__)
+        # command_func_name must begin with COMMAND_FUNC_PREFIX to be identified as a command by cmd2.
+        if not command_func_name.startswith(COMMAND_FUNC_PREFIX):
+            raise CommandSetRegistrationError(f"{command_func_name} does not begin with '{COMMAND_FUNC_PREFIX}'")
 
-            self._command_parsers[command] = parser
+        # command_method must start with COMMAND_FUNC_PREFIX for use in self._command_parsers.
+        if not command_method.__name__.startswith(COMMAND_FUNC_PREFIX):
+            raise CommandSetRegistrationError(f"{command_method.__name__} does not begin with '{COMMAND_FUNC_PREFIX}'")
 
-    def _install_command_function(self, command: str, command_wrapper: Callable[..., Any], context: str = '') -> None:
-        cmd_func_name = COMMAND_FUNC_PREFIX + command
+        command = command_func_name[len(COMMAND_FUNC_PREFIX) :]
 
         # Make sure command function doesn't share name with existing attribute
-        if hasattr(self, cmd_func_name):
-            raise CommandSetRegistrationError(f'Attribute already exists: {cmd_func_name} ({context})')
+        if hasattr(self, command_func_name):
+            raise CommandSetRegistrationError(f'Attribute already exists: {command_func_name} ({context})')
 
         # Check if command has an invalid name
         valid, errmsg = self.statement_parser.is_valid_command(command)
@@ -761,9 +830,7 @@ class Cmd(cmd.Cmd):
             self.pwarning(f"Deleting macro '{command}' because it shares its name with a new command")
             del self.macros[command]
 
-        self._register_command_parser(command, command_wrapper)
-
-        setattr(self, cmd_func_name, command_wrapper)
+        setattr(self, command_func_name, command_method)
 
     def _install_completer_function(self, cmd_name: str, cmd_completer: CompleterFunc) -> None:
         completer_func_name = COMPLETER_FUNC_PREFIX + cmd_name
@@ -790,62 +857,66 @@ class Cmd(cmd.Cmd):
             cmdset.on_unregister()
             self._unregister_subcommands(cmdset)
 
-            methods: List[Tuple[str, Callable[[Any], Any]]] = inspect.getmembers(
+            methods: List[Tuple[str, Callable[..., Any]]] = inspect.getmembers(
                 cmdset,
                 predicate=lambda meth: isinstance(meth, Callable)  # type: ignore[arg-type]
                 and hasattr(meth, '__name__')
                 and meth.__name__.startswith(COMMAND_FUNC_PREFIX),
             )
 
-            for method in methods:
-                cmd_name = method[0][len(COMMAND_FUNC_PREFIX) :]
+            for cmd_func_name, command_method in methods:
+                command = cmd_func_name[len(COMMAND_FUNC_PREFIX) :]
 
                 # Enable the command before uninstalling it to make sure we remove both
                 # the real functions and the ones used by the DisabledCommand object.
-                if cmd_name in self.disabled_commands:
-                    self.enable_command(cmd_name)
+                if command in self.disabled_commands:
+                    self.enable_command(command)
+
+                if command in self._cmd_to_command_sets:
+                    del self._cmd_to_command_sets[command]
 
-                if cmd_name in self._cmd_to_command_sets:
-                    del self._cmd_to_command_sets[cmd_name]
+                # Only remove the parser if this is the actual
+                # command since command synonyms don't own it.
+                if cmd_func_name == command_method.__name__:
+                    self._command_parsers.remove(command_method)
 
-                delattr(self, COMMAND_FUNC_PREFIX + cmd_name)
-                if cmd_name in self._command_parsers:
-                    del self._command_parsers[cmd_name]
+                if hasattr(self, COMPLETER_FUNC_PREFIX + command):
+                    delattr(self, COMPLETER_FUNC_PREFIX + command)
+                if hasattr(self, HELP_FUNC_PREFIX + command):
+                    delattr(self, HELP_FUNC_PREFIX + command)
 
-                if hasattr(self, COMPLETER_FUNC_PREFIX + cmd_name):
-                    delattr(self, COMPLETER_FUNC_PREFIX + cmd_name)
-                if hasattr(self, HELP_FUNC_PREFIX + cmd_name):
-                    delattr(self, HELP_FUNC_PREFIX + cmd_name)
+                delattr(self, cmd_func_name)
 
             cmdset.on_unregistered()
             self._installed_command_sets.remove(cmdset)
 
     def _check_uninstallable(self, cmdset: CommandSet) -> None:
-        methods: List[Tuple[str, Callable[[Any], Any]]] = inspect.getmembers(
+        def check_parser_uninstallable(parser: argparse.ArgumentParser) -> None:
+            for action in parser._actions:
+                if isinstance(action, argparse._SubParsersAction):
+                    for subparser in action.choices.values():
+                        attached_cmdset = getattr(subparser, constants.PARSER_ATTR_COMMANDSET, None)
+                        if attached_cmdset is not None and attached_cmdset is not cmdset:
+                            raise CommandSetRegistrationError(
+                                'Cannot uninstall CommandSet when another CommandSet depends on it'
+                            )
+                        check_parser_uninstallable(subparser)
+                    break
+
+        methods: List[Tuple[str, Callable[..., Any]]] = inspect.getmembers(
             cmdset,
             predicate=lambda meth: isinstance(meth, Callable)  # type: ignore[arg-type]
             and hasattr(meth, '__name__')
             and meth.__name__.startswith(COMMAND_FUNC_PREFIX),
         )
 
-        for method in methods:
-            command_name = method[0][len(COMMAND_FUNC_PREFIX) :]
-            command_parser = self._command_parsers.get(command_name, None)
-
-            def check_parser_uninstallable(parser: argparse.ArgumentParser) -> None:
-                for action in parser._actions:
-                    if isinstance(action, argparse._SubParsersAction):
-                        for subparser in action.choices.values():
-                            attached_cmdset = getattr(subparser, constants.PARSER_ATTR_COMMANDSET, None)
-                            if attached_cmdset is not None and attached_cmdset is not cmdset:
-                                raise CommandSetRegistrationError(
-                                    'Cannot uninstall CommandSet when another CommandSet depends on it'
-                                )
-                            check_parser_uninstallable(subparser)
-                        break
-
-            if command_parser is not None:
-                check_parser_uninstallable(command_parser)
+        for cmd_func_name, command_method in methods:
+            # We only need to check if it's safe to remove the parser if this
+            # is the actual command since command synonyms don't own it.
+            if cmd_func_name == command_method.__name__:
+                command_parser = self._command_parsers.get(command_method)
+                if command_parser is not None:
+                    check_parser_uninstallable(command_parser)
 
     def _register_subcommands(self, cmdset: Union[CommandSet, 'Cmd']) -> None:
         """
@@ -889,7 +960,7 @@ class Cmd(cmd.Cmd):
                 raise CommandSetRegistrationError(
                     f"Could not find command '{command_name}' needed by subcommand: {str(method)}"
                 )
-            command_parser = self._command_parsers.get(command_name, None)
+            command_parser = self._command_parsers.get(command_func)
             if command_parser is None:
                 raise CommandSetRegistrationError(
                     f"Could not find argparser for command '{command_name}' needed by subcommand: {str(method)}"
@@ -991,7 +1062,7 @@ class Cmd(cmd.Cmd):
                 raise CommandSetRegistrationError(
                     f"Could not find command '{command_name}' needed by subcommand: {str(method)}"
                 )
-            command_parser = self._command_parsers.get(command_name, None)
+            command_parser = self._command_parsers.get(command_func)
             if command_parser is None:  # pragma: no cover
                 # This really shouldn't be possible since _register_subcommands would prevent this from happening
                 # but keeping in case it does for some strange reason
@@ -1141,123 +1212,67 @@ class Cmd(cmd.Cmd):
 
     def print_to(
         self,
-        dest: Union[TextIO, IO[str]],
+        dest: IO[str],
         msg: Any,
         *,
         end: str = '\n',
         style: Optional[Callable[[str], str]] = None,
-        paged: bool = False,
-        chop: bool = False,
     ) -> None:
+        """
+        Print message to a given file object.
+
+        :param dest: the file object being written to
+        :param msg: object to print
+        :param end: string appended after the end of the message, default a newline
+        :param style: optional style function to format msg with (e.g. ansi.style_success)
+        """
         final_msg = style(msg) if style is not None else msg
-        if paged:
-            self.ppaged(final_msg, end=end, chop=chop, dest=dest)
-        else:
-            try:
-                ansi.style_aware_write(dest, f'{final_msg}{end}')
-            except BrokenPipeError:
-                # This occurs if a command's output is being piped to another
-                # process and that process closes before the command is
-                # finished. If you would like your application to print a
-                # warning message, then set the broken_pipe_warning attribute
-                # to the message you want printed.
-                if self.broken_pipe_warning:
-                    sys.stderr.write(self.broken_pipe_warning)
+        try:
+            ansi.style_aware_write(dest, f'{final_msg}{end}')
+        except BrokenPipeError:
+            # This occurs if a command's output is being piped to another
+            # process and that process closes before the command is
+            # finished. If you would like your application to print a
+            # warning message, then set the broken_pipe_warning attribute
+            # to the message you want printed.
+            if self.broken_pipe_warning:
+                sys.stderr.write(self.broken_pipe_warning)
 
-    def poutput(
-        self,
-        msg: Any = '',
-        *,
-        end: str = '\n',
-        apply_style: bool = True,
-        paged: bool = False,
-        chop: bool = False,
-    ) -> None:
+    def poutput(self, msg: Any = '', *, end: str = '\n') -> None:
         """Print message to self.stdout and appends a newline by default
 
-        Also handles BrokenPipeError exceptions for when a command's output has
-        been piped to another process and that process terminates before the
-        cmd2 command is finished executing.
-
         :param msg: object to print
         :param end: string appended after the end of the message, default a newline
-        :param apply_style: If True, then ansi.style_output will be applied to the message text. Set to False in cases
-                            where the message text already has the desired style. Defaults to True.
-        :param paged: If True, pass the output through the configured pager.
-        :param chop: If paged is True, True to truncate long lines or False to wrap long lines.
         """
-        self.print_to(self.stdout, msg, end=end, style=ansi.style_output if apply_style else None, paged=paged, chop=chop)
+        self.print_to(self.stdout, msg, end=end)
 
-    def perror(
-        self,
-        msg: Any = '',
-        *,
-        end: str = '\n',
-        apply_style: bool = True,
-        paged: bool = False,
-        chop: bool = False,
-    ) -> None:
+    def perror(self, msg: Any = '', *, end: str = '\n', apply_style: bool = True) -> None:
         """Print message to sys.stderr
 
         :param msg: object to print
         :param end: string appended after the end of the message, default a newline
         :param apply_style: If True, then ansi.style_error will be applied to the message text. Set to False in cases
                             where the message text already has the desired style. Defaults to True.
-        :param paged: If True, pass the output through the configured pager.
-        :param chop: If paged is True, True to truncate long lines or False to wrap long lines.
         """
-        self.print_to(sys.stderr, msg, end=end, style=ansi.style_error if apply_style else None, paged=paged, chop=chop)
+        self.print_to(sys.stderr, msg, end=end, style=ansi.style_error if apply_style else None)
 
-    def psuccess(
-        self,
-        msg: Any = '',
-        *,
-        end: str = '\n',
-        paged: bool = False,
-        chop: bool = False,
-    ) -> None:
-        """Writes to stdout applying ansi.style_success by default
+    def psuccess(self, msg: Any = '', *, end: str = '\n') -> None:
+        """Wraps poutput, but applies ansi.style_success by default
 
         :param msg: object to print
         :param end: string appended after the end of the message, default a newline
-        :param paged: If True, pass the output through the configured pager.
-        :param chop: If paged is True, True to truncate long lines or False to wrap long lines.
         """
-        self.print_to(self.stdout, msg, end=end, style=ansi.style_success, paged=paged, chop=chop)
+        msg = ansi.style_success(msg)
+        self.poutput(msg, end=end)
 
-    def pwarning(
-        self,
-        msg: Any = '',
-        *,
-        end: str = '\n',
-        paged: bool = False,
-        chop: bool = False,
-    ) -> None:
+    def pwarning(self, msg: Any = '', *, end: str = '\n') -> None:
         """Wraps perror, but applies ansi.style_warning by default
 
         :param msg: object to print
         :param end: string appended after the end of the message, default a newline
-        :param paged: If True, pass the output through the configured pager.
-        :param chop: If paged is True, True to truncate long lines or False to wrap long lines.
-        """
-        self.print_to(sys.stderr, msg, end=end, style=ansi.style_warning, paged=paged, chop=chop)
-
-    def pfailure(
-        self,
-        msg: Any = '',
-        *,
-        end: str = '\n',
-        paged: bool = False,
-        chop: bool = False,
-    ) -> None:
-        """Writes to stderr applying ansi.style_error by default
-
-        :param msg: object to print
-        :param end: string appended after the end of the message, default a newline
-        :param paged: If True, pass the output through the configured pager.
-        :param chop: If paged is True, True to truncate long lines or False to wrap long lines.
         """
-        self.print_to(sys.stderr, msg, end=end, style=ansi.style_error, paged=paged, chop=chop)
+        msg = ansi.style_warning(msg)
+        self.perror(msg, end=end, apply_style=False)
 
     def pexcept(self, msg: Any, *, end: str = '\n', apply_style: bool = True) -> None:
         """Print Exception message to sys.stderr. If debug is true, print exception traceback if one exists.
@@ -1286,36 +1301,20 @@ class Cmd(cmd.Cmd):
 
         self.perror(final_msg, end=end, apply_style=False)
 
-    def pfeedback(
-        self,
-        msg: Any,
-        *,
-        end: str = '\n',
-        apply_style: bool = True,
-        paged: bool = False,
-        chop: bool = False,
-    ) -> None:
+    def pfeedback(self, msg: Any, *, end: str = '\n') -> None:
         """For printing nonessential feedback.  Can be silenced with `quiet`.
         Inclusion in redirected output is controlled by `feedback_to_output`.
 
         :param msg: object to print
         :param end: string appended after the end of the message, default a newline
-        :param apply_style: If True, then ansi.style_output will be applied to the message text. Set to False in cases
-                            where the message text already has the desired style. Defaults to True.
-        :param paged: If True, pass the output through the configured pager.
-        :param chop: If paged is True, True to truncate long lines or False to wrap long lines.
         """
         if not self.quiet:
-            self.print_to(
-                self.stdout if self.feedback_to_output else sys.stderr,
-                msg,
-                end=end,
-                style=ansi.style_output if apply_style else None,
-                paged=paged,
-                chop=chop,
-            )
+            if self.feedback_to_output:
+                self.poutput(msg, end=end)
+            else:
+                self.perror(msg, end=end, apply_style=False)
 
-    def ppaged(self, msg: Any, *, end: str = '\n', chop: bool = False, dest: Optional[Union[TextIO, IO[str]]] = None) -> None:
+    def ppaged(self, msg: Any, *, end: str = '\n', chop: bool = False) -> None:
         """Print output using a pager if it would go off screen and stdout isn't currently being redirected.
 
         Never uses a pager inside a script (Python or text) or when output is being redirected or piped or when
@@ -1328,53 +1327,44 @@ class Cmd(cmd.Cmd):
                               - chopping is ideal for displaying wide tabular data as is done in utilities like pgcli
                      False -> causes lines longer than the screen width to wrap to the next line
                               - wrapping is ideal when you want to keep users from having to use horizontal scrolling
-        :param dest: Optionally specify the destination stream to write to. If unspecified, defaults to self.stdout
 
         WARNING: On Windows, the text always wraps regardless of what the chop argument is set to
         """
-        # msg can be any type, so convert to string before checking if it's blank
-        msg_str = str(msg)
-        dest = self.stdout if dest is None else dest
-
-        # Consider None to be no data to print
-        if msg is None or msg_str == '':
-            return
+        # Attempt to detect if we are not running within a fully functional terminal.
+        # Don't try to use the pager when being run by a continuous integration system like Jenkins + pexpect.
+        functional_terminal = False
 
-        try:
-            import subprocess
-
-            # Attempt to detect if we are not running within a fully functional terminal.
-            # Don't try to use the pager when being run by a continuous integration system like Jenkins + pexpect.
-            functional_terminal = False
+        if self.stdin.isatty() and self.stdout.isatty():
+            if sys.platform.startswith('win') or os.environ.get('TERM') is not None:
+                functional_terminal = True
 
-            if self.stdin.isatty() and self.stdout.isatty():
-                if sys.platform.startswith('win') or os.environ.get('TERM') is not None:
-                    functional_terminal = True
+        # Don't attempt to use a pager that can block if redirecting or running a script (either text or Python).
+        # Also only attempt to use a pager if actually running in a real fully functional terminal.
+        if functional_terminal and not self._redirecting and not self.in_pyscript() and not self.in_script():
+            final_msg = f"{msg}{end}"
+            if ansi.allow_style == ansi.AllowStyle.NEVER:
+                final_msg = ansi.strip_style(final_msg)
 
-            # Don't attempt to use a pager that can block if redirecting or running a script (either text or Python)
-            # Also only attempt to use a pager if actually running in a real fully functional terminal
-            if functional_terminal and not self._redirecting and not self.in_pyscript() and not self.in_script():
-                if ansi.allow_style == ansi.AllowStyle.NEVER:
-                    msg_str = ansi.strip_style(msg_str)
-                msg_str += end
-
-                pager = self.pager
-                if chop:
-                    pager = self.pager_chop
+            pager = self.pager
+            if chop:
+                pager = self.pager_chop
 
+            try:
                 # Prevent KeyboardInterrupts while in the pager. The pager application will
                 # still receive the SIGINT since it is in the same process group as us.
                 with self.sigint_protection:
-                    pipe_proc = subprocess.Popen(pager, shell=True, stdin=subprocess.PIPE)
-                    pipe_proc.communicate(msg_str.encode('utf-8', 'replace'))
-            else:
-                ansi.style_aware_write(dest, f'{msg_str}{end}')
-        except BrokenPipeError:
-            # This occurs if a command's output is being piped to another process and that process closes before the
-            # command is finished. If you would like your application to print a warning message, then set the
-            # broken_pipe_warning attribute to the message you want printed.`
-            if self.broken_pipe_warning:
-                sys.stderr.write(self.broken_pipe_warning)
+                    import subprocess
+
+                    pipe_proc = subprocess.Popen(pager, shell=True, stdin=subprocess.PIPE, stdout=self.stdout)
+                    pipe_proc.communicate(final_msg.encode('utf-8', 'replace'))
+            except BrokenPipeError:
+                # This occurs if a command's output is being piped to another process and that process closes before the
+                # command is finished. If you would like your application to print a warning message, then set the
+                # broken_pipe_warning attribute to the message you want printed.`
+                if self.broken_pipe_warning:
+                    sys.stderr.write(self.broken_pipe_warning)
+        else:
+            self.poutput(msg, end=end)
 
     # -----  Methods related to tab completion -----
 
@@ -2098,12 +2088,12 @@ class Cmd(cmd.Cmd):
                 else:
                     # There's no completer function, next see if the command uses argparse
                     func = self.cmd_func(command)
-                    argparser = self._command_parsers.get(command, None)
+                    argparser = None if func is None else self._command_parsers.get(func)
 
                     if func is not None and argparser is not None:
                         # Get arguments for complete()
                         preserve_quotes = getattr(func, constants.CMD_ATTR_PRESERVE_QUOTES)
-                        cmd_set = self._cmd_to_command_sets[command] if command in self._cmd_to_command_sets else None
+                        cmd_set = self.find_commandset_for_command(command)
 
                         # Create the argparse completer
                         completer_type = self._determine_ap_completer_type(argparser)
@@ -3044,19 +3034,9 @@ class Cmd(cmd.Cmd):
 
         helpfunc now contains a reference to the ``do_help`` method
         """
-        func_name = self._cmd_func_name(command)
-        if func_name:
-            return cast(Optional[CommandFunc], getattr(self, func_name))
-        return None
-
-    def _cmd_func_name(self, command: str) -> str:
-        """Get the method name associated with a given command.
-
-        :param command: command to look up method name which implements it
-        :return: method name which implements the given command
-        """
-        target = constants.COMMAND_FUNC_PREFIX + command
-        return target if callable(getattr(self, target, None)) else ''
+        func_name = constants.COMMAND_FUNC_PREFIX + command
+        func = getattr(self, func_name, None)
+        return cast(CommandFunc, func) if callable(func) else None
 
     def onecmd(self, statement: Union[Statement, str], *, add_to_history: bool = True) -> bool:
         """This executes the actual do_* method for a command.
@@ -3404,7 +3384,7 @@ class Cmd(cmd.Cmd):
     alias_description = "Manage aliases\n" "\n" "An alias is a command that enables replacement of a word by another string."
     alias_epilog = "See also:\n" "  macro"
     alias_parser = argparse_custom.DEFAULT_ARGUMENT_PARSER(description=alias_description, epilog=alias_epilog)
-    alias_parser.add_subparsers(dest='subcommand', metavar='SUBCOMMAND', required=True)
+    alias_parser.add_subparsers(metavar='SUBCOMMAND', required=True)
 
     # Preserve quotes since we are passing strings to other commands
     @with_argparser(alias_parser, preserve_quotes=True)
@@ -3572,7 +3552,7 @@ class Cmd(cmd.Cmd):
     macro_description = "Manage macros\n" "\n" "A macro is similar to an alias, but it can contain argument placeholders."
     macro_epilog = "See also:\n" "  alias"
     macro_parser = argparse_custom.DEFAULT_ARGUMENT_PARSER(description=macro_description, epilog=macro_epilog)
-    macro_parser.add_subparsers(dest='subcommand', metavar='SUBCOMMAND', required=True)
+    macro_parser.add_subparsers(metavar='SUBCOMMAND', required=True)
 
     # Preserve quotes since we are passing strings to other commands
     @with_argparser(macro_parser, preserve_quotes=True)
@@ -3820,9 +3800,7 @@ class Cmd(cmd.Cmd):
             return []
 
         # Check if this command uses argparse
-        func = self.cmd_func(command)
-        argparser = self._command_parsers.get(command, None)
-        if func is None or argparser is None:
+        if (func := self.cmd_func(command)) is None or (argparser := self._command_parsers.get(func)) is None:
             return []
 
         completer = argparse_completer.DEFAULT_AP_COMPLETER(argparser, self)
@@ -3857,7 +3835,7 @@ class Cmd(cmd.Cmd):
             # Getting help for a specific command
             func = self.cmd_func(args.command)
             help_func = getattr(self, constants.HELP_FUNC_PREFIX + args.command, None)
-            argparser = self._command_parsers.get(args.command, None)
+            argparser = None if func is None else self._command_parsers.get(func)
 
             # If the command function uses argparse, then use argparse's help
             if func is not None and argparser is not None:
@@ -3979,28 +3957,29 @@ class Cmd(cmd.Cmd):
     def _build_command_info(self) -> Tuple[Dict[str, List[str]], List[str], List[str], List[str]]:
         # Get a sorted list of help topics
         help_topics = sorted(self.get_help_topics(), key=self.default_sort_key)
+
         # Get a sorted list of visible command names
         visible_commands = sorted(self.get_visible_commands(), key=self.default_sort_key)
         cmds_doc: List[str] = []
         cmds_undoc: List[str] = []
         cmds_cats: Dict[str, List[str]] = {}
         for command in visible_commands:
-            func = self.cmd_func(command)
+            func = cast(CommandFunc, self.cmd_func(command))
             has_help_func = False
+            has_parser = func in self._command_parsers
 
             if command in help_topics:
                 # Prevent the command from showing as both a command and help topic in the output
                 help_topics.remove(command)
 
                 # Non-argparse commands can have help_functions for their documentation
-                if command not in self._command_parsers:
-                    has_help_func = True
+                has_help_func = not has_parser
 
             if hasattr(func, constants.CMD_ATTR_HELP_CATEGORY):
                 category: str = getattr(func, constants.CMD_ATTR_HELP_CATEGORY)
                 cmds_cats.setdefault(category, [])
                 cmds_cats[category].append(command)
-            elif func.__doc__ or has_help_func:
+            elif func.__doc__ or has_help_func or has_parser:
                 cmds_doc.append(command)
             else:
                 cmds_undoc.append(command)
@@ -4035,11 +4014,17 @@ class Cmd(cmd.Cmd):
                 # Try to get the documentation string for each command
                 topics = self.get_help_topics()
                 for command in cmds:
-                    cmd_func = self.cmd_func(command)
+                    if (cmd_func := self.cmd_func(command)) is None:
+                        continue
+
                     doc: Optional[str]
 
+                    # If this is an argparse command, use its description.
+                    if (cmd_parser := self._command_parsers.get(cmd_func)) is not None:
+                        doc = cmd_parser.description
+
                     # Non-argparse commands can have help_functions for their documentation
-                    if command not in self._command_parsers and command in topics:
+                    elif command in topics:
                         help_func = getattr(self, constants.HELP_FUNC_PREFIX + command)
                         result = io.StringIO()
 
@@ -5436,12 +5421,13 @@ class Cmd(cmd.Cmd):
         if command not in self.disabled_commands:
             return
 
+        cmd_func_name = constants.COMMAND_FUNC_PREFIX + command
         help_func_name = constants.HELP_FUNC_PREFIX + command
         completer_func_name = constants.COMPLETER_FUNC_PREFIX + command
 
         # Restore the command function to its original value
         dc = self.disabled_commands[command]
-        setattr(self, self._cmd_func_name(command), dc.command_function)
+        setattr(self, cmd_func_name, dc.command_function)
 
         # Restore the help function to its original value
         if dc.help_function is None:
@@ -5489,6 +5475,7 @@ class Cmd(cmd.Cmd):
         if command_function is None:
             raise AttributeError(f"'{command}' does not refer to a command")
 
+        cmd_func_name = constants.COMMAND_FUNC_PREFIX + command
         help_func_name = constants.HELP_FUNC_PREFIX + command
         completer_func_name = constants.COMPLETER_FUNC_PREFIX + command
 
@@ -5503,7 +5490,7 @@ class Cmd(cmd.Cmd):
         new_func = functools.partial(
             self._report_disabled_command_usage, message_to_print=message_to_print.replace(constants.COMMAND_NAME, command)
         )
-        setattr(self, self._cmd_func_name(command), new_func)
+        setattr(self, cmd_func_name, new_func)
         setattr(self, help_func_name, new_func)
 
         # Set the completer to a function that returns a blank list

cmd2/decorators.py

@@ -346,7 +346,9 @@ def with_argparser(
             statement, parsed_arglist = cmd2_app.statement_parser.get_command_arg_list(
                 command_name, statement_arg, preserve_quotes
             )
-            arg_parser = cmd2_app._command_parsers.get(command_name, None)
+
+            # Pass cmd_wrapper instead of func, since it contains the parser info.
+            arg_parser = cmd2_app._command_parsers.get(cmd_wrapper)
             if arg_parser is None:
                 # This shouldn't be possible to reach
                 raise ValueError(f'No argument parser found for {command_name}')  # pragma: no cover

{cmd2-2.5.6.dist-info → cmd2-2.5.8.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cmd2
-Version: 2.5.6
+Version: 2.5.8
 Summary: cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python
 Author: cmd2 Contributors
 License: The MIT License (MIT)
@@ -43,43 +43,43 @@ Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.8
 Description-Content-Type: text/markdown
 License-File: LICENSE
+Requires-Dist: gnureadline; platform_system == "Darwin"
 Requires-Dist: pyperclip
+Requires-Dist: pyreadline3; platform_system == "Windows"
 Requires-Dist: wcwidth
-Requires-Dist: gnureadline ; platform_system == "Darwin"
-Requires-Dist: pyreadline3 ; platform_system == "Windows"
 Provides-Extra: build
-Requires-Dist: build ; extra == 'build'
-Requires-Dist: setuptools ; extra == 'build'
-Requires-Dist: setuptools-scm ; extra == 'build'
+Requires-Dist: build; extra == "build"
+Requires-Dist: setuptools; extra == "build"
+Requires-Dist: setuptools-scm; extra == "build"
 Provides-Extra: dev
-Requires-Dist: codecov ; extra == 'dev'
-Requires-Dist: doc8 ; extra == 'dev'
-Requires-Dist: invoke ; extra == 'dev'
-Requires-Dist: mypy ; extra == 'dev'
-Requires-Dist: pytest ; extra == 'dev'
-Requires-Dist: pytest-cov ; extra == 'dev'
-Requires-Dist: pytest-mock ; extra == 'dev'
-Requires-Dist: sphinx ; extra == 'dev'
-Requires-Dist: sphinx-autobuild ; extra == 'dev'
-Requires-Dist: sphinx-rtd-theme ; extra == 'dev'
-Requires-Dist: ruff ; extra == 'dev'
-Requires-Dist: twine ; extra == 'dev'
+Requires-Dist: codecov; extra == "dev"
+Requires-Dist: doc8; extra == "dev"
+Requires-Dist: invoke; extra == "dev"
+Requires-Dist: mypy; extra == "dev"
+Requires-Dist: pytest; extra == "dev"
+Requires-Dist: pytest-cov; extra == "dev"
+Requires-Dist: pytest-mock; extra == "dev"
+Requires-Dist: sphinx; extra == "dev"
+Requires-Dist: sphinx-autobuild; extra == "dev"
+Requires-Dist: sphinx-rtd-theme; extra == "dev"
+Requires-Dist: ruff; extra == "dev"
+Requires-Dist: twine; extra == "dev"
 Provides-Extra: docs
-Requires-Dist: setuptools ; extra == 'docs'
-Requires-Dist: setuptools-scm ; extra == 'docs'
-Requires-Dist: sphinx ; extra == 'docs'
-Requires-Dist: sphinx-autobuild ; extra == 'docs'
-Requires-Dist: sphinx-rtd-theme ; extra == 'docs'
+Requires-Dist: setuptools; extra == "docs"
+Requires-Dist: setuptools_scm; extra == "docs"
+Requires-Dist: sphinx; extra == "docs"
+Requires-Dist: sphinx-autobuild; extra == "docs"
+Requires-Dist: sphinx-rtd-theme; extra == "docs"
 Provides-Extra: test
-Requires-Dist: codecov ; extra == 'test'
-Requires-Dist: coverage ; extra == 'test'
-Requires-Dist: pytest ; extra == 'test'
-Requires-Dist: pytest-cov ; extra == 'test'
-Requires-Dist: pytest-mock ; extra == 'test'
+Requires-Dist: codecov; extra == "test"
+Requires-Dist: coverage; extra == "test"
+Requires-Dist: pytest; extra == "test"
+Requires-Dist: pytest-cov; extra == "test"
+Requires-Dist: pytest-mock; extra == "test"
 Provides-Extra: validate
-Requires-Dist: mypy ; extra == 'validate'
-Requires-Dist: ruff ; extra == 'validate'
-Requires-Dist: types-setuptools ; extra == 'validate'
+Requires-Dist: mypy; extra == "validate"
+Requires-Dist: ruff; extra == "validate"
+Requires-Dist: types-setuptools; extra == "validate"
 
 <h1 align="center">cmd2 : immersive interactive command line applications</h1>
 
@@ -89,7 +89,6 @@ Requires-Dist: types-setuptools ; extra == 'validate'
 [![Documentation Status](https://readthedocs.org/projects/cmd2/badge/?version=latest)](http://cmd2.readthedocs.io/en/latest/?badge=latest)
 <a href="https://discord.gg/RpVG6tk"><img src="https://img.shields.io/badge/chat-on%20discord-7289da.svg" alt="Chat"></a>
 
-
 <p align="center">
   <a href="#the-developers-toolbox">Developer's Toolbox</a> •
   <a href="#philosophy">Philosophy</a> •
@@ -104,17 +103,15 @@ Requires-Dist: types-setuptools ; extra == 'validate'
 
 cmd2 is a tool for building interactive command line applications in Python. Its goal is to make it
 quick and easy for developers to build feature-rich and user-friendly interactive command line
-applications.  It provides a simple API which is an extension of Python's built-in
-[cmd](https://docs.python.org/3/library/cmd.html) module.  cmd2 provides a wealth of features on top
+applications. It provides a simple API which is an extension of Python's built-in
+[cmd](https://docs.python.org/3/library/cmd.html) module. cmd2 provides a wealth of features on top
 of cmd to make your life easier and eliminates much of the boilerplate code which would be necessary
 when using cmd.
 
-The developers toolbox
-----------------------
+## The developers toolbox
 
 ![system schema](https://raw.githubusercontent.com/python-cmd2/cmd2/master/.github/images/graph.drawio.png)
 
-
 When creating solutions developers have no shortage of tools to create rich and smart user interfaces.
 System administrators have long been duct taping together brittle workflows based on a menagerie of simple command line tools created by strangers on github and the guy down the hall.
 Unfortunately, when CLIs become significantly complex the ease of command discoverability tends to fade quickly.
@@ -125,15 +122,13 @@ The price we pay for beautifully colored displays is complexity required to aggr
 The `cmd2` framework provides a great mixture of both worlds. Application designers can easily create complex applications and rely on the cmd2 library to offer effortless user facing help and extensive tab completion.
 When users become comfortable with functionality, cmd2 turns into a feature rich library enabling a smooth transition to full automation. If designed with enough forethought, a well implemented cmd2 application can serve as a boutique workflow tool. `cmd2` pulls off this flexibility based on two pillars of philosophy:
 
-* Tab Completion
-* Automation Transition
+- Tab Completion
+- Automation Transition
 
-Philosophy
--------------
+## Philosophy
 
 <a href="https://imgflip.com/i/63h03x"><img src="https://i.imgflip.com/63h03x.jpg" title="made at imgflip.com" width="70%" height="%70"/></a>
 
-
 Deep extensive tab completion and help text generation based on the argparse library create the first pillar of 'ease of command discovery'. The following is a list of features in this category.
 
 - Great tab completion of commands, subcommands, file system paths, and shell commands.
@@ -152,9 +147,8 @@ cmd2 creates the second pillar of 'ease of transition to automation' through ali
 - Powerful and flexible built-in Python scripting of your application using the `run_pyscript` command
 - Transcripts for use with built-in regression can be automatically generated from `history -t` or `run_script -t`
 
+## Installation
 
-Installation
-------------
 On all operating systems, the latest stable version of `cmd2` can be installed using pip:
 
 ```bash
@@ -167,31 +161,26 @@ For information on other installation options, see
 [Installation Instructions](https://cmd2.readthedocs.io/en/latest/overview/installation.html) in the cmd2
 documentation.
 
+## Documentation
 
-Documentation
--------------
 The latest documentation for cmd2 can be read online here: https://cmd2.readthedocs.io/en/latest/
 
 It is available in HTML, PDF, and ePub formats.
 
-
 The best way to learn the cmd2 api is to delve into the example applications located in source under examples.
 
-Tutorials
----------
-
-* PyOhio 2019 presentation:
-    * [video](https://www.youtube.com/watch?v=pebeWrTqIIw)
-    * [slides](https://github.com/python-cmd2/talks/blob/master/PyOhio_2019/cmd2-PyOhio_2019.pdf)
-    * [example code](https://github.com/python-cmd2/talks/tree/master/PyOhio_2019/examples)
-* [Cookiecutter](https://github.com/cookiecutter/cookiecutter) Templates from community
-    * Basic cookiecutter template for cmd2 application : https://github.com/jayrod/cookiecutter-python-cmd2
-    * Advanced cookiecutter template with external plugin support : https://github.com/jayrod/cookiecutter-python-cmd2-ext-plug
-* [Example Applications](https://github.com/jayrod/cmd2-example-apps)
+## Tutorials
 
+- PyOhio 2019 presentation:
+  - [video](https://www.youtube.com/watch?v=pebeWrTqIIw)
+  - [slides](https://github.com/python-cmd2/talks/blob/master/PyOhio_2019/cmd2-PyOhio_2019.pdf)
+  - [example code](https://github.com/python-cmd2/talks/tree/master/PyOhio_2019/examples)
+- [Cookiecutter](https://github.com/cookiecutter/cookiecutter) Templates from community
+  - Basic cookiecutter template for cmd2 application : https://github.com/jayrod/cookiecutter-python-cmd2
+  - Advanced cookiecutter template with external plugin support : https://github.com/jayrod/cookiecutter-python-cmd2-ext-plug
+- [Example Applications](https://github.com/jayrod/cmd2-example-apps)
 
-Hello World
------------
+## Hello World
 
 ```python
 #!/usr/bin/env python
@@ -212,36 +201,48 @@ if __name__ == '__main__':
 
 ```
 
-
-Found a bug?
-------------
-
-If you think you've found a bug, please first read through the open [Issues](https://github.com/python-cmd2/cmd2/issues). If you're confident it's a new bug, go ahead and create a new GitHub issue. Be sure to include as much information as possible so we can reproduce the bug.  At a minimum, please state the following:
-
-* ``cmd2`` version
-* Python version
-* OS name and version
-* What you did to cause the bug to occur
-* Include any traceback or error message associated with the bug
-
-
-Projects using cmd2
--------------------------------
-
-| Application Name                                                | Description                                                                                                                     |   |
-|-----------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------|---|
-| [Jok3r](http://www.jok3r-framework.com)                         | Network & Web Pentest Automation Framework                                                                                      |   |
-| [CephFS Shell](https://github.com/ceph/ceph)                    | [Ceph](https://ceph.com/) is a distributed object, block, and file storage platform                                             |   |
-| [psiTurk](https://psiturk.org)                                  | An open platform for science on Amazon Mechanical Turk                                                                          |   |
-| [Poseidon](https://github.com/CyberReboot/poseidon)             | Leverages software-defined networks (SDNs) to acquire and then feed network traffic to a number of machine learning techniques. |   |
-| [Unipacker](https://github.com/unipacker/unipacker)             | Automatic and platform-independent unpacker for Windows binaries based on emulation                                             |   |
-| [tomcatmanager](https://github.com/tomcatmanager/tomcatmanager) | A command line tool and python library for managing a tomcat server                                                             |   |
-| [Expliot](https://gitlab.com/expliot_framework/expliot)         | Internet of Things (IoT) exploitation framework                                                                                 |   |
-| [mptcpanalyzer]()                                               | Tool to help analyze mptcp pcaps                                                                                                |   |
-| [clanvas](https://github.com/marklalor/clanvas)                 | Command-line client for Canvas by Instructure                                                                                   |   |
-
+## Found a bug?
+
+If you think you've found a bug, please first read through the open [Issues](https://github.com/python-cmd2/cmd2/issues). If you're confident it's a new bug, go ahead and create a new GitHub issue. Be sure to include as much information as possible so we can reproduce the bug. At a minimum, please state the following:
+
+- `cmd2` version
+- Python version
+- OS name and version
+- What you did to cause the bug to occur
+- Include any traceback or error message associated with the bug
+
+## Projects using cmd2
+
+| Application Name                                                | Description                                                                                                                     | Organization or Author                                                |
+| --------------------------------------------------------------- | ------------------------------------------------------------------------------------------------------------------------------- | --------------------------------------------------------------------- |
+| [CephFS Shell](https://github.com/ceph/ceph)                    | The Ceph File System, or CephFS, is a POSIX-compliant file system built on top of Ceph’s distributed object store               | [ceph](https://ceph.com/)                                             |
+| [garak](https://github.com/NVIDIA/garak)                        | LLM vulnerability scanner that checks if an LLM can be made to fail in a way we don't want                                      | [NVIDIA](https://github.com/NVIDIA)                                   |
+| [medusa](https://github.com/Ch0pin/medusa)                      | Binary instrumentation framework that that automates processes for the dynamic analysis of Android and iOS Applications         | [Ch0pin](https://github.com/Ch0pin)                                   |
+| [InternalBlue](https://github.com/seemoo-lab/internalblue)      | Bluetooth experimentation framework for Broadcom and Cypress chips                                                              | [Secure Mobile Networking Lab](https://github.com/seemoo-lab)         |
+| [SCCMHunter](https://github.com/garrettfoster13/sccmhunter)     | A post-ex tool built to streamline identifying, profiling, and attacking SCCM related assets in an Active Directory domain      | [Garret Foster](https://github.com/garrettfoster13)                   |
+| [Unipacker](https://github.com/unipacker/unipacker)             | Automatic and platform-independent unpacker for Windows binaries based on emulation                                             | [unipacker](https://github.com/unipacker)                             |
+| [Frankenstein](https://github.com/seemoo-lab/frankenstein)      | Broadcom and Cypress firmware emulation for fuzzing and further full-stack debugging                                            | [Secure Mobile Networking Lab](https://github.com/seemoo-lab)         |
+| [Poseidon](https://github.com/faucetsdn/poseidon)               | Leverages software-defined networks (SDNs) to acquire and then feed network traffic to a number of machine learning techniques. | [Faucet SDN](https://github.com/faucetsdn)                            |
+| [DFTimewolf](https://github.com/log2timeline/dftimewolf)        | A framework for orchestrating forensic collection, processing and data export                                                   | [log2timeline](https://github.com/log2timeline)                       |
+| [GAP SDK](https://github.com/GreenWaves-Technologies/gap_sdk)   | SDK for Greenwaves Technologies' GAP8 IoT Application Processor                                                                 | [GreenWaves Technologies](https://github.com/GreenWaves-Technologies) |
+| [REW Sploit](https://github.com/REW-sploit/REW-sploit)          | Emulate and Dissect Metasploit Framework (MSF) and other attacks                                                                | [REW-sploit](https://github.com/REW-sploit)                           |
+| [tomcatmanager](https://github.com/tomcatmanager/tomcatmanager) | A command line tool and python library for managing a tomcat server                                                             | [tomcatmanager](https://github.com/tomcatmanager)                     |
+| [Falcon Toolkit](https://github.com/CrowdStrike/Falcon-Toolkit) | Unleash the power of the CrowdStrike Falcon Platform at the CLI                                                                 | [CrowdStrike](https://github.com/CrowdStrike)                         |
+| [EXPLIoT](https://gitlab.com/expliot_framework/expliot)         | Internet of Things Security Testing and Exploitation framework                                                                  | [expliot_framework](https://gitlab.com/expliot_framework/)            |
 
 Possibly defunct but still good examples
 
-* [JSShell](https://github.com/Den1al/JSShell)
-* [FLASHMINGO](https://github.com/fireeye/flashmingo)
+| Application Name                                                              | Description                                                                            | Organization or Author                                         |
+| ----------------------------------------------------------------------------- | -------------------------------------------------------------------------------------- | -------------------------------------------------------------- |
+| [Katana](https://github.com/JohnHammond/katana)                               | Automatic CTF Challenge Solver                                                         | [John Hammond](https://github.com/JohnHammond)                 |
+| [SatanSword](https://github.com/Lucifer1993/SatanSword) (in Chinese)          | Comprehensive Penetration Framework for Red Teaming                                    | [Lucifer1993](https://github.com/Lucifer1993)                  |
+| [Jok3r](http://www.jok3r-framework.com)                                       | Network & Web Pentest Automation Framework                                             | [Koutto](https://github.com/koutto)                            |
+| [Counterfit](https://github.com/Azure/counterfit)                             | a CLI that provides a generic automation layer for assessing the security of ML models | [Microsoft Azure](https://github.com/Azure)                    |
+| [Overlord](https://github.com/qsecure-labs/overlord)                          | Red Teaming Infrastructure Automation                                                  | [QSecure Labs](https://github.com/qsecure-labs)                |
+| [Automated Reconnaissance Pipeline](https://github.com/epi052/recon-pipeline) | An automated target reconnaissance pipeline                                            | [epi052](https://github.com/epi052)                            |
+| [JSShell](https://github.com/Den1al/JSShell)                                  | An interactive multi-user web JavaScript (JS) shell                                    | [Den1al](https://github.com/Den1al)                            |
+| [RedShell](https://github.com/Verizon/redshell)                               | An interactive command prompt for red teaming and pentesting                           | [Verizon](https://github.com/Verizon)                          |
+| [FLASHMINGO](https://github.com/mandiant/flashmingo)                          | Automatic analysis of SWF files based on some heuristics. Extensible via plugins.      | [Mandiant](https://github.com/mandiant)                        |
+| [psiTurk](https://github.com/NYUCCL/psiTurk)                                  | An open platform for science on Amazon Mechanical Turk                                 | [NYU Computation and Cognition Lab](https://github.com/NYUCCL) |
+
+Note: If you have created an application based on `cmd2` that you would like us to mention here, please get in touch.

{cmd2-2.5.6.dist-info → cmd2-2.5.8.dist-info}/RECORD

@@ -1,12 +1,12 @@
 cmd2/__init__.py,sha256=C6IHJ_uHgkqejuRwA10IK0-OzPxHKyZbPn82nMUwn-A,2602
-cmd2/ansi.py,sha256=BasPj_Wla0cEyjpe_zu-cn24CgVdSXK3sfxknLM1WcY,32203
+cmd2/ansi.py,sha256=DD1yVk4EnbKSmGM9Tj8jxWv23UZBVjbhdf0oOVhhl_c,32054
 cmd2/argparse_completer.py,sha256=6z0zmODqM7vhQhI0c6JUvCmR2V4qfdWQEyTZeNIea8c,36505
 cmd2/argparse_custom.py,sha256=bbAYRr79ZSJWGchd7trmRQDHWAsSJaW0dTQMp65Mrv4,57806
 cmd2/clipboard.py,sha256=7EISono76d7djj17hbvR9cCTB7jVGSBkUjgVQiMyUjE,549
-cmd2/cmd2.py,sha256=_u8AqoPQ_3kydZOT_PJOb46qRqtHGKoUwN_g9mSwFfU,261510
+cmd2/cmd2.py,sha256=--45LzbUB5vLrrHYPV_pSQK3H9ePAacb4lBlXBQfB1A,261355
 cmd2/command_definition.py,sha256=OscFEk-O2N20fb8_fhkczqclaCxOwYyxNTnXWXOlngg,7655
 cmd2/constants.py,sha256=DioxETv-_HzcMUnjuPyz7Cqw4YEt_MTrzOMotiHj-Jo,1981
-cmd2/decorators.py,sha256=tNVvNyOR6uZW_bkU1ti13bBDNKbN5V-AJtbTns_aSOQ,19743
+cmd2/decorators.py,sha256=XXQKqei5CVM6k5zt8CdBmIDan-QwuN3YgJiaIsabbuA,19820
 cmd2/exceptions.py,sha256=DwX7rQmon4eRyX1ZK4yne4lObdPO1j5Agg3Bav6pXwU,3600
 cmd2/history.py,sha256=GkJ3pZQNGNoXa9pYLul_iaqLeK132V5nLZZG6MsIEus,15000
 cmd2/parsing.py,sha256=zWG_iDjUU6TWVNwMeY-yn6AIa2jx12Q9ey4DA9DGZFc,28272
@@ -17,8 +17,8 @@ cmd2/rl_utils.py,sha256=HVPdNjuYyU67-XerPUJArmzhohzI1ABrZhU9cLc-EIs,11538
 cmd2/table_creator.py,sha256=qoxt9s3MxQkfSkp4cIPFMlVzC7kRjUU55p0ow7pFQus,47544
 cmd2/transcript.py,sha256=I0sD38RbG79Qz9GXIlfh1pHSNmWBTY2SLZAKEdSLWI4,9182
 cmd2/utils.py,sha256=4eBvbG6yqe3wg9wwi2jdng2iy5gghueNQjuF2afSyuI,49385
-cmd2-2.5.6.dist-info/LICENSE,sha256=QXrW0Z0merk9mncyUkn-sgRxhT8_o1dL5HEaBNH47Q4,1099
-cmd2-2.5.6.dist-info/METADATA,sha256=8_-ALhxdH1tG6ZonYNcVZJ5wdpMCZ5sTj4Ka2axdLDM,13308
-cmd2-2.5.6.dist-info/WHEEL,sha256=R06PA3UVYHThwHvxuRWMqaGcr-PuniXahwjmQRFMEkY,91
-cmd2-2.5.6.dist-info/top_level.txt,sha256=gJbOJmyrARwLhm5diXAtzlNQdxbDZ8iRJ8HJi65_5hg,5
-cmd2-2.5.6.dist-info/RECORD,,
+cmd2-2.5.8.dist-info/LICENSE,sha256=QXrW0Z0merk9mncyUkn-sgRxhT8_o1dL5HEaBNH47Q4,1099
+cmd2-2.5.8.dist-info/METADATA,sha256=-y-uEodZc06B7Akuvlb5oRWVfaTmuUqjwJZ4kGuvR_I,18098
+cmd2-2.5.8.dist-info/WHEEL,sha256=PZUExdf71Ui_so67QXpySuHtCi3-J3wvF4ORK6k_S8U,91
+cmd2-2.5.8.dist-info/top_level.txt,sha256=gJbOJmyrARwLhm5diXAtzlNQdxbDZ8iRJ8HJi65_5hg,5
+cmd2-2.5.8.dist-info/RECORD,,

{cmd2-2.5.6.dist-info → cmd2-2.5.8.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: setuptools (75.5.0)
+Generator: setuptools (75.6.0)
 Root-Is-Purelib: true
 Tag: py3-none-any