cmd2 3.0.0rc1__py3-none-any.whl → 3.1.1__py3-none-any.whl

cmd2/argparse_completer.py

@@ -39,7 +39,7 @@ from .exceptions import CompletionError
 from .styles import Cmd2Style
 
 # If no descriptive headers are supplied, then this will be used instead
-DEFAULT_DESCRIPTIVE_HEADERS: Sequence[str | Column] = ('Description',)
+DEFAULT_DESCRIPTIVE_HEADERS: Sequence[str | Column] = ['Description']
 
 # Name of the choice/completer function argument that, if present, will be passed a dictionary of
 # command line tokens up through the token being completed mapped to their argparse destination name.

cmd2/argparse_custom.py

@@ -258,14 +258,11 @@ sub-parser from a sub-parsers group. See _SubParsersAction_remove_parser` for mo
 import argparse
 import re
 import sys
-from argparse import (
-    ONE_OR_MORE,
-    ZERO_OR_MORE,
-    ArgumentError,
-)
+from argparse import ArgumentError
 from collections.abc import (
     Callable,
     Iterable,
+    Iterator,
     Sequence,
 )
 from gettext import gettext
@@ -293,6 +290,7 @@ from rich_argparse import (
     RawTextRichHelpFormatter,
     RichHelpFormatter,
 )
+from typing_extensions import Self
 
 from . import constants
 from . import rich_utils as ru
@@ -380,7 +378,7 @@ class CompletionItem(str):  # noqa: SLOT000
     See header of this file for more information
     """
 
-    def __new__(cls, value: object, *_args: Any, **_kwargs: Any) -> 'CompletionItem':
+    def __new__(cls, value: object, *_args: Any, **_kwargs: Any) -> Self:
         """Responsible for creating and returning a new instance, called before __init__ when an object is instantiated."""
         return super().__new__(cls, value)
 
@@ -804,7 +802,7 @@ def _add_argument_wrapper(
     choices_provider: ChoicesProviderFunc | None = None,
     completer: CompleterFunc | None = None,
     suppress_tab_hint: bool = False,
-    descriptive_headers: list[Column | str] | None = None,
+    descriptive_headers: Sequence[str | Column] | None = None,
     **kwargs: Any,
 ) -> argparse.Action:
     """Wrap ActionsContainer.add_argument() which supports more settings used by cmd2.
@@ -1295,29 +1293,68 @@ class Cmd2HelpFormatter(RichHelpFormatter):
 
         return format_tuple
 
+    def _build_nargs_range_str(self, nargs_range: tuple[int, int | float]) -> str:
+        """Generate nargs range string for help text."""
+        if nargs_range[1] == constants.INFINITY:
+            # {min+}
+            range_str = f"{{{nargs_range[0]}+}}"
+        else:
+            # {min..max}
+            range_str = f"{{{nargs_range[0]}..{nargs_range[1]}}}"
+
+        return range_str
+
     def _format_args(self, action: argparse.Action, default_metavar: str) -> str:
-        """Handle ranged nargs and make other output less verbose."""
+        """Override to handle cmd2's custom nargs formatting.
+
+        All formats in this function need to be handled by _rich_metavar_parts().
+        """
         metavar = self._determine_metavar(action, default_metavar)
         metavar_formatter = self._metavar_formatter(action, default_metavar)
 
         # Handle nargs specified as a range
         nargs_range = action.get_nargs_range()  # type: ignore[attr-defined]
         if nargs_range is not None:
-            range_str = f'{nargs_range[0]}+' if nargs_range[1] == constants.INFINITY else f'{nargs_range[0]}..{nargs_range[1]}'
-
-            return '{}{{{}}}'.format('%s' % metavar_formatter(1), range_str)  # noqa: UP031
-
-        # Make this output less verbose. Do not customize the output when metavar is a
-        # tuple of strings. Allow argparse's formatter to handle that instead.
-        if isinstance(metavar, str):
-            if action.nargs == ZERO_OR_MORE:
-                return '[%s [...]]' % metavar_formatter(1)  # noqa: UP031
-            if action.nargs == ONE_OR_MORE:
-                return '%s [...]' % metavar_formatter(1)  # noqa: UP031
-            if isinstance(action.nargs, int) and action.nargs > 1:
-                return '{}{{{}}}'.format('%s' % metavar_formatter(1), action.nargs)  # noqa: UP031
+            arg_str = '%s' % metavar_formatter(1)  # noqa: UP031
+            range_str = self._build_nargs_range_str(nargs_range)
+            return f"{arg_str}{range_str}"
+
+        # When nargs is just a number, argparse repeats the arg in the help text.
+        # For instance, when nargs=5 the help text looks like: 'command arg arg arg arg arg'.
+        # To make this less verbose, format it like: 'command arg{5}'.
+        # Do not customize the output when metavar is a tuple of strings. Allow argparse's
+        # formatter to handle that instead.
+        if isinstance(metavar, str) and isinstance(action.nargs, int) and action.nargs > 1:
+            arg_str = '%s' % metavar_formatter(1)  # noqa: UP031
+            return f"{arg_str}{{{action.nargs}}}"
+
+        # Fallback to parent for all other cases
+        return super()._format_args(action, default_metavar)
+
+    def _rich_metavar_parts(
+        self,
+        action: argparse.Action,
+        default_metavar: str,
+    ) -> Iterator[tuple[str, bool]]:
+        """Override to handle all cmd2-specific formatting in _format_args()."""
+        metavar = self._determine_metavar(action, default_metavar)
+        metavar_formatter = self._metavar_formatter(action, default_metavar)
 
-        return super()._format_args(action, default_metavar)  # type: ignore[arg-type]
+        # Handle nargs specified as a range
+        nargs_range = action.get_nargs_range()  # type: ignore[attr-defined]
+        if nargs_range is not None:
+            yield "%s" % metavar_formatter(1), True  # noqa: UP031
+            yield self._build_nargs_range_str(nargs_range), False
+            return
+
+        # Handle specific integer nargs (e.g., nargs=5 -> arg{5})
+        if isinstance(metavar, str) and isinstance(action.nargs, int) and action.nargs > 1:
+            yield "%s" % metavar_formatter(1), True  # noqa: UP031
+            yield f"{{{action.nargs}}}", False
+            return
+
+        # Fallback to parent for all other cases
+        yield from super()._rich_metavar_parts(action, default_metavar)
 
 
 class RawDescriptionCmd2HelpFormatter(

cmd2/cmd2.py

@@ -1,24 +1,26 @@
-"""Variant on standard library's cmd with extra features.
-
-To use, simply import cmd2.Cmd instead of cmd.Cmd; use precisely as though you
-were using the standard library's cmd, while enjoying the extra features.
-
-Searchable command history (commands: "history")
-Run commands from file, save to file, edit commands in file
-Multi-line commands
-Special-character shortcut commands (beyond cmd's "?" and "!")
-Settable environment parameters
-Parsing commands with `argparse` argument parsers (flags)
-Redirection to file or paste buffer (clipboard) with > or >>
-Easy transcript-based testing of applications (see examples/transcript_example.py)
-Bash-style ``select`` available
+"""cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python.
+
+cmd2 is a tool for building interactive command line applications in Python. Its goal is to make it quick and easy for
+developers to build feature-rich and user-friendly interactive command line applications. It provides a simple API which
+is an extension of Python's built-in cmd module. cmd2 provides a wealth of features on top of cmd to make your life easier
+and eliminates much of the boilerplate code which would be necessary when using cmd.
+
+Extra features include:
+- Searchable command history (commands: "history")
+- Run commands from file, save to file, edit commands in file
+- Multi-line commands
+- Special-character shortcut commands (beyond cmd's "?" and "!")
+- Settable environment parameters
+- Parsing commands with `argparse` argument parsers (flags)
+- Redirection to file or paste buffer (clipboard) with > or >>
+- Easy transcript-based testing of applications (see examples/transcript_example.py)
+- Bash-style ``select`` available
 
 Note, if self.stdout is different than sys.stdout, then redirection with > and |
 will only work if `self.poutput()` is used in place of `print`.
 
-- Catherine Devlin, Jan 03 2008 - catherinedevlin.blogspot.com
-
-Git repository on GitHub at https://github.com/python-cmd2/cmd2
+GitHub: https://github.com/python-cmd2/cmd2
+Documentation: https://cmd2.readthedocs.io/
 """
 
 # This module has many imports, quite a few of which are only
@@ -26,7 +28,6 @@ Git repository on GitHub at https://github.com/python-cmd2/cmd2
 # import this module, many of these imports are lazy-loaded
 # i.e. we only import the module when we use it.
 import argparse
-import cmd
 import contextlib
 import copy
 import functools
@@ -64,7 +65,7 @@ from typing import (
 )
 
 import rich.box
-from rich.console import Group
+from rich.console import Group, RenderableType
 from rich.highlighter import ReprHighlighter
 from rich.rule import Rule
 from rich.style import Style, StyleType
@@ -286,7 +287,7 @@ class _CommandParsers:
             del self._parsers[full_method_name]
 
 
-class Cmd(cmd.Cmd):
+class Cmd:
     """An easy but powerful framework for writing line-oriented command interpreters.
 
     Extends the Python Standard Library's cmd package by adding a lot of useful features
@@ -304,6 +305,8 @@ class Cmd(cmd.Cmd):
     # List for storing transcript test file names
     testfiles: ClassVar[list[str]] = []
 
+    DEFAULT_PROMPT = '(Cmd) '
+
     def __init__(
         self,
         completekey: str = 'tab',
@@ -326,6 +329,7 @@ class Cmd(cmd.Cmd):
         auto_load_commands: bool = False,
         allow_clipboard: bool = True,
         suggest_similar_command: bool = False,
+        intro: RenderableType = '',
     ) -> None:
         """Easy but powerful framework for writing line-oriented command interpreters, extends Python's cmd package.
 
@@ -376,6 +380,7 @@ class Cmd(cmd.Cmd):
         :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``.
+        "param intro: Intro banner to print when starting the application.
         """
         # Check if py or ipy need to be disabled in this instance
         if not include_py:
@@ -384,11 +389,28 @@ class Cmd(cmd.Cmd):
             setattr(self, 'do_ipy', None)  # noqa: B010
 
         # initialize plugin system
-        # needs to be done before we call __init__(0)
+        # needs to be done before we most of the other stuff below
         self._initialize_plugin_system()
 
-        # Call super class constructor
-        super().__init__(completekey=completekey, stdin=stdin, stdout=stdout)
+        # Configure a few defaults
+        self.prompt = Cmd.DEFAULT_PROMPT
+        self.intro = intro
+        self.use_rawinput = True
+
+        # What to use for standard input
+        if stdin is not None:
+            self.stdin = stdin
+        else:
+            self.stdin = sys.stdin
+
+        # What to use for standard output
+        if stdout is not None:
+            self.stdout = stdout
+        else:
+            self.stdout = sys.stdout
+
+        # Key used for tab completion
+        self.completekey = completekey
 
         # Attributes which should NOT be dynamically settable via the set command at runtime
         self.default_to_shell = False  # Attempt to run unrecognized commands as shell commands
@@ -2412,9 +2434,7 @@ class Cmd(cmd.Cmd):
             if len(self.completion_matches) == 1 and self.allow_closing_quote and completion_token_quote:
                 self.completion_matches[0] += completion_token_quote
 
-    def complete(  # type: ignore[override]
-        self, text: str, state: int, custom_settings: utils.CustomCompletionSettings | None = None
-    ) -> str | None:
+    def complete(self, text: str, state: int, custom_settings: utils.CustomCompletionSettings | None = None) -> str | None:
         """Override of cmd's complete method which returns the next possible completion for 'text'.
 
         This completer function is called by readline as complete(text, state), for state in 0, 1, 2, …,
@@ -2693,10 +2713,6 @@ class Cmd(cmd.Cmd):
     def parseline(self, line: str) -> tuple[str, str, str]:
         """Parse the line into a command name and a string containing the arguments.
 
-        NOTE: This is an override of a parent class method.  It is only used by other parent class methods.
-
-        Different from the parent class method, this ignores self.identchars.
-
         :param line: line read by readline
         :return: tuple containing (command, args, line)
         """
@@ -3086,7 +3102,7 @@ class Cmd(cmd.Cmd):
 
         # Initialize the redirection saved state
         redir_saved_state = utils.RedirectionSavedState(
-            cast(TextIO, self.stdout), stdouts_match, self._cur_pipe_proc_reader, self._redirecting
+            self.stdout, stdouts_match, self._cur_pipe_proc_reader, self._redirecting
         )
 
         # The ProcReader for this command
@@ -3141,7 +3157,7 @@ class Cmd(cmd.Cmd):
                 new_stdout.close()
                 raise RedirectionError(f'Pipe process exited with code {proc.returncode} before command could run')
             redir_saved_state.redirecting = True
-            cmd_pipe_proc_reader = utils.ProcReader(proc, cast(TextIO, self.stdout), sys.stderr)
+            cmd_pipe_proc_reader = utils.ProcReader(proc, self.stdout, sys.stderr)
 
             self.stdout = new_stdout
             if stdouts_match:
@@ -3276,7 +3292,7 @@ class Cmd(cmd.Cmd):
 
         return stop if stop is not None else False
 
-    def default(self, statement: Statement) -> bool | None:  # type: ignore[override]
+    def default(self, statement: Statement) -> bool | None:
         """Execute when the command given isn't a recognized command implemented by a do_* method.
 
         :param statement: Statement object with parsed input
@@ -3293,6 +3309,15 @@ class Cmd(cmd.Cmd):
         self.perror(err_msg, style=None)
         return None
 
+    def completedefault(self, *_ignored: list[str]) -> list[str]:
+        """Call to complete an input line when no command-specific complete_*() method is available.
+
+        This method is only called for non-argparse-based commands.
+
+        By default, it returns an empty list.
+        """
+        return []
+
     def _suggest_similar_command(self, command: str) -> str | None:
         return suggest_similar(command, self.get_visible_commands())
 
@@ -4131,10 +4156,6 @@ class Cmd(cmd.Cmd):
         )
         return help_parser
 
-    # Get rid of cmd's complete_help() functions so ArgparseCompleter will complete the help command
-    if getattr(cmd.Cmd, 'complete_help', None) is not None:
-        delattr(cmd.Cmd, 'complete_help')
-
     @with_argparser(_build_help_parser)
     def do_help(self, args: argparse.Namespace) -> None:
         """List available commands or provide detailed help for a specific command."""
@@ -4640,7 +4661,7 @@ class Cmd(cmd.Cmd):
                 **kwargs,
             )
 
-            proc_reader = utils.ProcReader(proc, cast(TextIO, self.stdout), sys.stderr)
+            proc_reader = utils.ProcReader(proc, self.stdout, sys.stderr)
             proc_reader.wait()
 
             # Save the return code of the application for use in a pyscript
@@ -5029,7 +5050,7 @@ class Cmd(cmd.Cmd):
         history_action_group.add_argument('-e', '--edit', action='store_true', help='edit and then run selected history items')
         history_action_group.add_argument(
             '-o',
-            '--output_file',
+            '--output-file',
             metavar='FILE',
             help='output commands to a script file, implies -s',
             completer=cls.path_complete,
@@ -5359,7 +5380,7 @@ class Cmd(cmd.Cmd):
                 transcript += command
 
                 # Use a StdSim object to capture output
-                stdsim = utils.StdSim(cast(TextIO, self.stdout))
+                stdsim = utils.StdSim(self.stdout)
                 self.stdout = cast(TextIO, stdsim)
 
                 # then run the command and let the output go into our buffer
@@ -5385,7 +5406,7 @@ class Cmd(cmd.Cmd):
             with self.sigint_protection:
                 # Restore altered attributes to their original state
                 self.echo = saved_echo
-                self.stdout = cast(TextIO, saved_stdout)
+                self.stdout = saved_stdout
 
         # Check if all commands ran
         if commands_run < len(history):
@@ -5880,11 +5901,10 @@ class Cmd(cmd.Cmd):
         """
         self.perror(message_to_print, style=None)
 
-    def cmdloop(self, intro: str | None = None) -> int:  # type: ignore[override]
+    def cmdloop(self, intro: RenderableType = '') -> int:
         """Deal with extra features provided by cmd2, this is an outer wrapper around _cmdloop().
 
-        _cmdloop() provides the main loop equivalent to cmd.cmdloop().  This is a wrapper around that which deals with
-        the following extra features provided by cmd2:
+        _cmdloop() provides the main loop.  This provides the following extra features provided by cmd2:
         - transcript testing
         - intro banner
         - exit code
@@ -5922,11 +5942,11 @@ class Cmd(cmd.Cmd):
             self._run_transcript_tests([os.path.expanduser(tf) for tf in self._transcript_files])
         else:
             # If an intro was supplied in the method call, allow it to override the default
-            if intro is not None:
+            if intro:
                 self.intro = intro
 
             # Print the intro, if there is one, right after the preloop
-            if self.intro is not None:
+            if self.intro:
                 self.poutput(self.intro)
 
             # And then call _cmdloop() to enter the main loop

cmd2/parsing.py

@@ -9,6 +9,8 @@ from dataclasses import (
 )
 from typing import Any
 
+from typing_extensions import Self
+
 from . import (
     constants,
     utils,
@@ -105,10 +107,10 @@ class Statement(str):  # noqa: SLOT000
        whether positional or denoted with switches.
 
     2. For commands with simple positional arguments, use
-       [args][cmd2.Statement.args] or [arg_list][cmd2.Statement.arg_list]
+       [args][cmd2.parsing.Statement.args] or [arg_list][cmd2.parsing.Statement.arg_list]
 
     3. If you don't want to have to worry about quoted arguments, see
-       [argv][cmd2.Statement.argv] for a trick which strips quotes off for you.
+       [argv][cmd2.parsing.Statement.argv] for a trick which strips quotes off for you.
     """
 
     # the arguments, but not the command, nor the output redirection clauses.
@@ -144,7 +146,7 @@ class Statement(str):  # noqa: SLOT000
     # Used in JSON dictionaries
     _args_field = 'args'
 
-    def __new__(cls, value: object, *_pos_args: Any, **_kw_args: Any) -> 'Statement':
+    def __new__(cls, value: object, *_pos_args: Any, **_kw_args: Any) -> Self:
         """Create a new instance of Statement.
 
         We must override __new__ because we are subclassing `str` which is
@@ -193,7 +195,7 @@ class Statement(str):  # noqa: SLOT000
 
     @property
     def expanded_command_line(self) -> str:
-        """Concatenate [command_and_args][cmd2.Statement.command_and_args] and [post_command][cmd2.Statement.post_command]."""
+        """Concatenate [cmd2.parsing.Statement.command_and_args]() and [cmd2.parsing.Statement.post_command]()."""
         return self.command_and_args + self.post_command
 
     @property

cmd2/py_bridge.py

@@ -137,7 +137,7 @@ class PyBridge:
                 )
         finally:
             with self._cmd2_app.sigint_protection:
-                self._cmd2_app.stdout = cast(IO[str], copy_cmd_stdout.inner_stream)
+                self._cmd2_app.stdout = cast(TextIO, copy_cmd_stdout.inner_stream)
                 if stdouts_match:
                     sys.stdout = self._cmd2_app.stdout
 

cmd2/rich_utils.py

@@ -1,10 +1,7 @@
 """Provides common utilities to support Rich in cmd2-based applications."""
 
 import re
-from collections.abc import (
-    Iterable,
-    Mapping,
-)
+from collections.abc import Mapping
 from enum import Enum
 from typing import (
     IO,
@@ -22,7 +19,6 @@ from rich.console import (
 from rich.padding import Padding
 from rich.pretty import is_expandable
 from rich.protocol import rich_cast
-from rich.segment import Segment
 from rich.style import StyleType
 from rich.table import (
     Column,
@@ -380,72 +376,3 @@ def _from_ansi_has_newline_bug() -> bool:
 # 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]
-
-
-###################################################################################
-# Segment.apply_style() monkey patch
-###################################################################################
-
-# Save original Segment.apply_style() so we can call it in our wrapper
-_orig_segment_apply_style = Segment.apply_style
-
-
-@classmethod  # type: ignore[misc]
-def _apply_style_wrapper(cls: type[Segment], *args: Any, **kwargs: Any) -> Iterable["Segment"]:
-    r"""Wrap Segment.apply_style() to fix bug with styling newlines.
-
-    This wrapper handles an issue where Segment.apply_style() includes newlines
-    within styled Segments. As a result, when printing text using a background color
-    and soft wrapping, the background color incorrectly carries over onto the following line.
-
-    You can reproduce this behavior by calling console.print() using a background color
-    and soft wrapping.
-
-    For example:
-        console.print("line_1", style="blue on white", soft_wrap=True)
-
-    When soft wrapping is disabled, console.print() splits Segments into their individual
-    lines, which separates the newlines from the styled text. Therefore, the background color
-    issue does not occur in that mode.
-
-    This function copies that behavior to fix this the issue even when soft wrapping is enabled.
-
-    There is currently a pull request on Rich to fix this.
-    https://github.com/Textualize/rich/pull/3839
-    """
-    styled_segments = list(_orig_segment_apply_style(*args, **kwargs))
-    newline_segment = cls.line()
-
-    # If the final segment ends in a newline, that newline will be stripped by Segment.split_lines().
-    # Save an unstyled newline to restore later.
-    end_segment = newline_segment if styled_segments and styled_segments[-1].text.endswith("\n") else None
-
-    # Use Segment.split_lines() to separate the styled text from the newlines.
-    # This way the ANSI reset code will appear before any newline.
-    sanitized_segments: list[Segment] = []
-
-    lines = list(Segment.split_lines(styled_segments))
-    for index, line in enumerate(lines):
-        sanitized_segments.extend(line)
-        if index < len(lines) - 1:
-            sanitized_segments.append(newline_segment)
-
-    if end_segment is not None:
-        sanitized_segments.append(end_segment)
-
-    return sanitized_segments
-
-
-def _rich_has_styled_newline_bug() -> bool:
-    """Check if newlines are styled when soft wrapping."""
-    console = Console(force_terminal=True)
-    with console.capture() as capture:
-        console.print("line_1", style="blue on white", soft_wrap=True)
-
-    # Check if we see a styled newline in the output
-    return "\x1b[34;47m\n\x1b[0m" in capture.get()
-
-
-# Only apply the monkey patch if the bug is present
-if _rich_has_styled_newline_bug():
-    Segment.apply_style = _apply_style_wrapper  # type: ignore[assignment]

cmd2/styles.py

@@ -51,7 +51,6 @@ class Cmd2Style(StrEnum):
 
     COMMAND_LINE = "cmd2.example"  # Command line examples in help text
     ERROR = "cmd2.error"  # Error text (used by perror())
-    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())
@@ -63,9 +62,8 @@ class Cmd2Style(StrEnum):
 DEFAULT_CMD2_STYLES: dict[str, StyleType] = {
     Cmd2Style.COMMAND_LINE: Style(color=Color.CYAN, bold=True),
     Cmd2Style.ERROR: Style(color=Color.BRIGHT_RED),
-    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.HELP_HEADER: Style(color=Color.BRIGHT_GREEN),
+    Cmd2Style.HELP_LEADER: Style(color=Color.CYAN),
     Cmd2Style.SUCCESS: Style(color=Color.GREEN),
     Cmd2Style.TABLE_BORDER: Style(color=Color.BRIGHT_GREEN),
     Cmd2Style.WARNING: Style(color=Color.BRIGHT_YELLOW),

cmd2/transcript.py

@@ -46,7 +46,7 @@ class Cmd2TestCase(unittest.TestCase):
 
             # Trap stdout
             self._orig_stdout = self.cmdapp.stdout
-            self.cmdapp.stdout = cast(TextIO, utils.StdSim(cast(TextIO, self.cmdapp.stdout)))
+            self.cmdapp.stdout = cast(TextIO, utils.StdSim(self.cmdapp.stdout))
 
     def tearDown(self) -> None:
         """Instructions that will be executed after each test method."""

{cmd2-3.0.0rc1.dist-info → cmd2-3.1.1.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmd2
-Version: 3.0.0rc1
+Version: 3.1.1
 Summary: cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python
 Author: cmd2 Contributors
 License-Expression: MIT
@@ -16,6 +16,7 @@ Classifier: Programming Language :: Python :: 3.11
 Classifier: Programming Language :: Python :: 3.12
 Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: 3.14
+Classifier: Programming Language :: Python :: 3.15
 Classifier: Programming Language :: Python :: Free Threading :: 3 - Stable
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.10
@@ -23,16 +24,16 @@ Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: backports.strenum; python_version == "3.10"
 Requires-Dist: gnureadline>=8; platform_system == "Darwin"
-Requires-Dist: pyperclip>=1.8
+Requires-Dist: pyperclip>=1.8.2
 Requires-Dist: pyreadline3>=3.4; platform_system == "Windows"
-Requires-Dist: rich>=14.1.0
+Requires-Dist: rich>=14.3.0
 Requires-Dist: rich-argparse>=1.7.1
 Dynamic: license-file
 
 <h1 align="center">cmd2 : immersive interactive command line applications</h1>
 
 [![Latest Version](https://img.shields.io/pypi/v/cmd2.svg?style=flat-square&label=latest%20stable%20version)](https://pypi.python.org/pypi/cmd2/)
-[![GitHub Actions](https://github.com/python-cmd2/cmd2/workflows/CI/badge.svg)](https://github.com/python-cmd2/cmd2/actions?query=workflow%3ACI)
+[![Tests](https://github.com/python-cmd2/cmd2/actions/workflows/tests.yml/badge.svg)](https://github.com/python-cmd2/cmd2/actions/workflows/tests.yml)
 [![codecov](https://codecov.io/gh/python-cmd2/cmd2/branch/main/graph/badge.svg)](https://codecov.io/gh/python-cmd2/cmd2)
 [![Documentation Status](https://readthedocs.org/projects/cmd2/badge/?version=latest)](http://cmd2.readthedocs.io/en/latest/?badge=latest)
 <a href="https://discord.gg/RpVG6tk"><img src="https://img.shields.io/badge/chat-on%20discord-7289da.svg" alt="Chat"></a>
@@ -56,10 +57,10 @@ applications. It provides a simple API which is an extension of Python's built-i
 of cmd to make your life easier and eliminates much of the boilerplate code which would be necessary
 when using cmd.
 
-> :warning: **cmd2 is now "feature complete" for the `2.x` branch and is actively working on the
-> 3.0.0 release on the `main` branch. New features will only be addressed in 3.x moving forwards. If
-> need be, we will still fix bugs in 2.x. A beta version, 3.0.0b2, is available for testing and we
-> would appreciate feedback.**
+> :warning: **`cmd2` 3.0.0 has been released and there are some significant backwards
+> incompatibilities from version `2.x`. Please see the
+> [Migration Guide](https://cmd2.readthedocs.io/en/latest/upgrades/) for tips on upgrading from
+> `cmd2` 2.x to 3.x.**
 
 ## The developers toolbox
 

{cmd2-3.0.0rc1.dist-info → cmd2-3.1.1.dist-info}/RECORD

@@ -1,27 +1,27 @@
 cmd2/__init__.py,sha256=JG-jiy2MMArRTujSiU8usvQpdgQbl3KLTim4tU5SCJw,2278
-cmd2/argparse_completer.py,sha256=QaOXP-SfHwmoieNJf5kjZAy0osP3KPeOOx7aYKYthwc,35681
-cmd2/argparse_custom.py,sha256=k6l6KUGK8GujvFIXEqLvYiRYWpM491zufDODfXThEoc,67239
+cmd2/argparse_completer.py,sha256=8hK5_QUnHgeHVY60C89kMKn2b91AUyDjyq4dykzjCRA,35680
+cmd2/argparse_custom.py,sha256=7h68TXurxjDoMsCzoZy1uyy6tvTEEi3RornPQ9ZHJoA,68767
 cmd2/clipboard.py,sha256=5PSKTe3uDe2pFFEDUEMMwAmzcyPkbXXz14SOQxFFncg,515
-cmd2/cmd2.py,sha256=knANWJByVps9EdWKpPOi1_Z-pHiJirOmPnAbA865bQo,271803
+cmd2/cmd2.py,sha256=rHSkJ2RF9QQiYdIktd5DHJYJL-X7swwzyVqM6TMbSZU,272373
 cmd2/colors.py,sha256=gLAU8gjhPwZud9MNVk53RGE9ZSdwspLnye_kReeZKjc,7848
 cmd2/command_definition.py,sha256=4FQgivn-9aZegU5tbUl6XsK_G_gZTMfsbGDortz-Ir8,7992
 cmd2/constants.py,sha256=yDcaeEG4Y2DHmLwUpV-_lEiHkiYUZEuyf9mpDdAzmkg,1773
 cmd2/decorators.py,sha256=_xxagAxlcUROLZowqjW5RYP935uNMEJyr2h8FkWalGw,17356
 cmd2/exceptions.py,sha256=J8Ck0dhusB2cfVksRLkM4WVgBTGQnPdEcU26RfBjjRw,3440
 cmd2/history.py,sha256=QNg5QOe3854hFsu9qw7QlqtnTQvmtXojOWgMZlg6JoQ,14755
-cmd2/parsing.py,sha256=G3Ox876rLY4rZ089GjnMlDDbHN_R_g9bemTQ_ONB4Hg,27994
+cmd2/parsing.py,sha256=-8TfpXZAZnlLbCJem_EziaC2JqZvmOkIUoera1xmM4Y,28035
 cmd2/plugin.py,sha256=_KD44QaHPXncT3qSOWXyzesxKvEbJp5tQeMJ569mLNw,827
 cmd2/py.typed,sha256=qrkHrYJvGoZpU2BpVLNxJB44LlhqVSKyYOwD_L_1m3s,10
-cmd2/py_bridge.py,sha256=dpafsQ2fhhDv-PXu1ZOaiLW4ficD0IsZm-y2nGGfdrU,5191
-cmd2/rich_utils.py,sha256=hYD5Cpl1fAYeau3l8NuJIO9SGiC44Ew9vTKHret6QMo,16364
+cmd2/py_bridge.py,sha256=oD7EwT59HvWSvF9FACWDi-_izkQY6mfitOYX20Y5daI,5190
+cmd2/rich_utils.py,sha256=-BZW98c5OEdYpPq9J3LDkgWHPGoAb8CGMbZvFQrsONE,13461
 cmd2/rl_utils.py,sha256=tlDsH5QnN5xlkJT62Q4ZSOHvccXtt1Nm6kcWJQh6cUc,11315
 cmd2/string_utils.py,sha256=7F8ORonOc2xS0ZC56hjhQcnZhonE3lDFdQxij6v54dA,4430
-cmd2/styles.py,sha256=kuekxVEr0kOrDNJJbVFqOl96YqX8M6lheKBCBS1nGSU,2945
+cmd2/styles.py,sha256=rh7N-4A2moKDEH82Co-yTrmzAknU75d2c0oR2G1euEg,2762
 cmd2/terminal_utils.py,sha256=AOk1VjOAzxn7jou2wbALeD6FRIRlKgkQ0VCzIEY51DA,6052
-cmd2/transcript.py,sha256=aD5J7UcU82XNo_nJ6wr98t97OkhOsR04VZwbwb1lJLs,9224
+cmd2/transcript.py,sha256=5a_1HGDzhhG1I47g9QnrVNWnOI6Mt_z7jGMH7wFm2XQ,9210
 cmd2/utils.py,sha256=4jlhcHfgr8yoymP2hRPeCr7_1J37vI4MIIBkszyPK6M,32292
-cmd2-3.0.0rc1.dist-info/licenses/LICENSE,sha256=9qPeHY4u2fkSz0JQGT-P4T3QqTWTqnQJ_8LkZUhSdFY,1099
-cmd2-3.0.0rc1.dist-info/METADATA,sha256=V_CnTGdr_L5itEiRwgR8U-J9q6R8lprv3khSFZRx4ow,16358
-cmd2-3.0.0rc1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cmd2-3.0.0rc1.dist-info/top_level.txt,sha256=gJbOJmyrARwLhm5diXAtzlNQdxbDZ8iRJ8HJi65_5hg,5
-cmd2-3.0.0rc1.dist-info/RECORD,,
+cmd2-3.1.1.dist-info/licenses/LICENSE,sha256=7JL3v4rPUpHV8b0yWAOl64e9r4YmwbHgl3SH_RGbsK8,1099
+cmd2-3.1.1.dist-info/METADATA,sha256=KL2uOqWMRRCYFEWwYiSbejEAtzY0IqYTIZR7mSwgz0M,16346
+cmd2-3.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+cmd2-3.1.1.dist-info/top_level.txt,sha256=gJbOJmyrARwLhm5diXAtzlNQdxbDZ8iRJ8HJi65_5hg,5
+cmd2-3.1.1.dist-info/RECORD,,

{cmd2-3.0.0rc1.dist-info → cmd2-3.1.1.dist-info}/WHEEL

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

cmd2-3.1.1.dist-info/licenses/LICENSE

@@ -0,0 +1,18 @@
+The MIT License (MIT)
+
+Copyright (c) 2008-2026 Catherine Devlin and others
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and
+associated documentation files (the "Software"), to deal in the Software without restriction,
+including without limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial
+portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT
+NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES
+OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

cmd2-3.0.0rc1.dist-info/licenses/LICENSE

@@ -1,21 +0,0 @@
-The MIT License (MIT)
-
-Copyright (c) 2008-2025 Catherine Devlin and others
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.