Word wrapping long exceptions in pexcept().

Author: kmvanbrunt

cmd2/cmd2.py

@@ -131,6 +131,7 @@
     shlex_split,
 )
 from .rich_utils import (
+    Cmd2ExceptionConsole,
     Cmd2GeneralConsole,
     RichPrintKwargs,
 )
@@ -1207,7 +1208,7 @@ def print_to(
         sep: str = " ",
         end: str = "\n",
         style: StyleType | None = None,
-        soft_wrap: bool | None = None,
+        soft_wrap: bool = True,
         rich_print_kwargs: RichPrintKwargs | None = None,
         **kwargs: Any,  # noqa: ARG002
     ) -> None:
@@ -1218,11 +1219,8 @@ def print_to(
         :param sep: string to write between print data. Defaults to " ".
         :param end: string to write at end of print data. Defaults to a newline.
         :param style: optional style to apply to output
-        :param soft_wrap: Enable soft wrap mode. If True, text lines will not be automatically word-wrapped to fit the
-                          terminal width; instead, any text that doesn't fit will run onto the following line(s),
-                          similar to the built-in print() function. Set to False to enable automatic word-wrapping.
-                          If None (the default for this parameter), the output will default to no word-wrapping, as
-                          configured by the Cmd2GeneralConsole.
+        :param soft_wrap: Enable soft wrap mode. If True, lines of text will not be word-wrapped or cropped to
+                          fit the terminal width. Defaults to True.
         :param rich_print_kwargs: optional additional keyword arguments to pass to Rich's Console.print().
         :param kwargs: Arbitrary keyword arguments. This allows subclasses to extend the signature of this
                        method and still call `super()` without encountering unexpected keyword argument errors.
@@ -1254,7 +1252,7 @@ def poutput(
         sep: str = " ",
         end: str = "\n",
         style: StyleType | None = None,
-        soft_wrap: bool | None = None,
+        soft_wrap: bool = True,
         rich_print_kwargs: RichPrintKwargs | None = None,
         **kwargs: Any,  # noqa: ARG002
     ) -> None:
@@ -1278,7 +1276,7 @@ def perror(
         sep: str = " ",
         end: str = "\n",
         style: StyleType | None = Cmd2Style.ERROR,
-        soft_wrap: bool | None = None,
+        soft_wrap: bool = True,
         rich_print_kwargs: RichPrintKwargs | None = None,
         **kwargs: Any,  # noqa: ARG002
     ) -> None:
@@ -1303,7 +1301,7 @@ def psuccess(
         *objects: Any,
         sep: str = " ",
         end: str = "\n",
-        soft_wrap: bool | None = None,
+        soft_wrap: bool = True,
         rich_print_kwargs: RichPrintKwargs | None = None,
         **kwargs: Any,  # noqa: ARG002
     ) -> None:
@@ -1325,7 +1323,7 @@ def pwarning(
         *objects: Any,
         sep: str = " ",
         end: str = "\n",
-        soft_wrap: bool | None = None,
+        soft_wrap: bool = True,
         rich_print_kwargs: RichPrintKwargs | None = None,
         **kwargs: Any,  # noqa: ARG002
     ) -> None:
@@ -1345,44 +1343,59 @@ def pwarning(
     def pexcept(
         self,
         exception: BaseException,
-        end: str = "\n",
-        rich_print_kwargs: RichPrintKwargs | None = None,
         **kwargs: Any,  # noqa: ARG002
     ) -> None:
         """Print an exception to sys.stderr.
 
-        If `debug` is true, a full exception traceback is also printed, if one exists.
+        If `debug` is true, a full traceback is also printed, if one exists.
 
         :param exception: the exception to be printed.
-
-        For details on the other parameters, refer to the `print_to` method documentation.
+        :param kwargs: Arbitrary keyword arguments. This allows subclasses to extend the signature of this
+                       method and still call `super()` without encountering unexpected keyword argument errors.
         """
-        final_msg = Text()
+        console = Cmd2ExceptionConsole(sys.stderr)
 
+        # Only print a traceback if we're in debug mode and one exists.
         if self.debug and sys.exc_info() != (None, None, None):
-            console = Cmd2GeneralConsole(sys.stderr)
-            console.print_exception(word_wrap=True, max_frames=0)
-        else:
-            final_msg += f"EXCEPTION of type '{type(exception).__name__}' occurred with message: {exception}"
+            console.print_exception(
+                width=console.width,
+                show_locals=True,
+                max_frames=0,  # 0 means full traceback.
+                word_wrap=True,  # Wrap long lines of code instead of truncate
+            )
+            console.print()
+            return
 
-        if not self.debug and 'debug' in self.settables:
-            warning = "\nTo enable full traceback, run the following command: 'set debug true'"
-            final_msg.append(warning, style=Cmd2Style.WARNING)
+        # Otherwise highlight and print the exception.
+        from rich.highlighter import ReprHighlighter
 
-        if final_msg:
-            self.perror(
-                final_msg,
-                end=end,
-                rich_print_kwargs=rich_print_kwargs,
+        highlighter = ReprHighlighter()
+
+        final_msg = Text.assemble(
+            ("EXCEPTION of type ", Cmd2Style.ERROR),
+            (f"{type(exception).__name__}", Cmd2Style.EXCEPTION_TYPE),
+            (" occurred with message: ", Cmd2Style.ERROR),
+            highlighter(str(exception)),
+        )
+
+        if not self.debug and 'debug' in self.settables:
+            help_msg = Text.assemble(
+                "\n\n",
+                ("To enable full traceback, run the following command: ", Cmd2Style.WARNING),
+                ("set debug true", Cmd2Style.COMMAND_LINE),
             )
+            final_msg.append(help_msg)
+
+        console.print(final_msg)
+        console.print()
 
     def pfeedback(
         self,
         *objects: Any,
         sep: str = " ",
         end: str = "\n",
         style: StyleType | None = None,
-        soft_wrap: bool | None = None,
+        soft_wrap: bool = True,
         rich_print_kwargs: RichPrintKwargs | None = None,
         **kwargs: Any,  # noqa: ARG002
     ) -> None:
@@ -1420,7 +1433,7 @@ def ppaged(
         end: str = "\n",
         style: StyleType | None = None,
         chop: bool = False,
-        soft_wrap: bool | None = None,
+        soft_wrap: bool = True,
         rich_print_kwargs: RichPrintKwargs | None = None,
         **kwargs: Any,  # noqa: ARG002
     ) -> None:
@@ -1436,13 +1449,11 @@ def ppaged(
                      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
                      WARNING: On Windows, the text always wraps regardless of what the chop argument is set to
-        :param soft_wrap: Enable soft wrap mode. If True, text lines will not be automatically word-wrapped to fit the
-                          terminal width; instead, any text that doesn't fit will run onto the following line(s),
-                          similar to the built-in print() function. Set to False to enable automatic word-wrapping.
-                          If None (the default for this parameter), the output will default to no word-wrapping, as
-                          configured by the Cmd2GeneralConsole.
+        :param soft_wrap: Enable soft wrap mode. If True, lines of text will not be word-wrapped or cropped to
+                          fit the terminal width. Defaults to True.
 
-                          Note: If chop is True and a pager is used, soft_wrap is automatically set to True.
+                          Note: If chop is True and a pager is used, soft_wrap is automatically set to True to
+                          prevent wrapping and allow for horizontal scrolling.
 
         For details on the other parameters, refer to the `print_to` method documentation.
         """
@@ -3527,7 +3538,7 @@ def _build_alias_create_parser(cls) -> Cmd2ArgumentParser:
         alias_create_notes = Group(
             "If you want to use redirection, pipes, or terminators in the value of the alias, then quote them.",
             "\n",
-            Text("    alias create save_results print_results \">\" out.txt\n", style=Cmd2Style.EXAMPLE),
+            Text("    alias create save_results print_results \">\" out.txt\n", style=Cmd2Style.COMMAND_LINE),
             (
                 "Since aliases are resolved during parsing, tab completion will function as it would "
                 "for the actual command the alias resolves to."
@@ -3740,14 +3751,14 @@ def _build_macro_create_parser(cls) -> Cmd2ArgumentParser:
             "\n",
             "The following creates a macro called my_macro that expects two arguments:",
             "\n",
-            Text("    macro create my_macro make_dinner --meat {1} --veggie {2}", style=Cmd2Style.EXAMPLE),
+            Text("    macro create my_macro make_dinner --meat {1} --veggie {2}", style=Cmd2Style.COMMAND_LINE),
             "\n",
             "When the macro is called, the provided arguments are resolved and the assembled command is run. For example:",
             "\n",
             Text.assemble(
-                ("    my_macro beef broccoli", Cmd2Style.EXAMPLE),
+                ("    my_macro beef broccoli", Cmd2Style.COMMAND_LINE),
                 (" ───> ", Style(bold=True)),
-                ("make_dinner --meat beef --veggie broccoli", Cmd2Style.EXAMPLE),
+                ("make_dinner --meat beef --veggie broccoli", Cmd2Style.COMMAND_LINE),
             ),
         )
         macro_create_parser = argparse_custom.DEFAULT_ARGUMENT_PARSER(description=macro_create_description)
@@ -3763,15 +3774,15 @@ def _build_macro_create_parser(cls) -> Cmd2ArgumentParser:
                 "first argument will populate both {1} instances."
             ),
             "\n",
-            Text("    macro create ft file_taxes -p {1} -q {2} -r {1}", style=Cmd2Style.EXAMPLE),
+            Text("    macro create ft file_taxes -p {1} -q {2} -r {1}", style=Cmd2Style.COMMAND_LINE),
             "\n",
             "To quote an argument in the resolved command, quote it during creation.",
             "\n",
-            Text("    macro create backup !cp \"{1}\" \"{1}.orig\"", style=Cmd2Style.EXAMPLE),
+            Text("    macro create backup !cp \"{1}\" \"{1}.orig\"", style=Cmd2Style.COMMAND_LINE),
             "\n",
             "If you want to use redirection, pipes, or terminators in the value of the macro, then quote them.",
             "\n",
-            Text("    macro create show_results print_results -type {1} \"|\" less", style=Cmd2Style.EXAMPLE),
+            Text("    macro create show_results print_results -type {1} \"|\" less", style=Cmd2Style.COMMAND_LINE),
             "\n",
             (
                 "Since macros don't resolve until after you press Enter, their arguments tab complete as paths. "
@@ -5316,7 +5327,7 @@ def _build_edit_parser(cls) -> Cmd2ArgumentParser:
             "Note",
             Text.assemble(
                 "To set a new editor, run: ",
-                ("set editor <program>", Cmd2Style.EXAMPLE),
+                ("set editor <program>", Cmd2Style.COMMAND_LINE),
             ),
         )
 

cmd2/rich_utils.py

@@ -45,7 +45,7 @@ def __repr__(self) -> str:
 
 
 def _create_default_theme() -> Theme:
-    """Create a default theme for cmd2-based applications.
+    """Create a default theme for the application.
 
     This theme combines the default styles from cmd2, rich-argparse, and Rich.
     """
@@ -79,8 +79,7 @@ def set_theme(styles: Mapping[str, StyleType] | None = None) -> None:
         RichHelpFormatter.styles[name] = APP_THEME.styles[name]
 
 
-# The main theme for cmd2-based applications.
-# You can change it with set_theme().
+# The application-wide theme. You can change it with set_theme().
 APP_THEME = _create_default_theme()
 
 
@@ -107,12 +106,22 @@ class RichPrintKwargs(TypedDict, total=False):
 
 
 class Cmd2BaseConsole(Console):
-    """A base class for Rich consoles in cmd2-based applications."""
+    """Base class for all cmd2 Rich consoles.
 
-    def __init__(self, file: IO[str] | None = None, **kwargs: Any) -> None:
+    This class handles the core logic for managing Rich behavior based on
+    cmd2's global settings, such as `ALLOW_STYLE` and `APP_THEME`.
+    """
+
+    def __init__(
+        self,
+        file: IO[str] | None = None,
+        **kwargs: Any,
+    ) -> None:
         """Cmd2BaseConsole initializer.
 
-        :param file: optional file object where the console should write to. Defaults to sys.stdout.
+        :param file: optional file object where the console should write to.
+                     Defaults to sys.stdout.
+        :param kwargs: keyword arguments passed to the parent Console class.
         """
         # Don't allow force_terminal or force_interactive to be passed in, as their
         # behavior is controlled by the ALLOW_STYLE setting.
@@ -160,12 +169,13 @@ def on_broken_pipe(self) -> None:
 
 
 class Cmd2GeneralConsole(Cmd2BaseConsole):
-    """Rich console for general-purpose printing in cmd2-based applications."""
+    """Rich console for general-purpose printing."""
 
     def __init__(self, file: IO[str] | None = None) -> None:
         """Cmd2GeneralConsole initializer.
 
-        :param file: optional file object where the console should write to. Defaults to sys.stdout.
+        :param file: optional file object where the console should write to.
+                     Defaults to sys.stdout.
         """
         # This console is configured for general-purpose printing. It enables soft wrap
         # and disables Rich's automatic processing for markup, emoji, and highlighting.
@@ -180,13 +190,20 @@ def __init__(self, file: IO[str] | None = None) -> None:
 
 
 class Cmd2RichArgparseConsole(Cmd2BaseConsole):
-    """Rich console for rich-argparse output in cmd2-based applications.
+    """Rich console for rich-argparse output.
 
     This class ensures long lines in help text are not truncated by avoiding soft_wrap,
     which conflicts with rich-argparse's explicit no_wrap and overflow settings.
     """
 
 
+class Cmd2ExceptionConsole(Cmd2BaseConsole):
+    """Rich console for printing exceptions.
+
+    Ensures that long exception messages word wrap for readability by keeping soft_wrap disabled.
+    """
+
+
 def console_width() -> int:
     """Return the width of the console."""
     return Cmd2BaseConsole().width

cmd2/styles.py

@@ -30,8 +30,9 @@ class Cmd2Style(StrEnum):
     added here must have a corresponding style definition there.
     """
 
+    COMMAND_LINE = "cmd2.example"  # Command line examples in help text
     ERROR = "cmd2.error"  # Error text (used by perror())
-    EXAMPLE = "cmd2.example"  # Command line examples in help text
+    EXCEPTION_TYPE = "cmd2.exception.type"  # Used by pexcept to mark an exception type
     HELP_HEADER = "cmd2.help.header"  # Help table header text
     HELP_LEADER = "cmd2.help.leader"  # Text right before the help tables are listed
     SUCCESS = "cmd2.success"  # Success text (used by psuccess())
@@ -41,8 +42,9 @@ class Cmd2Style(StrEnum):
 
 # Default styles used by cmd2. Tightly coupled with the Cmd2Style enum.
 DEFAULT_CMD2_STYLES: dict[str, StyleType] = {
+    Cmd2Style.COMMAND_LINE: Style(color=Color.CYAN, bold=True),
     Cmd2Style.ERROR: Style(color=Color.BRIGHT_RED),
-    Cmd2Style.EXAMPLE: Style(color=Color.CYAN, bold=True),
+    Cmd2Style.EXCEPTION_TYPE: Style(color=Color.DARK_ORANGE, bold=True),
     Cmd2Style.HELP_HEADER: Style(color=Color.BRIGHT_GREEN, bold=True),
     Cmd2Style.HELP_LEADER: Style(color=Color.CYAN, bold=True),
     Cmd2Style.SUCCESS: Style(color=Color.GREEN),

tests/test_cmd2.py

@@ -906,29 +906,14 @@ def test_base_timing(base_app) -> None:
         assert err[0].startswith('Elapsed: 0:00:00.0')
 
 
-def _expected_no_editor_error():
-    expected_exception = 'OSError'
-    # If PyPy, expect a different exception than with Python 3
-    if hasattr(sys, "pypy_translation_info"):
-        expected_exception = 'EnvironmentError'
-
-    return normalize(
-        f"""
-EXCEPTION of type '{expected_exception}' occurred with message: Please use 'set editor' to specify your text editing program of choice.
-To enable full traceback, run the following command: 'set debug true'
-"""
-    )
-
-
 def test_base_debug(base_app) -> None:
     # Purposely set the editor to None
     base_app.editor = None
 
     # Make sure we get an exception, but cmd2 handles it
     out, err = run_cmd(base_app, 'edit')
-
-    expected = _expected_no_editor_error()
-    assert err == expected
+    assert "EXCEPTION of type" in err[0]
+    assert "Please use 'set editor'" in err[0]
 
     # Set debug true
     out, err = run_cmd(base_app, 'set debug True')
@@ -2589,7 +2574,9 @@ def test_pexcept_style(base_app, capsys) -> None:
 
     base_app.pexcept(msg)
     out, err = capsys.readouterr()
-    assert err.startswith("\x1b[91mEXCEPTION of type 'Exception' occurred with message: testing")
+    expected = su.stylize("EXCEPTION of type ", style=Cmd2Style.ERROR)
+    expected += su.stylize("Exception", style=Cmd2Style.EXCEPTION_TYPE)
+    assert err.startswith(expected)
 
 
 @with_ansi_style(ru.AllowStyle.NEVER)
@@ -2598,17 +2585,17 @@ def test_pexcept_no_style(base_app, capsys) -> None:
 
     base_app.pexcept(msg)
     out, err = capsys.readouterr()
-    assert err.startswith("EXCEPTION of type 'Exception' occurred with message: testing...")
+    assert err.startswith("EXCEPTION of type Exception occurred with message: testing...")
 
 
-@with_ansi_style(ru.AllowStyle.ALWAYS)
+@with_ansi_style(ru.AllowStyle.NEVER)
 def test_pexcept_not_exception(base_app, capsys) -> None:
     # Pass in a msg that is not an Exception object
     msg = False
 
     base_app.pexcept(msg)
     out, err = capsys.readouterr()
-    assert err.startswith("\x1b[91mEXCEPTION of type 'bool' occurred with message: False")
+    assert err.startswith("EXCEPTION of type bool occurred with message: False")
 
 
 @pytest.mark.parametrize('chop', [True, False])