cmd2 3.3.0__tar.gz → 3.5.0__tar.gz

{cmd2-3.3.0 → cmd2-3.5.0}/CHANGELOG.md

@@ -1,4 +1,21 @@
-# 3.3.0 (March 1, 2026)
+## 3.5.0 (April 13, 2026)
+
+- Bug Fixes
+    - Fixed issue where Rich stripped colors from text in test environments where TERM=dumb.
+
+## 3.4.0 (March 3, 2026)
+
+- Enhancements
+    - Moved cmd2-specific printing logic from `Cmd.print_to()` into `Cmd2BaseConsole.print()` and
+      `Cmd2BaseConsole.log()`. This removes need to pass a console object to `Cmd.print_to()`.
+    - Addressed a bug in `rich.console.Console` where complex renderables (like `Table` and `Rule`)
+      may not receive formatting settings passed to `console.print()` and `console.log()`.
+
+- Breaking Changes
+    - Renamed the `destination` parameter of `Cmd.print_to()` back to `file` since you can no longer
+      pass in a console.
+
+## 3.3.0 (March 1, 2026)
 
 - Enhancements
     - Added ability to pass a console object to `Cmd.print_to()`. This provides support for things

{cmd2-3.3.0 → cmd2-3.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmd2
-Version: 3.3.0
+Version: 3.5.0
 Summary: cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python
 Author: cmd2 Contributors
 License-Expression: MIT
@@ -26,8 +26,8 @@ Requires-Dist: backports.strenum; python_version == "3.10"
 Requires-Dist: gnureadline>=8; platform_system == "Darwin"
 Requires-Dist: pyperclip>=1.8.2
 Requires-Dist: pyreadline3>=3.4; platform_system == "Windows"
-Requires-Dist: rich>=14.3.0
-Requires-Dist: rich-argparse>=1.7.1
+Requires-Dist: rich>=15.0.0
+Requires-Dist: rich-argparse>=1.7.2
 Requires-Dist: typing-extensions; python_version == "3.10"
 Dynamic: license-file
 

{cmd2-3.3.0 → cmd2-3.5.0}/cmd2/argparse_completer.py

@@ -368,7 +368,7 @@ class ArgparseCompleter:
                     action = remaining_positionals.popleft()
 
                     # Are we at a subcommand? If so, forward to the matching completer
-                    if action == self._subcommand_action:
+                    if self._subcommand_action is not None and action == self._subcommand_action:
                         if token in self._subcommand_action.choices:
                             # Merge self._parent_tokens and consumed_arg_values
                             parent_tokens = {**self._parent_tokens, **consumed_arg_values}

{cmd2-3.3.0 → cmd2-3.5.0}/cmd2/argparse_custom.py

@@ -1361,10 +1361,10 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
 
         self.print_usage(sys.stderr)
 
-        # Add error style to message
+        # Use console to add style since it will respect ALLOW_STYLE's value
         console = self._get_formatter().console
         with console.capture() as capture:
-            console.print(formatted_message, style=Cmd2Style.ERROR, crop=False)
+            console.print(formatted_message, style=Cmd2Style.ERROR)
         formatted_message = f"{capture.get()}"
 
         self.exit(2, f'{formatted_message}\n')

{cmd2-3.3.0 → cmd2-3.5.0}/cmd2/cmd2.py

@@ -66,7 +66,6 @@ from typing import (
 
 import rich.box
 from rich.console import (
-    Console,
     Group,
     RenderableType,
 )
@@ -1252,66 +1251,30 @@ class Cmd:
 
     def print_to(
         self,
-        destination: IO[str] | Cmd2BaseConsole,
+        file: IO[str],
         *objects: Any,
         sep: str = " ",
         end: str = "\n",
         style: StyleType | None = None,
-        soft_wrap: bool | None = None,
-        emoji: bool | None = None,
-        markup: bool | None = None,
-        highlight: bool | None = None,
+        soft_wrap: bool = True,
+        emoji: bool = False,
+        markup: bool = False,
+        highlight: bool = False,
         rich_print_kwargs: RichPrintKwargs | None = None,
         **kwargs: Any,  # noqa: ARG002
     ) -> None:
-        """Print objects to a given destination (file stream or cmd2 console).
-
-        If ``destination`` is a file-like object, it is wrapped in a ``Cmd2GeneralConsole``
-        which is configured for general-purpose printing. By default, it enables soft wrap and
-        disables Rich's automatic detection for markup, emoji, and highlighting. These defaults
-        can be overridden by passing explicit keyword arguments.
-
-        If ``destination`` is a ``Cmd2BaseConsole``, the console's default settings for
-        soft wrap, markup, emoji, and highlighting are used unless overridden by passing
-        explicit keyword arguments.
-
-        See the Rich documentation for more details on emoji codes, markup tags, and highlighting.
-
-        **Why use this method instead of console.print()?**
-
-        This method calls ``cmd2.rich_utils.prepare_objects_for_rendering()`` on the objects
-        being printed. This ensures that strings containing ANSI style sequences are converted
-        to Rich Text objects, so that Rich can correctly calculate their display width when
-        printing.
-
-        Example:
-        ```py
-        with console.capture() as capture:
-            self.print_to(console, some_ansi_styled_string)
-        ```
-
-        !!! note
-
-            To ensure consistent behavior, this method requires a file-like object or
-            an instance of ``Cmd2BaseConsole``.
-            Consoles not derived from ``Cmd2BaseConsole`` are disallowed because:
+        """Print objects to a given file stream.
 
-            1. **Style Control**: They ignore the global ``ALLOW_STYLE`` setting.
-            2. **Theming**: They do not respect the application-wide ``APP_THEME``.
-            3. **Error Handling**: They trigger a ``SystemExit`` on broken pipes.
-               ``Cmd2BaseConsole`` instead raises a catchable ``BrokenPipeError``,
-               ensuring the CLI application remains alive if a pipe is closed.
+        This method is configured for general-purpose printing. By default, it enables
+        soft wrap and disables Rich's automatic detection for markup, emoji, and highlighting.
+        These defaults can be overridden by passing explicit keyword arguments.
 
-        :param destination: The output target. File-like objects are automatically
-                            wrapped in a ``Cmd2GeneralConsole`` to ensure they respect
-                            cmd2 global settings; otherwise, this must be an
-                            instance of ``Cmd2BaseConsole``.
+        :param file: file stream being written to
         :param objects: objects to print
         :param sep: string to write between printed text. Defaults to " ".
         :param end: string to write at end of printed text. Defaults to a newline.
         :param style: optional style to apply to output
-        :param soft_wrap: Enable soft wrap mode. Defaults to None.
-                          If None, the destination console's default behavior is used.
+        :param soft_wrap: Enable soft wrap mode. Defaults to True.
                           If True, text that doesn't fit will run on to the following line,
                           just like with print(). This is useful for raw text and logs.
                           If False, Rich wraps text to fit the terminal width.
@@ -1320,44 +1283,23 @@ class Cmd:
                           For example, when soft_wrap is True Panels truncate text
                           which is wider than the terminal.
         :param emoji: If True, Rich will replace emoji codes (e.g., :smiley:) with their
-                      corresponding Unicode characters. Defaults to None.
-                      If None, the destination console's default behavior is used.
+                      corresponding Unicode characters. Defaults to False.
         :param markup: If True, Rich will interpret strings with tags (e.g., [bold]hello[/bold])
-                       as styled output. Defaults to None.
-                       If None, the destination console's default behavior is used.
+                       as styled output. Defaults to False.
         :param highlight: If True, Rich will automatically apply highlighting to elements within
                           strings, such as common Python data types like numbers, booleans, or None.
                           This is particularly useful when pretty printing objects like lists and
-                          dictionaries to display them in color. Defaults to None.
-                          If None, the destination console's default behavior is used.
+                          dictionaries to display them in color. Defaults to False.
         :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.
                        These arguments are not passed to Rich's Console.print().
-        :raises TypeError: If ``destination`` is a non-cmd2 ``Console`` instance that
-                           does not derive from ``Cmd2BaseConsole``.
 
+        See the Rich documentation for more details on emoji codes, markup tags, and highlighting.
         """
-        if isinstance(destination, Console):
-            if not isinstance(destination, Cmd2BaseConsole):
-                # Explicitly reject non-cmd2 consoles to ensure safe behavior
-                raise TypeError(
-                    f"destination must be a 'Cmd2BaseConsole' or a file-like object, "
-                    f"not a non-cmd2 '{type(destination).__name__}'. "
-                    "Consoles not derived from 'Cmd2BaseConsole' bypass cmd2's "
-                    "'ALLOW_STYLE' logic, 'APP_THEME' settings, and trigger 'SystemExit' "
-                    "on broken pipes."
-                )
-            console = destination
-        else:
-            # It's a file-like object (e.g., sys.stdout, StringIO)
-            console = Cmd2GeneralConsole(file=destination)
-
-        prepared_objects = ru.prepare_objects_for_rendering(*objects)
-
         try:
-            console.print(
-                *prepared_objects,
+            Cmd2BaseConsole(file=file).print(
+                *objects,
                 sep=sep,
                 end=end,
                 style=style,
@@ -1373,7 +1315,7 @@ class Cmd:
             # writing. 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 and console.file != sys.stderr:
+            if self.broken_pipe_warning and file != sys.stderr:
                 Cmd2GeneralConsole(file=sys.stderr).print(self.broken_pipe_warning)
 
     def poutput(
@@ -1382,10 +1324,10 @@ class Cmd:
         sep: str = " ",
         end: str = "\n",
         style: StyleType | None = None,
-        soft_wrap: bool | None = None,
-        emoji: bool | None = None,
-        markup: bool | None = None,
-        highlight: bool | None = None,
+        soft_wrap: bool = True,
+        emoji: bool = False,
+        markup: bool = False,
+        highlight: bool = False,
         rich_print_kwargs: RichPrintKwargs | None = None,
         **kwargs: Any,  # noqa: ARG002
     ) -> None:
@@ -1412,10 +1354,10 @@ class Cmd:
         sep: str = " ",
         end: str = "\n",
         style: StyleType | None = Cmd2Style.ERROR,
-        soft_wrap: bool | None = None,
-        emoji: bool | None = None,
-        markup: bool | None = None,
-        highlight: bool | None = None,
+        soft_wrap: bool = True,
+        emoji: bool = False,
+        markup: bool = False,
+        highlight: bool = False,
         rich_print_kwargs: RichPrintKwargs | None = None,
         **kwargs: Any,  # noqa: ARG002
     ) -> None:
@@ -1443,10 +1385,10 @@ class Cmd:
         *objects: Any,
         sep: str = " ",
         end: str = "\n",
-        soft_wrap: bool | None = None,
-        emoji: bool | None = None,
-        markup: bool | None = None,
-        highlight: bool | None = None,
+        soft_wrap: bool = True,
+        emoji: bool = False,
+        markup: bool = False,
+        highlight: bool = False,
         rich_print_kwargs: RichPrintKwargs | None = None,
         **kwargs: Any,  # noqa: ARG002
     ) -> None:
@@ -1471,10 +1413,10 @@ class Cmd:
         *objects: Any,
         sep: str = " ",
         end: str = "\n",
-        soft_wrap: bool | None = None,
-        emoji: bool | None = None,
-        markup: bool | None = None,
-        highlight: bool | None = None,
+        soft_wrap: bool = True,
+        emoji: bool = False,
+        markup: bool = False,
+        highlight: bool = False,
         rich_print_kwargs: RichPrintKwargs | None = None,
         **kwargs: Any,  # noqa: ARG002
     ) -> None:
@@ -1554,10 +1496,10 @@ class Cmd:
         sep: str = " ",
         end: str = "\n",
         style: StyleType | None = None,
-        soft_wrap: bool | None = None,
-        emoji: bool | None = None,
-        markup: bool | None = None,
-        highlight: bool | None = None,
+        soft_wrap: bool = True,
+        emoji: bool = False,
+        markup: bool = False,
+        highlight: bool = False,
         rich_print_kwargs: RichPrintKwargs | None = None,
         **kwargs: Any,  # noqa: ARG002
     ) -> None:
@@ -1602,9 +1544,9 @@ class Cmd:
         style: StyleType | None = None,
         chop: bool = False,
         soft_wrap: bool = True,
-        emoji: bool | None = None,
-        markup: bool | None = None,
-        highlight: bool | None = None,
+        emoji: bool = False,
+        markup: bool = False,
+        highlight: bool = False,
         rich_print_kwargs: RichPrintKwargs | None = None,
         **kwargs: Any,  # noqa: ARG002
     ) -> None:
@@ -1646,10 +1588,9 @@ class Cmd:
                 soft_wrap = True
 
             # Generate the bytes to send to the pager
-            console = Cmd2GeneralConsole(file=self.stdout)
+            console = Cmd2BaseConsole(file=self.stdout)
             with console.capture() as capture:
-                self.print_to(
-                    console,
+                console.print(
                     *objects,
                     sep=sep,
                     end=end,

{cmd2-3.3.0 → cmd2-3.5.0}/cmd2/rich_utils.py

@@ -1,6 +1,7 @@
 """Provides common utilities to support Rich in cmd2-based applications."""
 
 import re
+import threading
 from collections.abc import Mapping
 from enum import Enum
 from typing import (
@@ -135,8 +136,9 @@ class Cmd2BaseConsole(Console):
         :param kwargs: keyword arguments passed to the parent Console class.
         :raises TypeError: if disallowed keyword argument is passed in.
         """
-        # Don't allow force_terminal or force_interactive to be passed in, as their
-        # behavior is controlled by the ALLOW_STYLE setting.
+        # These settings are controlled by the ALLOW_STYLE setting and cannot be overridden.
+        if "color_system" in kwargs:
+            raise TypeError("Passing 'color_system' is not allowed. Its behavior is controlled by the 'ALLOW_STYLE' setting.")
         if "force_terminal" in kwargs:
             raise TypeError(
                 "Passing 'force_terminal' is not allowed. Its behavior is controlled by the 'ALLOW_STYLE' setting."
@@ -156,29 +158,175 @@ class Cmd2BaseConsole(Console):
 
         force_terminal: bool | None = None
         force_interactive: bool | None = None
+        allow_style = False
 
         if ALLOW_STYLE == AllowStyle.ALWAYS:
             force_terminal = True
+            allow_style = True
 
             # Turn off interactive mode if dest is not actually a terminal which supports it
             tmp_console = Console(file=file)
             force_interactive = tmp_console.is_interactive
+        elif ALLOW_STYLE == AllowStyle.TERMINAL:
+            tmp_console = Console(file=file)
+            allow_style = tmp_console.is_terminal
         elif ALLOW_STYLE == AllowStyle.NEVER:
             force_terminal = False
 
         super().__init__(
             file=file,
+            color_system="truecolor" if allow_style else None,
             force_terminal=force_terminal,
             force_interactive=force_interactive,
             theme=APP_THEME,
             **kwargs,
         )
+        self._thread_local = threading.local()
 
     def on_broken_pipe(self) -> None:
         """Override which raises BrokenPipeError instead of SystemExit."""
         self.quiet = True
         raise BrokenPipeError
 
+    def render_str(
+        self,
+        text: str,
+        highlight: bool | None = None,
+        markup: bool | None = None,
+        emoji: bool | None = None,
+        **kwargs: Any,
+    ) -> Text:
+        """Override to ensure formatting overrides passed to print() and log() are respected."""
+        if emoji is None:
+            emoji = getattr(self._thread_local, "emoji", None)
+        if markup is None:
+            markup = getattr(self._thread_local, "markup", None)
+        if highlight is None:
+            highlight = getattr(self._thread_local, "highlight", None)
+
+        return super().render_str(text, highlight=highlight, markup=markup, emoji=emoji, **kwargs)
+
+    def print(
+        self,
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+        style: StyleType | None = None,
+        justify: JustifyMethod | None = None,
+        overflow: OverflowMethod | None = None,
+        no_wrap: bool | None = None,
+        emoji: bool | None = None,
+        markup: bool | None = None,
+        highlight: bool | None = None,
+        width: int | None = None,
+        height: int | None = None,
+        crop: bool = True,
+        soft_wrap: bool | None = None,
+        new_line_start: bool = False,
+    ) -> None:
+        """Override to support ANSI sequences and address a bug in Rich.
+
+        This method calls [cmd2.rich_utils.prepare_objects_for_rendering][] on the
+        objects being printed. This ensures that strings containing ANSI style
+        sequences are converted to Rich Text objects, so that Rich can correctly
+        calculate their display width.
+
+        Additionally, it works around a bug in Rich where complex renderables
+        (like Table and Rule) may not receive formatting settings passed to print().
+        By temporarily injecting these settings into thread-local storage, we ensure
+        that all internal rendering calls within the print() operation respect the
+        requested overrides.
+
+        There is an issue on Rich to fix the latter:
+        https://github.com/Textualize/rich/issues/4028
+        """
+        prepared_objects = prepare_objects_for_rendering(*objects)
+
+        # Inject overrides into thread-local storage
+        self._thread_local.emoji = emoji
+        self._thread_local.markup = markup
+        self._thread_local.highlight = highlight
+
+        try:
+            super().print(
+                *prepared_objects,
+                sep=sep,
+                end=end,
+                style=style,
+                justify=justify,
+                overflow=overflow,
+                no_wrap=no_wrap,
+                emoji=emoji,
+                markup=markup,
+                highlight=highlight,
+                width=width,
+                height=height,
+                crop=crop,
+                soft_wrap=soft_wrap,
+                new_line_start=new_line_start,
+            )
+        finally:
+            # Clear overrides from thread-local storage
+            self._thread_local.emoji = None
+            self._thread_local.markup = None
+            self._thread_local.highlight = None
+
+    def log(
+        self,
+        *objects: Any,
+        sep: str = " ",
+        end: str = "\n",
+        style: StyleType | None = None,
+        justify: JustifyMethod | None = None,
+        emoji: bool | None = None,
+        markup: bool | None = None,
+        highlight: bool | None = None,
+        log_locals: bool = False,
+        _stack_offset: int = 1,
+    ) -> None:
+        """Override to support ANSI sequences and address a bug in Rich.
+
+        This method calls [cmd2.rich_utils.prepare_objects_for_rendering][] on the
+        objects being logged. This ensures that strings containing ANSI style
+        sequences are converted to Rich Text objects, so that Rich can correctly
+        calculate their display width.
+
+        Additionally, it works around a bug in Rich where complex renderables
+        (like Table and Rule) may not receive formatting settings passed to log().
+        By temporarily injecting these settings into thread-local storage, we ensure
+        that all internal rendering calls within the log() operation respect the
+        requested overrides.
+
+        There is an issue on Rich to fix the latter:
+        https://github.com/Textualize/rich/issues/4028
+        """
+        prepared_objects = prepare_objects_for_rendering(*objects)
+
+        # Inject overrides into thread-local storage
+        self._thread_local.emoji = emoji
+        self._thread_local.markup = markup
+        self._thread_local.highlight = highlight
+
+        try:
+            # Increment _stack_offset because we added this wrapper frame
+            super().log(
+                *prepared_objects,
+                sep=sep,
+                end=end,
+                style=style,
+                justify=justify,
+                emoji=emoji,
+                markup=markup,
+                highlight=highlight,
+                log_locals=log_locals,
+                _stack_offset=_stack_offset + 1,
+            )
+        finally:
+            # Clear overrides from thread-local storage
+            self._thread_local.emoji = None
+            self._thread_local.markup = None
+            self._thread_local.highlight = None
+
 
 class Cmd2GeneralConsole(Cmd2BaseConsole):
     """Rich console for general-purpose printing.
@@ -271,11 +419,9 @@ def rich_text_to_string(text: Text) -> str:
     """
     console = Console(
         force_terminal=True,
+        color_system="truecolor",
         soft_wrap=True,
         no_color=False,
-        markup=False,
-        emoji=False,
-        highlight=False,
         theme=APP_THEME,
     )
     with console.capture() as capture:
@@ -339,64 +485,3 @@ def prepare_objects_for_rendering(*objects: Any) -> tuple[Any, ...]:
             object_list[i] = Text.from_ansi(renderable_as_str)
 
     return tuple(object_list)
-
-
-###################################################################################
-# Rich Library Monkey Patches
-#
-# These patches fix specific bugs in the Rich library. They are conditional and
-# will only be applied if the bug is detected. When the bugs are fixed in a
-# future Rich release, these patches and their corresponding tests should be
-# removed.
-###################################################################################
-
-###################################################################################
-# Text.from_ansi() monkey patch
-###################################################################################
-
-# Save original Text.from_ansi() so we can call it in our wrapper
-_orig_text_from_ansi = Text.from_ansi
-
-
-@classmethod  # type: ignore[misc]
-def _from_ansi_wrapper(cls: type[Text], text: str, *args: Any, **kwargs: Any) -> Text:  # noqa: ARG001
-    r"""Wrap Text.from_ansi() to fix its trailing newline bug.
-
-    This wrapper handles an issue where Text.from_ansi() removes the
-    trailing line break from a string (e.g. "Hello\n" becomes "Hello").
-
-    There is currently a pull request on Rich to fix this.
-    https://github.com/Textualize/rich/pull/3793
-    """
-    result = _orig_text_from_ansi(text, *args, **kwargs)
-
-    # If the original string ends with a recognized line break character,
-    # then restore the missing newline. We use "\n" because Text.from_ansi()
-    # converts all line breaks into newlines.
-    # Source: https://docs.python.org/3/library/stdtypes.html#str.splitlines
-    line_break_chars = {
-        "\n",  # Line Feed
-        "\r",  # Carriage Return
-        "\v",  # Vertical Tab
-        "\f",  # Form Feed
-        "\x1c",  # File Separator
-        "\x1d",  # Group Separator
-        "\x1e",  # Record Separator
-        "\x85",  # Next Line (NEL)
-        "\u2028",  # Line Separator
-        "\u2029",  # Paragraph Separator
-    }
-    if text and text[-1] in line_break_chars:
-        result.append("\n")
-
-    return result
-
-
-def _from_ansi_has_newline_bug() -> bool:
-    """Check if Test.from_ansi() strips the trailing line break from a string."""
-    return Text.from_ansi("\n") == Text.from_ansi("")
-
-
-# Only apply the monkey patch if the bug is present
-if _from_ansi_has_newline_bug():
-    Text.from_ansi = _from_ansi_wrapper  # type: ignore[assignment]

{cmd2-3.3.0 → cmd2-3.5.0}/cmd2/utils.py

@@ -75,7 +75,7 @@ class Settable:
         settable_object: object,
         *,
         settable_attrib_name: str | None = None,
-        onchange_cb: Callable[[str, _T, _T], Any] | None = None,
+        onchange_cb: Callable[[str, Any, Any], Any] | None = None,
         choices: Iterable[Any] | None = None,
         choices_provider: ChoicesProviderFunc | None = None,
         completer: CompleterFunc | None = None,

{cmd2-3.3.0 → cmd2-3.5.0}/cmd2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmd2
-Version: 3.3.0
+Version: 3.5.0
 Summary: cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python
 Author: cmd2 Contributors
 License-Expression: MIT
@@ -26,8 +26,8 @@ Requires-Dist: backports.strenum; python_version == "3.10"
 Requires-Dist: gnureadline>=8; platform_system == "Darwin"
 Requires-Dist: pyperclip>=1.8.2
 Requires-Dist: pyreadline3>=3.4; platform_system == "Windows"
-Requires-Dist: rich>=14.3.0
-Requires-Dist: rich-argparse>=1.7.1
+Requires-Dist: rich>=15.0.0
+Requires-Dist: rich-argparse>=1.7.2
 Requires-Dist: typing-extensions; python_version == "3.10"
 Dynamic: license-file
 

{cmd2-3.3.0 → cmd2-3.5.0}/cmd2.egg-info/SOURCES.txt

@@ -119,7 +119,6 @@ examples/argparse_example.py
 examples/async_call.py
 examples/async_printing.py
 examples/basic_completion.py
-examples/cmd2_history.dat
 examples/cmd_as_argument.py
 examples/color.py
 examples/command_sets.py

{cmd2-3.3.0 → cmd2-3.5.0}/cmd2.egg-info/requires.txt

@@ -1,6 +1,6 @@
 pyperclip>=1.8.2
-rich>=14.3.0
-rich-argparse>=1.7.1
+rich>=15.0.0
+rich-argparse>=1.7.2
 
 [:platform_system == "Darwin"]
 gnureadline>=8

{cmd2-3.3.0 → cmd2-3.5.0}/pyproject.toml

@@ -33,8 +33,8 @@ dependencies = [
     "gnureadline>=8; platform_system == 'Darwin'",
     "pyperclip>=1.8.2",
     "pyreadline3>=3.4; platform_system == 'Windows'",
-    "rich>=14.3.0",
-    "rich-argparse>=1.7.1",
+    "rich>=15.0.0",
+    "rich-argparse>=1.7.2",
     "typing-extensions; python_version == '3.10'",
 ]