cmd2 2.4.2__py3-none-any.whl → 2.5.0__py3-none-any.whl

cmd2/cmd2.py

@@ -21,6 +21,7 @@ is used in place of `print`.
 
 Git repository on GitHub at https://github.com/python-cmd2/cmd2
 """
+
 # This module has many imports, quite a few of which are only
 # infrequently utilized. To reduce the initial overhead of
 # import this module, many of these imports are lazy-loaded
@@ -30,6 +31,7 @@ Git repository on GitHub at https://github.com/python-cmd2/cmd2
 # setting is True
 import argparse
 import cmd
+import copy
 import functools
 import glob
 import inspect
@@ -37,6 +39,7 @@ import os
 import pydoc
 import re
 import sys
+import tempfile
 import threading
 from code import (
     InteractiveConsole,
@@ -53,6 +56,8 @@ from types import (
     ModuleType,
 )
 from typing import (
+    IO,
+    TYPE_CHECKING,
     Any,
     Callable,
     Dict,
@@ -83,7 +88,6 @@ from .argparse_custom import (
     CompletionItem,
 )
 from .clipboard import (
-    can_clip,
     get_paste_buffer,
     write_to_paste_buffer,
 )
@@ -98,6 +102,7 @@ from .constants import (
     HELP_FUNC_PREFIX,
 )
 from .decorators import (
+    CommandParent,
     as_subcommand_to,
     with_argparser,
 )
@@ -114,6 +119,7 @@ from .exceptions import (
 from .history import (
     History,
     HistoryItem,
+    single_line_format,
 )
 from .parsing import (
     Macro,
@@ -125,8 +131,10 @@ from .parsing import (
 from .rl_utils import (
     RlType,
     rl_escape_prompt,
+    rl_get_display_prompt,
     rl_get_point,
     rl_get_prompt,
+    rl_in_search_mode,
     rl_set_prompt,
     rl_type,
     rl_warning,
@@ -140,6 +148,7 @@ from .utils import (
     Settable,
     get_defining_class,
     strip_doc_annotations,
+    suggest_similar,
 )
 
 # Set up readline
@@ -155,13 +164,10 @@ else:
     orig_rl_delims = readline.get_completer_delims()
 
     if rl_type == RlType.PYREADLINE:
-
         # Save the original pyreadline3 display completion function since we need to override it and restore it
-        # noinspection PyProtectedMember,PyUnresolvedReferences
         orig_pyreadline_display = readline.rl.mode._display_completions
 
     elif rl_type == RlType.GNU:
-
         # Get the readline lib so we can make changes to it
         import ctypes
 
@@ -197,6 +203,14 @@ class _SavedCmd2Env:
 DisabledCommand = namedtuple('DisabledCommand', ['command_function', 'help_function', 'completer_function'])
 
 
+if TYPE_CHECKING:  # pragma: no cover
+    StaticArgParseBuilder = staticmethod[[], argparse.ArgumentParser]
+    ClassArgParseBuilder = classmethod[Union['Cmd', CommandSet], [], argparse.ArgumentParser]
+else:
+    StaticArgParseBuilder = staticmethod
+    ClassArgParseBuilder = classmethod
+
+
 class Cmd(cmd.Cmd):
     """An easy but powerful framework for writing line-oriented command interpreters.
 
@@ -236,6 +250,8 @@ class Cmd(cmd.Cmd):
         shortcuts: Optional[Dict[str, str]] = None,
         command_sets: Optional[Iterable[CommandSet]] = None,
         auto_load_commands: bool = True,
+        allow_clipboard: bool = True,
+        suggest_similar_command: bool = False,
     ) -> None:
         """An easy but powerful framework for writing line-oriented command
         interpreters. Extends Python's cmd package.
@@ -283,6 +299,10 @@ class Cmd(cmd.Cmd):
                                    that are currently loaded by Python and automatically
                                    instantiate and register all commands. If False, CommandSets
                                    must be manually installed with `register_command_set`.
+        :param allow_clipboard: If False, cmd2 will disable clipboard interactions
+        :param suggest_similar_command: If ``True``, ``cmd2`` will attempt to suggest the most
+                                        similar command when the user types a command that does
+                                        not exist. Default: ``False``.
         """
         # Check if py or ipy need to be disabled in this instance
         if not include_py:
@@ -308,6 +328,7 @@ class Cmd(cmd.Cmd):
         self.editor = Cmd.DEFAULT_EDITOR
         self.feedback_to_output = False  # Do not include nonessentials in >, | output by default (things like timing)
         self.quiet = False  # Do not suppress nonessential output
+        self.scripts_add_to_history = True  # Scripts and pyscripts add commands to history
         self.timing = False  # Prints elapsed time for each command
 
         # The maximum number of CompletionItems to display during tab completion. If the number of completion
@@ -335,6 +356,7 @@ class Cmd(cmd.Cmd):
         self.hidden_commands = ['eof', '_relative_run_script']
 
         # Initialize history
+        self.persistent_history_file = ''
         self._persistent_history_length = persistent_history_length
         self._initialize_history(persistent_history_file)
 
@@ -389,7 +411,7 @@ class Cmd(cmd.Cmd):
         self.help_error = "No help on {}"
 
         # The error that prints when a non-existent command is run
-        self.default_error = "{} is not a recognized command, alias, or macro"
+        self.default_error = "{} is not a recognized command, alias, or macro."
 
         # If non-empty, this string will be displayed if a broken pipe error occurs
         self.broken_pipe_warning = ''
@@ -436,8 +458,8 @@ class Cmd(cmd.Cmd):
             self.pager = 'less -RXF'
             self.pager_chop = 'less -SRXF'
 
-        # This boolean flag determines whether or not the cmd2 application can interact with the clipboard
-        self._can_clip = can_clip
+        # This boolean flag stores whether cmd2 will allow clipboard related features
+        self.allow_clipboard = allow_clipboard
 
         # This determines the value returned by cmdloop() when exiting the application
         self.exit_code = 0
@@ -507,6 +529,16 @@ class Cmd(cmd.Cmd):
         # This does not affect self.formatted_completions.
         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]
+
+        # Add functions decorated to be subcommands
+        self._register_subcommands(self)
+
         ############################################################################################################
         # The following code block loads CommandSets, verifies command names, and registers subcommands.
         # This block should appear after all attributes have been created since the registration code
@@ -526,8 +558,11 @@ class Cmd(cmd.Cmd):
             if not valid:
                 raise ValueError(f"Invalid command name '{cur_cmd}': {errmsg}")
 
-        # Add functions decorated to be subcommands
-        self._register_subcommands(self)
+        self.suggest_similar_command = suggest_similar_command
+        self.default_suggestion_message = "Did you mean {}?"
+
+        # the current command being executed
+        self.current_command: Optional[Statement] = None
 
     def find_commandsets(self, commandset_type: Type[CommandSet], *, subclass_match: bool = False) -> List[CommandSet]:
         """
@@ -541,7 +576,7 @@ class Cmd(cmd.Cmd):
         return [
             cmdset
             for cmdset in self._installed_command_sets
-            if type(cmdset) == commandset_type or (subclass_match and isinstance(cmdset, commandset_type))
+            if type(cmdset) == commandset_type or (subclass_match and isinstance(cmdset, commandset_type))  # noqa: E721
         ]
 
     def find_commandset_for_command(self, command_name: str) -> Optional[CommandSet]:
@@ -601,11 +636,14 @@ class Cmd(cmd.Cmd):
                     raise CommandSetRegistrationError(f'Duplicate settable {key} is already registered')
 
         cmdset.on_register(self)
-        methods = inspect.getmembers(
-            cmdset,
-            predicate=lambda meth: isinstance(meth, Callable)  # type: ignore[arg-type]
-            and hasattr(meth, '__name__')
-            and meth.__name__.startswith(COMMAND_FUNC_PREFIX),
+        methods = cast(
+            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),
+            ),
         )
 
         default_category = getattr(cmdset, CLASS_ATTR_DEFAULT_HELP_CATEGORY, None)
@@ -650,6 +688,50 @@ class Cmd(cmd.Cmd):
             cmdset.on_unregistered()
             raise
 
+    def _build_parser(
+        self,
+        parent: CommandParent,
+        parser_builder: Optional[
+            Union[
+                argparse.ArgumentParser,
+                Callable[[], argparse.ArgumentParser],
+                StaticArgParseBuilder,
+                ClassArgParseBuilder,
+            ]
+        ],
+    ) -> Optional[argparse.ArgumentParser]:
+        parser: Optional[argparse.ArgumentParser] = None
+        if isinstance(parser_builder, staticmethod):
+            parser = parser_builder.__func__()
+        elif isinstance(parser_builder, classmethod):
+            parser = parser_builder.__func__(parent if not None else self)  # type: ignore[arg-type]
+        elif callable(parser_builder):
+            parser = parser_builder()
+        elif isinstance(parser_builder, argparse.ArgumentParser):
+            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,
+            )
+
+            _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._command_parsers[command] = parser
+
     def _install_command_function(self, command: str, command_wrapper: Callable[..., Any], context: str = '') -> None:
         cmd_func_name = COMMAND_FUNC_PREFIX + command
 
@@ -672,6 +754,8 @@ 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)
 
     def _install_completer_function(self, cmd_name: str, cmd_completer: CompleterFunc) -> None:
@@ -699,7 +783,7 @@ class Cmd(cmd.Cmd):
             cmdset.on_unregister()
             self._unregister_subcommands(cmdset)
 
-            methods = inspect.getmembers(
+            methods: List[Tuple[str, Callable[[Any], Any]]] = inspect.getmembers(
                 cmdset,
                 predicate=lambda meth: isinstance(meth, Callable)  # type: ignore[arg-type]
                 and hasattr(meth, '__name__')
@@ -718,6 +802,8 @@ class Cmd(cmd.Cmd):
                     del self._cmd_to_command_sets[cmd_name]
 
                 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 + cmd_name):
                     delattr(self, COMPLETER_FUNC_PREFIX + cmd_name)
@@ -728,7 +814,7 @@ class Cmd(cmd.Cmd):
             self._installed_command_sets.remove(cmdset)
 
     def _check_uninstallable(self, cmdset: CommandSet) -> None:
-        methods = inspect.getmembers(
+        methods: List[Tuple[str, Callable[[Any], Any]]] = inspect.getmembers(
             cmdset,
             predicate=lambda meth: isinstance(meth, Callable)  # type: ignore[arg-type]
             and hasattr(meth, '__name__')
@@ -737,14 +823,7 @@ class Cmd(cmd.Cmd):
 
         for method in methods:
             command_name = method[0][len(COMMAND_FUNC_PREFIX) :]
-
-            # Search for the base command function and verify it has an argparser defined
-            if command_name in self.disabled_commands:
-                command_func = self.disabled_commands[command_name].command_function
-            else:
-                command_func = self.cmd_func(command_name)
-
-            command_parser = cast(argparse.ArgumentParser, getattr(command_func, constants.CMD_ATTR_ARGPARSER, None))
+            command_parser = self._command_parsers.get(command_name, None)
 
             def check_parser_uninstallable(parser: argparse.ArgumentParser) -> None:
                 for action in parser._actions:
@@ -783,7 +862,7 @@ class Cmd(cmd.Cmd):
         for method_name, method in methods:
             subcommand_name: str = getattr(method, constants.SUBCMD_ATTR_NAME)
             full_command_name: str = getattr(method, constants.SUBCMD_ATTR_COMMAND)
-            subcmd_parser = getattr(method, constants.CMD_ATTR_ARGPARSER)
+            subcmd_parser_builder = getattr(method, constants.CMD_ATTR_ARGPARSER)
 
             subcommand_valid, errmsg = self.statement_parser.is_valid_command(subcommand_name, is_subcommand=True)
             if not subcommand_valid:
@@ -803,7 +882,7 @@ class Cmd(cmd.Cmd):
                 raise CommandSetRegistrationError(
                     f"Could not find command '{command_name}' needed by subcommand: {str(method)}"
                 )
-            command_parser = getattr(command_func, constants.CMD_ATTR_ARGPARSER, None)
+            command_parser = self._command_parsers.get(command_name, None)
             if command_parser is None:
                 raise CommandSetRegistrationError(
                     f"Could not find argparser for command '{command_name}' needed by subcommand: {str(method)}"
@@ -823,16 +902,17 @@ class Cmd(cmd.Cmd):
 
             target_parser = find_subcommand(command_parser, subcommand_names)
 
+            subcmd_parser = cast(argparse.ArgumentParser, self._build_parser(cmdset, subcmd_parser_builder))
+            from .decorators import (
+                _set_parser_prog,
+            )
+
+            _set_parser_prog(subcmd_parser, f'{command_name} {subcommand_name}')
+            if subcmd_parser.description is None and method.__doc__:
+                subcmd_parser.description = strip_doc_annotations(method.__doc__)
+
             for action in target_parser._actions:
                 if isinstance(action, argparse._SubParsersAction):
-                    # Temporary workaround for avoiding subcommand help text repeatedly getting added to
-                    # action._choices_actions. Until we have instance-specific parser objects, we will remove
-                    # any existing subcommand which has the same name before replacing it. This problem is
-                    # exercised when more than one cmd2.Cmd-based object is created and the same subcommands
-                    # get added each time. Argparse overwrites the previous subcommand but keeps growing the help
-                    # text which is shown by running something like 'alias -h'.
-                    action.remove_parser(subcommand_name)  # type: ignore[arg-type,attr-defined]
-
                     # Get the kwargs for add_parser()
                     add_parser_kwargs = getattr(method, constants.SUBCMD_ATTR_ADD_PARSER_KWARGS, {})
 
@@ -904,7 +984,7 @@ class Cmd(cmd.Cmd):
                 raise CommandSetRegistrationError(
                     f"Could not find command '{command_name}' needed by subcommand: {str(method)}"
                 )
-            command_parser = getattr(command_func, constants.CMD_ATTR_ARGPARSER, None)
+            command_parser = self._command_parsers.get(command_name, None)
             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
@@ -1012,12 +1092,7 @@ class Cmd(cmd.Cmd):
         )
 
         self.add_settable(
-            Settable(
-                'always_show_hint',
-                bool,
-                'Display tab completion hint even when completion suggestions print',
-                self,
-            )
+            Settable('always_show_hint', bool, 'Display tab completion hint even when completion suggestions print', self)
         )
         self.add_settable(Settable('debug', bool, "Show full traceback on exception", self))
         self.add_settable(Settable('echo', bool, "Echo command issued into output", self))
@@ -1027,6 +1102,7 @@ class Cmd(cmd.Cmd):
             Settable('max_completion_items', int, "Maximum number of CompletionItems to display during tab completion", self)
         )
         self.add_settable(Settable('quiet', bool, "Don't print nonessential feedback", self))
+        self.add_settable(Settable('scripts_add_to_history', bool, 'Scripts and pyscripts add commands to history', self))
         self.add_settable(Settable('timing', bool, "Report execution times", self))
 
     # -----  Methods related to presenting output to the user -----
@@ -1056,7 +1132,40 @@ class Cmd(cmd.Cmd):
         """
         return ansi.strip_style(self.prompt)
 
-    def poutput(self, msg: Any = '', *, end: str = '\n') -> None:
+    def print_to(
+        self,
+        dest: Union[TextIO, IO[str]],
+        msg: Any,
+        *,
+        end: str = '\n',
+        style: Optional[Callable[[str], str]] = None,
+        paged: bool = False,
+        chop: bool = False,
+    ) -> None:
+        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)
+
+    def poutput(
+        self,
+        msg: Any = '',
+        *,
+        end: str = '\n',
+        apply_style: bool = True,
+        paged: bool = False,
+        chop: bool = False,
+    ) -> None:
         """Print message to self.stdout and appends a newline by default
 
         Also handles BrokenPipeError exceptions for when a command's output has
@@ -1065,44 +1174,83 @@ class Cmd(cmd.Cmd):
 
         :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.
         """
-        try:
-            ansi.style_aware_write(self.stdout, f"{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)
+        self.print_to(self.stdout, msg, end=end, style=ansi.style_output if apply_style else None, paged=paged, chop=chop)
 
-    # noinspection PyMethodMayBeStatic
-    def perror(self, msg: Any = '', *, end: str = '\n', apply_style: bool = True) -> None:
+    def perror(
+        self,
+        msg: Any = '',
+        *,
+        end: str = '\n',
+        apply_style: bool = True,
+        paged: bool = False,
+        chop: bool = False,
+    ) -> 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.
         """
-        if apply_style:
-            final_msg = ansi.style_error(msg)
-        else:
-            final_msg = str(msg)
-        ansi.style_aware_write(sys.stderr, final_msg + end)
+        self.print_to(sys.stderr, msg, end=end, style=ansi.style_error if apply_style else None, paged=paged, chop=chop)
 
-    def pwarning(self, msg: Any = '', *, end: str = '\n', apply_style: bool = True) -> 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
+
+        :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)
+
+    def pwarning(
+        self,
+        msg: Any = '',
+        *,
+        end: str = '\n',
+        paged: bool = False,
+        chop: bool = False,
+    ) -> 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 apply_style: If True, then ansi.style_warning 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 apply_style:
-            msg = ansi.style_warning(msg)
-        self.perror(msg, end=end, apply_style=False)
+        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)
 
     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.
@@ -1131,23 +1279,39 @@ class Cmd(cmd.Cmd):
 
         self.perror(final_msg, end=end, apply_style=False)
 
-    def pfeedback(self, msg: Any, *, end: str = '\n') -> None:
+    def pfeedback(
+        self,
+        msg: Any,
+        *,
+        end: str = '\n',
+        apply_style: bool = True,
+        paged: bool = False,
+        chop: bool = False,
+    ) -> 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:
-            if self.feedback_to_output:
-                self.poutput(msg, end=end)
-            else:
-                self.perror(msg, end=end, apply_style=False)
+            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,
+            )
 
-    def ppaged(self, msg: Any, *, end: str = '\n', chop: bool = False) -> None:
+    def ppaged(self, msg: Any, *, end: str = '\n', chop: bool = False, dest: Optional[Union[TextIO, IO[str]]] = None) -> None:
         """Print output using a pager if it would go off screen and stdout isn't currently being redirected.
 
-        Never uses a pager inside of a script (Python or text) or when output is being redirected or piped or when
+        Never uses a pager inside a script (Python or text) or when output is being redirected or piped or when
         stdout or stdin are not a fully functional terminal.
 
         :param msg: object to print
@@ -1157,11 +1321,13 @@ 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 == '':
@@ -1195,7 +1361,7 @@ class Cmd(cmd.Cmd):
                     pipe_proc = subprocess.Popen(pager, shell=True, stdin=subprocess.PIPE)
                     pipe_proc.communicate(msg_str.encode('utf-8', 'replace'))
             else:
-                self.poutput(msg_str, end=end)
+                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
@@ -1222,7 +1388,6 @@ class Cmd(cmd.Cmd):
         if rl_type == RlType.GNU:
             readline.set_completion_display_matches_hook(self._display_matches_gnu_readline)
         elif rl_type == RlType.PYREADLINE:
-            # noinspection PyUnresolvedReferences
             readline.rl.mode._display_completions = self._display_matches_pyreadline
 
     def tokens_for_completion(self, line: str, begidx: int, endidx: int) -> Tuple[List[str], List[str]]:
@@ -1289,7 +1454,6 @@ class Cmd(cmd.Cmd):
 
         return tokens, raw_tokens
 
-    # noinspection PyMethodMayBeStatic, PyUnusedLocal
     def basic_complete(
         self,
         text: str,
@@ -1480,7 +1644,6 @@ class Cmd(cmd.Cmd):
 
         return matches
 
-    # noinspection PyUnusedLocal
     def path_complete(
         self, text: str, line: str, begidx: int, endidx: int, *, path_filter: Optional[Callable[[str], bool]] = None
     ) -> List[str]:
@@ -1498,7 +1661,6 @@ class Cmd(cmd.Cmd):
 
         # Used to complete ~ and ~user strings
         def complete_users() -> List[str]:
-
             users = []
 
             # Windows lacks the pwd module so we can't get a list of users.
@@ -1516,10 +1678,8 @@ class Cmd(cmd.Cmd):
 
                 # Iterate through a list of users from the password database
                 for cur_pw in pwd.getpwall():
-
                     # Check if the user has an existing home dir
                     if os.path.isdir(cur_pw.pw_dir):
-
                         # Add a ~ to the user to match against text
                         cur_user = '~' + cur_pw.pw_name
                         if cur_user.startswith(text):
@@ -1605,7 +1765,6 @@ class Cmd(cmd.Cmd):
 
             # Build display_matches and add a slash to directories
             for index, cur_match in enumerate(matches):
-
                 # Display only the basename of this path in the tab completion suggestions
                 self.display_matches.append(os.path.basename(cur_match))
 
@@ -1674,7 +1833,6 @@ class Cmd(cmd.Cmd):
 
         # Must at least have the command
         if len(raw_tokens) > 1:
-
             # True when command line contains any redirection tokens
             has_redirection = False
 
@@ -1766,7 +1924,6 @@ class Cmd(cmd.Cmd):
         :param longest_match_length: longest printed length of the matches
         """
         if rl_type == RlType.GNU:
-
             # Print hint if one exists and we are supposed to display it
             hint_printed = False
             if self.always_show_hint and self.completion_hint:
@@ -1806,7 +1963,6 @@ class Cmd(cmd.Cmd):
 
                 # rl_display_match_list() expects matches to be in argv format where
                 # substitution is the first element, followed by the matches, and then a NULL.
-                # noinspection PyCallingNonCallable,PyTypeChecker
                 strings_array = cast(List[Optional[bytes]], (ctypes.c_char_p * (1 + len(encoded_matches) + 1))())
 
                 # Copy in the encoded strings and add a NULL to the end
@@ -1826,7 +1982,6 @@ class Cmd(cmd.Cmd):
         :param matches: the tab completion matches to display
         """
         if rl_type == RlType.PYREADLINE:
-
             # Print hint if one exists and we are supposed to display it
             hint_printed = False
             if self.always_show_hint and self.completion_hint:
@@ -1865,9 +2020,8 @@ class Cmd(cmd.Cmd):
         :param parser: the parser to examine
         :return: type of ArgparseCompleter
         """
-        completer_type: Optional[
-            Type[argparse_completer.ArgparseCompleter]
-        ] = parser.get_ap_completer_type()  # type: ignore[attr-defined]
+        Completer = Optional[Type[argparse_completer.ArgparseCompleter]]
+        completer_type: Completer = parser.get_ap_completer_type()  # type: ignore[attr-defined]
 
         if completer_type is None:
             completer_type = argparse_completer.DEFAULT_AP_COMPLETER
@@ -1898,11 +2052,14 @@ class Cmd(cmd.Cmd):
 
             expanded_line = statement.command_and_args
 
-            # We overwrote line with a properly formatted but fully stripped version
-            # Restore the end spaces since line is only supposed to be lstripped when
-            # passed to completer functions according to Python docs
-            rstripped_len = len(line) - len(line.rstrip())
-            expanded_line += ' ' * rstripped_len
+            if not expanded_line[-1:].isspace():
+                # Unquoted trailing whitespace gets stripped by parse_command_only().
+                # Restore it since line is only supposed to be lstripped when passed
+                # to completer functions according to the Python cmd docs. Regardless
+                # of what type of whitespace (' ', \n) was stripped, just append spaces
+                # since shlex treats whitespace characters the same when splitting.
+                rstripped_len = len(line) - len(line.rstrip())
+                expanded_line += ' ' * rstripped_len
 
             # Fix the index values if expanded_line has a different size than line
             if len(expanded_line) != len(line):
@@ -1934,7 +2091,7 @@ class Cmd(cmd.Cmd):
                 else:
                     # There's no completer function, next see if the command uses argparse
                     func = self.cmd_func(command)
-                    argparser: Optional[argparse.ArgumentParser] = getattr(func, constants.CMD_ATTR_ARGPARSER, None)
+                    argparser = self._command_parsers.get(command, None)
 
                     if func is not None and argparser is not None:
                         # Get arguments for complete()
@@ -1980,7 +2137,6 @@ class Cmd(cmd.Cmd):
 
         # Check if the token being completed has an opening quote
         if raw_completion_token and raw_completion_token[0] in constants.QUOTES:
-
             # Since the token is still being completed, we know the opening quote is unclosed.
             # Save the quote so we can add a matching closing quote later.
             completion_token_quote = raw_completion_token[0]
@@ -2005,7 +2161,6 @@ class Cmd(cmd.Cmd):
         self.completion_matches = self._redirect_complete(text, line, begidx, endidx, completer_func)
 
         if self.completion_matches:
-
             # Eliminate duplicates
             self.completion_matches = utils.remove_duplicates(self.completion_matches)
             self.display_matches = utils.remove_duplicates(self.display_matches)
@@ -2020,7 +2175,6 @@ class Cmd(cmd.Cmd):
 
             # Check if we need to add an opening quote
             if not completion_token_quote:
-
                 add_quote = False
 
                 # This is the tab completion text that will appear on the command line.
@@ -2073,7 +2227,6 @@ class Cmd(cmd.Cmd):
         :param custom_settings: used when not tab completing the main command line
         :return: the next possible completion for text or None
         """
-        # noinspection PyBroadException
         try:
             if state == 0:
                 self._reset_completion_defaults()
@@ -2081,7 +2234,7 @@ class Cmd(cmd.Cmd):
                 # Check if we are completing a multiline command
                 if self._at_continuation_prompt:
                     # lstrip and prepend the previously typed portion of this multiline command
-                    lstripped_previous = self._multiline_in_progress.lstrip().replace(constants.LINE_FEED, ' ')
+                    lstripped_previous = self._multiline_in_progress.lstrip()
                     line = lstripped_previous + readline.get_line_buffer()
 
                     # Increment the indexes to account for the prepended text
@@ -2103,7 +2256,7 @@ class Cmd(cmd.Cmd):
                 # from text and update the indexes. This only applies if we are at the beginning of the command line.
                 shortcut_to_restore = ''
                 if begidx == 0 and custom_settings is None:
-                    for (shortcut, _) in self.statement_parser.shortcuts:
+                    for shortcut, _ in self.statement_parser.shortcuts:
                         if text.startswith(shortcut):
                             # Save the shortcut to restore later
                             shortcut_to_restore = shortcut
@@ -2251,14 +2404,13 @@ class Cmd(cmd.Cmd):
         # Filter out hidden and disabled commands
         return [topic for topic in all_topics if topic not in self.hidden_commands and topic not in self.disabled_commands]
 
-    # noinspection PyUnusedLocal
-    def sigint_handler(self, signum: int, _: FrameType) -> None:
+    def sigint_handler(self, signum: int, _: Optional[FrameType]) -> None:
         """Signal handler for SIGINTs which typically come from Ctrl-C events.
 
-        If you need custom SIGINT behavior, then override this function.
+        If you need custom SIGINT behavior, then override this method.
 
         :param signum: signal number
-        :param _: required param for signal handlers
+        :param _: the current stack frame or None
         """
         if self._cur_pipe_proc_reader is not None:
             # Pass the SIGINT to the current pipe process
@@ -2266,7 +2418,30 @@ class Cmd(cmd.Cmd):
 
         # Check if we are allowed to re-raise the KeyboardInterrupt
         if not self.sigint_protection:
-            self._raise_keyboard_interrupt()
+            raise_interrupt = True
+            if self.current_command is not None:
+                command_set = self.find_commandset_for_command(self.current_command.command)
+                if command_set is not None:
+                    raise_interrupt = not command_set.sigint_handler()
+            if raise_interrupt:
+                self._raise_keyboard_interrupt()
+
+    def termination_signal_handler(self, signum: int, _: Optional[FrameType]) -> None:
+        """
+        Signal handler for SIGHUP and SIGTERM. Only runs on Linux and Mac.
+
+        SIGHUP - received when terminal window is closed
+        SIGTERM - received when this app has been requested to terminate
+
+        The basic purpose of this method is to call sys.exit() so our exit handler will run
+        and save the persistent history file. If you need more complex behavior like killing
+        threads and performing cleanup, then override this method.
+
+        :param signum: signal number
+        :param _: the current stack frame or None
+        """
+        # POSIX systems add 128 to signal numbers for the exit code
+        sys.exit(128 + signum)
 
     def _raise_keyboard_interrupt(self) -> None:
         """Helper function to raise a KeyboardInterrupt"""
@@ -2335,7 +2510,13 @@ class Cmd(cmd.Cmd):
         return statement.command, statement.args, statement.command_and_args
 
     def onecmd_plus_hooks(
-        self, line: str, *, add_to_history: bool = True, raise_keyboard_interrupt: bool = False, py_bridge_call: bool = False
+        self,
+        line: str,
+        *,
+        add_to_history: bool = True,
+        raise_keyboard_interrupt: bool = False,
+        py_bridge_call: bool = False,
+        orig_rl_history_length: Optional[int] = None,
     ) -> bool:
         """Top-level function called by cmdloop() to handle parsing a line and running the command and all of its hooks.
 
@@ -2347,6 +2528,9 @@ class Cmd(cmd.Cmd):
         :param py_bridge_call: This should only ever be set to True by PyBridge to signify the beginning
                                of an app() call from Python. It is used to enable/disable the storage of the
                                command's stdout.
+        :param orig_rl_history_length: Optional length of the readline history before the current command was typed.
+                                       This is used to assist in combining multiline readline history entries and is only
+                                       populated by cmd2. Defaults to None.
         :return: True if running of commands should stop
         """
         import datetime
@@ -2356,7 +2540,7 @@ class Cmd(cmd.Cmd):
 
         try:
             # Convert the line into a Statement
-            statement = self._input_line_to_statement(line)
+            statement = self._input_line_to_statement(line, orig_rl_history_length=orig_rl_history_length)
 
             # call the postparsing hooks
             postparsing_data = plugin.PostparsingData(False, statement)
@@ -2431,7 +2615,8 @@ class Cmd(cmd.Cmd):
             if raise_keyboard_interrupt and not stop:
                 raise ex
         except SystemExit as ex:
-            self.exit_code = ex.code
+            if isinstance(ex.code, int):
+                self.exit_code = ex.code
             stop = True
         except PassThroughException as ex:
             raise ex.wrapped_ex
@@ -2444,7 +2629,8 @@ class Cmd(cmd.Cmd):
                 if raise_keyboard_interrupt and not stop:
                     raise ex
             except SystemExit as ex:
-                self.exit_code = ex.code
+                if isinstance(ex.code, int):
+                    self.exit_code = ex.code
                 stop = True
             except PassThroughException as ex:
                 raise ex.wrapped_ex
@@ -2508,7 +2694,7 @@ class Cmd(cmd.Cmd):
 
         return False
 
-    def _complete_statement(self, line: str) -> Statement:
+    def _complete_statement(self, line: str, *, orig_rl_history_length: Optional[int] = None) -> Statement:
         """Keep accepting lines of input until the command is complete.
 
         There is some pretty hacky code here to handle some quirks of
@@ -2517,10 +2703,29 @@ class Cmd(cmd.Cmd):
         backwards compatibility with the standard library version of cmd.
 
         :param line: the line being parsed
+        :param orig_rl_history_length: Optional length of the readline history before the current command was typed.
+                                       This is used to assist in combining multiline readline history entries and is only
+                                       populated by cmd2. Defaults to None.
         :return: the completed Statement
         :raises: Cmd2ShlexError if a shlex error occurs (e.g. No closing quotation)
         :raises: EmptyStatement when the resulting Statement is blank
         """
+
+        def combine_rl_history(statement: Statement) -> None:
+            """Combine all lines of a multiline command into a single readline history entry"""
+            if orig_rl_history_length is None or not statement.multiline_command:
+                return
+
+            # Remove all previous lines added to history for this command
+            while readline.get_current_history_length() > orig_rl_history_length:
+                readline.remove_history_item(readline.get_current_history_length() - 1)
+
+            formatted_command = single_line_format(statement)
+
+            # If formatted command is different than the previous history item, add it
+            if orig_rl_history_length == 0 or formatted_command != readline.get_history_item(orig_rl_history_length):
+                readline.add_history(formatted_command)
+
         while True:
             try:
                 statement = self.statement_parser.parse(line)
@@ -2532,7 +2737,7 @@ class Cmd(cmd.Cmd):
                     # so we are done
                     break
             except Cmd2ShlexError:
-                # we have unclosed quotation marks, lets parse only the command
+                # we have an unclosed quotation mark, let's parse only the command
                 # and see if it's a multiline
                 statement = self.statement_parser.parse_command_only(line)
                 if not statement.multiline_command:
@@ -2548,6 +2753,7 @@ class Cmd(cmd.Cmd):
                 # Save the command line up to this point for tab completion
                 self._multiline_in_progress = line + '\n'
 
+                # Get next line of this command
                 nextline = self._read_command_line(self.continuation_prompt)
                 if nextline == 'eof':
                     # they entered either a blank line, or we hit an EOF
@@ -2556,7 +2762,14 @@ class Cmd(cmd.Cmd):
                     # terminator
                     nextline = '\n'
                     self.poutput(nextline)
-                line = f'{self._multiline_in_progress}{nextline}'
+
+                line += f'\n{nextline}'
+
+                # Combine all history lines of this multiline command as we go.
+                if nextline:
+                    statement = self.statement_parser.parse_command_only(line)
+                    combine_rl_history(statement)
+
             except KeyboardInterrupt:
                 self.poutput('^C')
                 statement = self.statement_parser.parse('')
@@ -2566,13 +2779,20 @@ class Cmd(cmd.Cmd):
 
         if not statement.command:
             raise EmptyStatement
+        else:
+            # If necessary, update history with completed multiline command.
+            combine_rl_history(statement)
+
         return statement
 
-    def _input_line_to_statement(self, line: str) -> Statement:
+    def _input_line_to_statement(self, line: str, *, orig_rl_history_length: Optional[int] = None) -> Statement:
         """
         Parse the user's input line and convert it to a Statement, ensuring that all macros are also resolved
 
         :param line: the line being parsed
+        :param orig_rl_history_length: Optional length of the readline history before the current command was typed.
+                                       This is used to assist in combining multiline readline history entries and is only
+                                       populated by cmd2. Defaults to None.
         :return: parsed command line as a Statement
         :raises: Cmd2ShlexError if a shlex error occurs (e.g. No closing quotation)
         :raises: EmptyStatement when the resulting Statement is blank
@@ -2583,11 +2803,13 @@ class Cmd(cmd.Cmd):
         # Continue until all macros are resolved
         while True:
             # Make sure all input has been read and convert it to a Statement
-            statement = self._complete_statement(line)
+            statement = self._complete_statement(line, orig_rl_history_length=orig_rl_history_length)
 
-            # Save the fully entered line if this is the first loop iteration
+            # If this is the first loop iteration, save the original line and stop
+            # combining multiline history entries in the remaining iterations.
             if orig_line is None:
                 orig_line = statement.raw
+                orig_rl_history_length = None
 
             # Check if this command matches a macro and wasn't already processed to avoid an infinite loop
             if statement.command in self.macros.keys() and statement.command not in used_macros:
@@ -2732,13 +2954,8 @@ class Cmd(cmd.Cmd):
                 sys.stdout = self.stdout = new_stdout
 
         elif statement.output:
-            import tempfile
-
-            if (not statement.output_to) and (not self._can_clip):
-                raise RedirectionError("Cannot redirect to paste buffer; missing 'pyperclip' and/or pyperclip dependencies")
-
-            # Redirecting to a file
-            elif statement.output_to:
+            if statement.output_to:
+                # redirecting to a file
                 # statement.output can only contain REDIRECTION_APPEND or REDIRECTION_OUTPUT
                 mode = 'a' if statement.output == constants.REDIRECTION_APPEND else 'w'
                 try:
@@ -2750,14 +2967,26 @@ class Cmd(cmd.Cmd):
                 redir_saved_state.redirecting = True
                 sys.stdout = self.stdout = new_stdout
 
-            # Redirecting to a paste buffer
             else:
+                # Redirecting to a paste buffer
+                # we are going to direct output to a temporary file, then read it back in and
+                # put it in the paste buffer later
+                if not self.allow_clipboard:
+                    raise RedirectionError("Clipboard access not allowed")
+
+                # attempt to get the paste buffer, this forces pyperclip to go figure
+                # out if it can actually interact with the paste buffer, and will throw exceptions
+                # if it's not gonna work. That way we throw the exception before we go
+                # run the command and queue up all the output. if this is going to fail,
+                # no point opening up the temporary file
+                current_paste_buffer = get_paste_buffer()
+                # create a temporary file to store output
                 new_stdout = cast(TextIO, tempfile.TemporaryFile(mode="w+"))
                 redir_saved_state.redirecting = True
                 sys.stdout = self.stdout = new_stdout
 
                 if statement.output == constants.REDIRECTION_APPEND:
-                    self.stdout.write(get_paste_buffer())
+                    self.stdout.write(current_paste_buffer)
                     self.stdout.flush()
 
         # These are updated regardless of whether the command redirected
@@ -2822,7 +3051,6 @@ class Cmd(cmd.Cmd):
         target = constants.COMMAND_FUNC_PREFIX + command
         return target if callable(getattr(self, target, None)) else ''
 
-    # noinspection PyMethodOverriding
     def onecmd(self, statement: Union[Statement, str], *, add_to_history: bool = True) -> bool:
         """This executes the actual do_* method for a command.
 
@@ -2847,7 +3075,11 @@ class Cmd(cmd.Cmd):
             ):
                 self.history.append(statement)
 
-            stop = func(statement)
+            try:
+                self.current_command = statement
+                stop = func(statement)
+            finally:
+                self.current_command = None
 
         else:
             stop = self.default(statement)
@@ -2863,15 +3095,19 @@ class Cmd(cmd.Cmd):
             if 'shell' not in self.exclude_from_history:
                 self.history.append(statement)
 
-            # noinspection PyTypeChecker
             return self.do_shell(statement.command_and_args)
         else:
             err_msg = self.default_error.format(statement.command)
+            if self.suggest_similar_command and (suggested_command := self._suggest_similar_command(statement.command)):
+                err_msg += f"\n{self.default_suggestion_message.format(suggested_command)}"
 
-            # Set apply_style to False so default_error's style is not overridden
+            # Set apply_style to False so styles for default_error and default_suggestion_message are not overridden
             self.perror(err_msg, apply_style=False)
             return None
 
+    def _suggest_similar_command(self, command: str) -> Optional[str]:
+        return suggest_similar(command, self.get_visible_commands())
+
     def read_input(
         self,
         prompt: str,
@@ -2926,7 +3162,7 @@ class Cmd(cmd.Cmd):
             nonlocal saved_history
             nonlocal parser
 
-            if readline_configured:  # pragma: no cover
+            if readline_configured or rl_type == RlType.NONE:  # pragma: no cover
                 return
 
             # Configure tab completion
@@ -2935,7 +3171,7 @@ class Cmd(cmd.Cmd):
 
                 # Disable completion
                 if completion_mode == utils.CompletionMode.NONE:
-                    # noinspection PyUnusedLocal
+
                     def complete_none(text: str, state: int) -> Optional[str]:  # pragma: no cover
                         return None
 
@@ -2966,7 +3202,6 @@ class Cmd(cmd.Cmd):
             if completion_mode != utils.CompletionMode.COMMANDS or history is not None:
                 saved_history = []
                 for i in range(1, readline.get_current_history_length() + 1):
-                    # noinspection PyArgumentList
                     saved_history.append(readline.get_history_item(i))
 
                 readline.clear_history()
@@ -2979,7 +3214,7 @@ class Cmd(cmd.Cmd):
         def restore_readline() -> None:
             """Restore readline tab completion and history"""
             nonlocal readline_configured
-            if not readline_configured:  # pragma: no cover
+            if not readline_configured or rl_type == RlType.NONE:  # pragma: no cover
                 return
 
             if self._completion_supported():
@@ -3063,8 +3298,13 @@ class Cmd(cmd.Cmd):
         """
         readline_settings = _SavedReadlineSettings()
 
-        if self._completion_supported():
+        if rl_type == RlType.GNU:
+            # To calculate line count when printing async_alerts, we rely on commands wider than
+            # the terminal to wrap across multiple lines. The default for horizontal-scroll-mode
+            # is "off" but a user may have overridden it in their readline initialization file.
+            readline.parse_and_bind("set horizontal-scroll-mode off")
 
+        if self._completion_supported():
             # Set up readline for our tab completion needs
             if rl_type == RlType.GNU:
                 # GNU readline automatically adds a closing quote if the text being completed has an opening quote.
@@ -3098,7 +3338,6 @@ class Cmd(cmd.Cmd):
         :param readline_settings: the readline settings to restore
         """
         if self._completion_supported():
-
             # Restore what we changed in readline
             readline.set_completer(readline_settings.completer)
             readline.set_completer_delims(readline_settings.delims)
@@ -3107,7 +3346,6 @@ class Cmd(cmd.Cmd):
                 readline.set_completion_display_matches_hook(None)
                 rl_basic_quote_characters.value = readline_settings.basic_quotes
             elif rl_type == RlType.PYREADLINE:
-                # noinspection PyUnresolvedReferences
                 readline.rl.mode._display_completions = orig_pyreadline_display
 
     def _cmdloop(self) -> None:
@@ -3129,6 +3367,13 @@ class Cmd(cmd.Cmd):
             self._startup_commands.clear()
 
             while not stop:
+                # Used in building multiline readline history entries. Only applies
+                # when command line is read by input() in a terminal.
+                if rl_type != RlType.NONE and self.use_rawinput and sys.stdin.isatty():
+                    orig_rl_history_length = readline.get_current_history_length()
+                else:
+                    orig_rl_history_length = None
+
                 # Get commands from user
                 try:
                     line = self._read_command_line(self.prompt)
@@ -3137,7 +3382,7 @@ class Cmd(cmd.Cmd):
                     line = ''
 
                 # Run the command along with all associated pre and post hooks
-                stop = self.onecmd_plus_hooks(line)
+                stop = self.onecmd_plus_hooks(line, orig_rl_history_length=orig_rl_history_length)
         finally:
             # Get sigint protection while we restore readline settings
             with self.sigint_protection:
@@ -3571,7 +3816,7 @@ class Cmd(cmd.Cmd):
 
         # Check if this command uses argparse
         func = self.cmd_func(command)
-        argparser = getattr(func, constants.CMD_ATTR_ARGPARSER, None)
+        argparser = self._command_parsers.get(command, None)
         if func is None or argparser is None:
             return []
 
@@ -3607,7 +3852,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 = getattr(func, constants.CMD_ATTR_ARGPARSER, None)
+            argparser = self._command_parsers.get(args.command, None)
 
             # If the command function uses argparse, then use argparse's help
             if func is not None and argparser is not None:
@@ -3688,9 +3933,10 @@ class Cmd(cmd.Cmd):
             if totwidth <= display_width:
                 break
         else:
+            # The output is wider than display_width. Print 1 column with each string on its own row.
             nrows = len(str_list)
             ncols = 1
-            colwidths = [0]
+            colwidths = [1]
         for row in range(nrows):
             texts = []
             for col in range(ncols):
@@ -3742,7 +3988,7 @@ class Cmd(cmd.Cmd):
                 help_topics.remove(command)
 
                 # Non-argparse commands can have help_functions for their documentation
-                if not hasattr(func, constants.CMD_ATTR_ARGPARSER):
+                if command not in self._command_parsers:
                     has_help_func = True
 
             if hasattr(func, constants.CMD_ATTR_HELP_CATEGORY):
@@ -3788,7 +4034,7 @@ class Cmd(cmd.Cmd):
                     doc: Optional[str]
 
                     # Non-argparse commands can have help_functions for their documentation
-                    if not hasattr(cmd_func, constants.CMD_ATTR_ARGPARSER) and command in topics:
+                    if command not in self._command_parsers and command in topics:
                         help_func = getattr(self, constants.HELP_FUNC_PREFIX + command)
                         result = io.StringIO()
 
@@ -3841,7 +4087,6 @@ class Cmd(cmd.Cmd):
         self.poutput()
 
         # self.last_result will be set by do_quit()
-        # noinspection PyTypeChecker
         return self.do_quit('')
 
     quit_parser = argparse_custom.DEFAULT_ARGUMENT_PARSER(description="Exit this application")
@@ -3878,7 +4123,7 @@ class Cmd(cmd.Cmd):
                     fulloptions.append((opt[0], opt[1]))
                 except IndexError:
                     fulloptions.append((opt[0], opt[0]))
-        for (idx, (_, text)) in enumerate(fulloptions):
+        for idx, (_, text) in enumerate(fulloptions):
             self.poutput('  %2d. %s' % (idx + 1, text))
 
         while True:
@@ -3977,7 +4222,6 @@ class Cmd(cmd.Cmd):
                 try:
                     orig_value = settable.get_value()
                     new_value = settable.set_value(utils.strip_quotes(args.value))
-                # noinspection PyBroadException
                 except Exception as ex:
                     self.perror(f"Error setting {args.param}: {ex}")
                 else:
@@ -4113,7 +4357,6 @@ class Cmd(cmd.Cmd):
         if rl_type != RlType.NONE:
             # Save cmd2 history
             for i in range(1, readline.get_current_history_length() + 1):
-                # noinspection PyArgumentList
                 cmd2_env.history.append(readline.get_history_item(i))
 
             readline.clear_history()
@@ -4147,7 +4390,6 @@ class Cmd(cmd.Cmd):
                 if rl_type == RlType.GNU:
                     readline.set_completion_display_matches_hook(None)
                 elif rl_type == RlType.PYREADLINE:
-                    # noinspection PyUnresolvedReferences
                     readline.rl.mode._display_completions = orig_pyreadline_display
 
                 # Save off the current completer and set a new one in the Python console
@@ -4182,7 +4424,6 @@ class Cmd(cmd.Cmd):
             # Save py's history
             self._py_history.clear()
             for i in range(1, readline.get_current_history_length() + 1):
-                # noinspection PyArgumentList
                 self._py_history.append(readline.get_history_item(i))
 
             readline.clear_history()
@@ -4226,7 +4467,8 @@ class Cmd(cmd.Cmd):
             PyBridge,
         )
 
-        py_bridge = PyBridge(self)
+        add_to_history = self.scripts_add_to_history if pyscript else True
+        py_bridge = PyBridge(self, add_to_history=add_to_history)
         saved_sys_path = None
 
         if self.in_pyscript():
@@ -4278,7 +4520,6 @@ class Cmd(cmd.Cmd):
 
             # Check if we are running Python code
             if py_code_to_run:
-                # noinspection PyBroadException
                 try:
                     interp.runcode(py_code_to_run)  # type: ignore[arg-type]
                 except BaseException:
@@ -4296,7 +4537,6 @@ class Cmd(cmd.Cmd):
 
                 saved_cmd2_env = None
 
-                # noinspection PyBroadException
                 try:
                     # Get sigint protection while we set up the Python shell environment
                     with self.sigint_protection:
@@ -4377,7 +4617,6 @@ class Cmd(cmd.Cmd):
 
     ipython_parser = argparse_custom.DEFAULT_ARGUMENT_PARSER(description="Run an interactive IPython shell")
 
-    # noinspection PyPackageRequirements
     @with_argparser(ipython_parser)
     def do_ipy(self, _: argparse.Namespace) -> Optional[bool]:  # pragma: no cover
         """
@@ -4426,14 +4665,14 @@ class Cmd(cmd.Cmd):
                 local_vars['self'] = self
 
             # Configure IPython
-            config = TraitletsLoader.Config()
+            config = TraitletsLoader.Config()  # type: ignore
             config.InteractiveShell.banner2 = (
                 'Entering an IPython shell. Type exit, quit, or Ctrl-D to exit.\n'
                 f'Run CLI commands with: {self.py_bridge_name}("command ...")\n'
             )
 
             # Start IPython
-            start_ipython(config=config, argv=[], user_ns=local_vars)
+            start_ipython(config=config, argv=[], user_ns=local_vars)  # type: ignore[no-untyped-call]
             self.poutput("Now exiting IPython shell...")
 
             # The IPython application is a singleton and won't be recreated next time
@@ -4548,8 +4787,6 @@ class Cmd(cmd.Cmd):
                 self.last_result = True
                 return stop
         elif args.edit:
-            import tempfile
-
             fd, fname = tempfile.mkstemp(suffix='.txt', text=True)
             fobj: TextIO
             with os.fdopen(fd, 'w') as fobj:
@@ -4562,7 +4799,6 @@ class Cmd(cmd.Cmd):
                 self.run_editor(fname)
 
                 # self.last_resort will be set by do_run_script()
-                # noinspection PyTypeChecker
                 return self.do_run_script(utils.quote_string(fname))
             finally:
                 os.remove(fname)
@@ -4622,11 +4858,9 @@ class Cmd(cmd.Cmd):
                           previous sessions will be included. Additionally, all history will be written
                           to this file when the application exits.
         """
-        import json
-        import lzma
-
         self.history = History()
-        # with no persistent history, nothing else in this method is relevant
+
+        # With no persistent history, nothing else in this method is relevant
         if not hist_file:
             self.persistent_history_file = hist_file
             return
@@ -4647,64 +4881,96 @@ class Cmd(cmd.Cmd):
             self.perror(f"Error creating persistent history file directory '{hist_file_dir}': {ex}")
             return
 
-        # Read and process history file
+        # Read history file
         try:
             with open(hist_file, 'rb') as fobj:
                 compressed_bytes = fobj.read()
-            history_json = lzma.decompress(compressed_bytes).decode(encoding='utf-8')
-            self.history = History.from_json(history_json)
         except FileNotFoundError:
-            # Just use an empty history
-            pass
+            compressed_bytes = bytes()
         except OSError as ex:
             self.perror(f"Cannot read persistent history file '{hist_file}': {ex}")
             return
-        except (json.JSONDecodeError, lzma.LZMAError, KeyError, UnicodeDecodeError, ValueError) as ex:
+
+        # Register a function to write history at save
+        import atexit
+
+        self.persistent_history_file = hist_file
+        atexit.register(self._persist_history)
+
+        # Empty or nonexistent history file. Nothing more to do.
+        if not compressed_bytes:
+            return
+
+        # Decompress history data
+        try:
+            import lzma as decompress_lib
+
+            decompress_exceptions: Tuple[type[Exception]] = (decompress_lib.LZMAError,)
+        except ModuleNotFoundError:  # pragma: no cover
+            import bz2 as decompress_lib  # type: ignore[no-redef]
+
+            decompress_exceptions: Tuple[type[Exception]] = (OSError, ValueError)  # type: ignore[no-redef]
+
+        try:
+            history_json = decompress_lib.decompress(compressed_bytes).decode(encoding='utf-8')
+        except decompress_exceptions as ex:
+            self.perror(
+                f"Error decompressing persistent history data '{hist_file}': {ex}\n"
+                f"The history file will be recreated when this application exits."
+            )
+            return
+
+        # Decode history json
+        import json
+
+        try:
+            self.history = History.from_json(history_json)
+        except (json.JSONDecodeError, KeyError, ValueError) as ex:
             self.perror(
-                f"Error processing persistent history file '{hist_file}': {ex}\n"
+                f"Error processing persistent history data '{hist_file}': {ex}\n"
                 f"The history file will be recreated when this application exits."
             )
+            return
 
         self.history.start_session()
-        self.persistent_history_file = hist_file
 
-        # populate readline history
+        # Populate readline history
         if rl_type != RlType.NONE:
-            last = None
             for item in self.history:
-                # Break the command into its individual lines
-                for line in item.raw.splitlines():
-                    # readline only adds a single entry for multiple sequential identical lines
-                    # so we emulate that behavior here
-                    if line != last:
-                        readline.add_history(line)
-                        last = line
-
-        # register a function to write history at save
-        # if the history file is in plain text format from 0.9.12 or lower
-        # this will fail, and the history in the plain text file will be lost
-        import atexit
+                formatted_command = single_line_format(item.statement)
 
-        atexit.register(self._persist_history)
+                # If formatted command is different than the previous history item, add it
+                cur_history_length = readline.get_current_history_length()
+                if cur_history_length == 0 or formatted_command != readline.get_history_item(cur_history_length):
+                    readline.add_history(formatted_command)
 
     def _persist_history(self) -> None:
         """Write history out to the persistent history file as compressed JSON"""
-        import lzma
-
         if not self.persistent_history_file:
             return
 
-        self.history.truncate(self._persistent_history_length)
         try:
-            history_json = self.history.to_json()
-            compressed_bytes = lzma.compress(history_json.encode(encoding='utf-8'))
+            import lzma as compress_lib
+        except ModuleNotFoundError:  # pragma: no cover
+            import bz2 as compress_lib  # type: ignore[no-redef]
 
+        self.history.truncate(self._persistent_history_length)
+        history_json = self.history.to_json()
+        compressed_bytes = compress_lib.compress(history_json.encode(encoding='utf-8'))
+
+        try:
             with open(self.persistent_history_file, 'wb') as fobj:
                 fobj.write(compressed_bytes)
         except OSError as ex:
             self.perror(f"Cannot write persistent history file '{self.persistent_history_file}': {ex}")
 
-    def _generate_transcript(self, history: Union[List[HistoryItem], List[str]], transcript_file: str) -> None:
+    def _generate_transcript(
+        self,
+        history: Union[List[HistoryItem], List[str]],
+        transcript_file: str,
+        *,
+        add_to_history: bool = True,
+    ) -> None:
         """Generate a transcript file from a given history of commands"""
         self.last_result = False
 
@@ -4754,7 +5020,11 @@ class Cmd(cmd.Cmd):
 
                 # then run the command and let the output go into our buffer
                 try:
-                    stop = self.onecmd_plus_hooks(history_item, raise_keyboard_interrupt=True)
+                    stop = self.onecmd_plus_hooks(
+                        history_item,
+                        add_to_history=add_to_history,
+                        raise_keyboard_interrupt=True,
+                    )
                 except KeyboardInterrupt as ex:
                     self.perror(ex)
                     stop = True
@@ -4826,7 +5096,6 @@ class Cmd(cmd.Cmd):
         if file_path:
             command += " " + utils.quote_string(os.path.expanduser(file_path))
 
-        # noinspection PyTypeChecker
         self.do_shell(command)
 
     @property
@@ -4899,9 +5168,17 @@ class Cmd(cmd.Cmd):
 
             if args.transcript:
                 # self.last_resort will be set by _generate_transcript()
-                self._generate_transcript(script_commands, os.path.expanduser(args.transcript))
+                self._generate_transcript(
+                    script_commands,
+                    os.path.expanduser(args.transcript),
+                    add_to_history=self.scripts_add_to_history,
+                )
             else:
-                stop = self.runcmds_plus_hooks(script_commands, stop_on_keyboard_interrupt=True)
+                stop = self.runcmds_plus_hooks(
+                    script_commands,
+                    add_to_history=self.scripts_add_to_history,
+                    stop_on_keyboard_interrupt=True,
+                )
                 self.last_result = True
                 return stop
 
@@ -4938,7 +5215,6 @@ class Cmd(cmd.Cmd):
         relative_path = os.path.join(self._current_script_dir or '', file_path)
 
         # self.last_result will be set by do_run_script()
-        # noinspection PyTypeChecker
         return self.do_run_script(utils.quote_string(relative_path))
 
     def _run_transcript_tests(self, transcript_paths: List[str]) -> None:
@@ -4981,7 +5257,6 @@ class Cmd(cmd.Cmd):
         sys.argv = [sys.argv[0]]  # the --test argument upsets unittest.main()
         testcase = TestMyAppCase()
         stream = cast(TextIO, utils.StdSim(sys.stderr))
-        # noinspection PyTypeChecker
         runner = unittest.TextTestRunner(stream=stream)
         start_time = time.time()
         test_results = runner.run(testcase)
@@ -4989,8 +5264,8 @@ class Cmd(cmd.Cmd):
         if test_results.wasSuccessful():
             ansi.style_aware_write(sys.stderr, stream.read())
             finish_msg = f' {num_transcripts} transcript{plural} passed in {execution_time:.3f} seconds '
-            finish_msg = ansi.style_success(utils.align_center(finish_msg, fill_char='='))
-            self.poutput(finish_msg)
+            finish_msg = utils.align_center(finish_msg, fill_char='=')
+            self.psuccess(finish_msg)
         else:
             # Strip off the initial traceback which isn't particularly useful for end users
             error_str = stream.read()
@@ -5007,16 +5282,16 @@ class Cmd(cmd.Cmd):
     def async_alert(self, alert_msg: str, new_prompt: Optional[str] = None) -> None:  # pragma: no cover
         """
         Display an important message to the user while they are at a command line prompt.
-        To the user it appears as if an alert message is printed above the prompt and their current input
-        text and cursor location is left alone.
+        To the user it appears as if an alert message is printed above the prompt and their
+        current input text and cursor location is left alone.
 
-        IMPORTANT: This function will not print an alert unless it can acquire self.terminal_lock to ensure
-                   a prompt is onscreen. Therefore, it is best to acquire the lock before calling this function
-                   to guarantee the alert prints and to avoid raising a RuntimeError.
+        This function needs to acquire self.terminal_lock to ensure a prompt is on screen.
+        Therefore, it is best to acquire the lock before calling this function to avoid
+        raising a RuntimeError.
 
-                   This function is only needed when you need to print an alert while the main thread is blocking
-                   at the prompt. Therefore, this should never be called from the main thread. Doing so will
-                   raise a RuntimeError.
+        This function is only needed when you need to print an alert or update the prompt while the
+        main thread is blocking at the prompt. Therefore, this should never be called from the main
+        thread. Doing so will raise a RuntimeError.
 
         :param alert_msg: the message to display to the user
         :param new_prompt: If you also want to change the prompt that is displayed, then include it here.
@@ -5032,7 +5307,6 @@ class Cmd(cmd.Cmd):
 
         # Sanity check that can't fail if self.terminal_lock was acquired before calling this function
         if self.terminal_lock.acquire(blocking=False):
-
             # Windows terminals tend to flicker when we redraw the prompt and input lines.
             # To reduce how often this occurs, only update terminal if there are changes.
             update_terminal = False
@@ -5044,20 +5318,18 @@ class Cmd(cmd.Cmd):
             if new_prompt is not None:
                 self.prompt = new_prompt
 
-            # Check if the prompt to display has changed from what's currently displayed
-            cur_onscreen_prompt = rl_get_prompt()
-            new_onscreen_prompt = self.continuation_prompt if self._at_continuation_prompt else self.prompt
-
-            if new_onscreen_prompt != cur_onscreen_prompt:
+            # Check if the onscreen prompt needs to be refreshed to match self.prompt.
+            if self.need_prompt_refresh():
                 update_terminal = True
+                rl_set_prompt(self.prompt)
 
             if update_terminal:
                 import shutil
 
-                # Generate the string which will replace the current prompt and input lines with the alert
+                # Print a string which replaces the onscreen prompt and input lines with the alert.
                 terminal_str = ansi.async_alert_str(
                     terminal_columns=shutil.get_terminal_size().columns,
-                    prompt=cur_onscreen_prompt,
+                    prompt=rl_get_display_prompt(),
                     line=readline.get_line_buffer(),
                     cursor_offset=rl_get_point(),
                     alert_msg=alert_msg,
@@ -5066,12 +5338,8 @@ class Cmd(cmd.Cmd):
                     sys.stderr.write(terminal_str)
                     sys.stderr.flush()
                 elif rl_type == RlType.PYREADLINE:
-                    # noinspection PyUnresolvedReferences
                     readline.rl.mode.console.write(terminal_str)
 
-                # Update Readline's prompt before we redraw it
-                rl_set_prompt(new_onscreen_prompt)
-
                 # Redraw the prompt and input lines below the alert
                 rl_force_redisplay()
 
@@ -5082,23 +5350,17 @@ class Cmd(cmd.Cmd):
 
     def async_update_prompt(self, new_prompt: str) -> None:  # pragma: no cover
         """
-        Update the command line prompt while the user is still typing at it. This is good for alerting the user to
-        system changes dynamically in between commands. For instance you could alter the color of the prompt to
-        indicate a system status or increase a counter to report an event. If you do alter the actual text of the
-        prompt, it is best to keep the prompt the same width as what's on screen. Otherwise the user's input text will
-        be shifted and the update will not be seamless.
+        Update the command line prompt while the user is still typing at it.
 
-        IMPORTANT: This function will not update the prompt unless it can acquire self.terminal_lock to ensure
-                   a prompt is onscreen. Therefore, it is best to acquire the lock before calling this function
-                   to guarantee the prompt changes and to avoid raising a RuntimeError.
+        This is good for alerting the user to system changes dynamically in between commands.
+        For instance you could alter the color of the prompt to indicate a system status or increase a
+        counter to report an event. If you do alter the actual text of the prompt, it is best to keep
+        the prompt the same width as what's on screen. Otherwise the user's input text will be shifted
+        and the update will not be seamless.
 
-                   This function is only needed when you need to update the prompt while the main thread is blocking
-                   at the prompt. Therefore, this should never be called from the main thread. Doing so will
-                   raise a RuntimeError.
-
-                   If user is at a continuation prompt while entering a multiline command, the onscreen prompt will
-                   not change. However, self.prompt will still be updated and display immediately after the multiline
-                   line command completes.
+        If user is at a continuation prompt while entering a multiline command, the onscreen prompt will
+        not change. However, self.prompt will still be updated and display immediately after the multiline
+        line command completes.
 
         :param new_prompt: what to change the prompt to
         :raises RuntimeError: if called from the main thread.
@@ -5106,6 +5368,32 @@ class Cmd(cmd.Cmd):
         """
         self.async_alert('', new_prompt)
 
+    def async_refresh_prompt(self) -> None:  # pragma: no cover
+        """
+        Refresh the oncreen prompt to match self.prompt.
+
+        One case where the onscreen prompt and self.prompt can get out of sync is
+        when async_alert() is called while a user is in search mode (e.g. Ctrl-r).
+        To prevent overwriting readline's onscreen search prompt, self.prompt is updated
+        but readline's saved prompt isn't.
+
+        Therefore when a user aborts a search, the old prompt is still on screen until they
+        press Enter or this method is called. Call need_prompt_refresh() in an async print
+        thread to know when a refresh is needed.
+
+        :raises RuntimeError: if called from the main thread.
+        :raises RuntimeError: if called while another thread holds `terminal_lock`
+        """
+        self.async_alert('')
+
+    def need_prompt_refresh(self) -> bool:  # pragma: no cover
+        """Check whether the onscreen prompt needs to be asynchronously refreshed to match self.prompt."""
+        if not (vt100_support and self.use_rawinput):
+            return False
+
+        # Don't overwrite a readline search prompt or a continuation prompt.
+        return not rl_in_search_mode() and not self._at_continuation_prompt and self.prompt != rl_get_prompt()
+
     @staticmethod
     def set_window_title(title: str) -> None:  # pragma: no cover
         """
@@ -5249,15 +5537,22 @@ class Cmd(cmd.Cmd):
         """
         # cmdloop() expects to be run in the main thread to support extensive use of KeyboardInterrupts throughout the
         # other built-in functions. You are free to override cmdloop, but much of cmd2's features will be limited.
-        if not threading.current_thread() is threading.main_thread():
+        if threading.current_thread() is not threading.main_thread():
             raise RuntimeError("cmdloop must be run in the main thread")
 
-        # Register a SIGINT signal handler for Ctrl+C
+        # Register signal handlers
         import signal
 
         original_sigint_handler = signal.getsignal(signal.SIGINT)
         signal.signal(signal.SIGINT, self.sigint_handler)
 
+        if not sys.platform.startswith('win'):
+            original_sighup_handler = signal.getsignal(signal.SIGHUP)
+            signal.signal(signal.SIGHUP, self.termination_signal_handler)
+
+            original_sigterm_handler = signal.getsignal(signal.SIGTERM)
+            signal.signal(signal.SIGTERM, self.termination_signal_handler)
+
         # Grab terminal lock before the command line prompt has been drawn by readline
         self.terminal_lock.acquire()
 
@@ -5290,9 +5585,13 @@ class Cmd(cmd.Cmd):
         # This will also zero the lock count in case cmdloop() is called again
         self.terminal_lock.release()
 
-        # Restore the original signal handler
+        # Restore original signal handlers
         signal.signal(signal.SIGINT, original_sigint_handler)
 
+        if not sys.platform.startswith('win'):
+            signal.signal(signal.SIGHUP, original_sighup_handler)
+            signal.signal(signal.SIGTERM, original_sigterm_handler)
+
         return self.exit_code
 
     ###
@@ -5443,7 +5742,7 @@ class Cmd(cmd.Cmd):
                 func_self = None
                 candidate_sets: List[CommandSet] = []
                 for installed_cmd_set in self._installed_command_sets:
-                    if type(installed_cmd_set) == func_class:
+                    if type(installed_cmd_set) == func_class:  # noqa: E721
                         # Case 2: CommandSet is an exact type match for the function's CommandSet
                         func_self = installed_cmd_set
                         break