cmd2 2.6.1__py3-none-any.whl → 2.7.0__py3-none-any.whl

cmd2/argparse_custom.py

@@ -229,14 +229,17 @@ from argparse import (
     ZERO_OR_MORE,
     ArgumentError,
 )
-from collections.abc import Callable, Iterable, Sequence
-from gettext import (
-    gettext,
+from collections.abc import (
+    Callable,
+    Iterable,
+    Sequence,
 )
+from gettext import gettext
 from typing import (
     IO,
     TYPE_CHECKING,
     Any,
+    ClassVar,
     NoReturn,
     Optional,
     Protocol,
@@ -245,6 +248,8 @@ from typing import (
     runtime_checkable,
 )
 
+from rich_argparse import RawTextRichHelpFormatter
+
 from . import (
     ansi,
     constants,
@@ -991,9 +996,25 @@ setattr(argparse._SubParsersAction, 'remove_parser', _SubParsersAction_remove_pa
 ############################################################################################################
 
 
-class Cmd2HelpFormatter(argparse.RawTextHelpFormatter):
+class Cmd2HelpFormatter(RawTextRichHelpFormatter):
     """Custom help formatter to configure ordering of help text."""
 
+    # rich-argparse formats all group names with str.title().
+    # Override their formatter to do nothing.
+    group_name_formatter: ClassVar[Callable[[str], str]] = str
+
+    # Disable automatic highlighting in the help text.
+    highlights: ClassVar[list[str]] = []
+
+    # Disable markup rendering in usage, help, description, and epilog text.
+    # cmd2's built-in commands do not escape opening brackets in their help text
+    # and therefore rely on these settings being False. If you desire to use
+    # markup in your help text, inherit from Cmd2HelpFormatter and override
+    # these settings in that child class.
+    usage_markup: ClassVar[bool] = False
+    help_markup: ClassVar[bool] = False
+    text_markup: ClassVar[bool] = False
+
     def _format_usage(
         self,
         usage: Optional[str],
@@ -1215,42 +1236,30 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
                                   behavior on this parser. If this is None or not present, then cmd2 will use
                                   argparse_completer.DEFAULT_AP_COMPLETER when tab completing this parser's arguments
         """
+        kwargs: dict[str, bool] = {}
         if sys.version_info >= (3, 14):
             # Python >= 3.14 so pass new arguments to parent argparse.ArgumentParser class
-            super().__init__(
-                prog=prog,
-                usage=usage,
-                description=description,
-                epilog=epilog,
-                parents=parents if parents else [],
-                formatter_class=formatter_class,  # type: ignore[arg-type]
-                prefix_chars=prefix_chars,
-                fromfile_prefix_chars=fromfile_prefix_chars,
-                argument_default=argument_default,
-                conflict_handler=conflict_handler,
-                add_help=add_help,
-                allow_abbrev=allow_abbrev,
-                exit_on_error=exit_on_error,  # added in Python 3.9
-                suggest_on_error=suggest_on_error,  # added in Python 3.14
-                color=color,  # added in Python 3.14
-            )
-        else:
-            # Python < 3.14, so don't pass new arguments to parent argparse.ArgumentParser class
-            super().__init__(
-                prog=prog,
-                usage=usage,
-                description=description,
-                epilog=epilog,
-                parents=parents if parents else [],
-                formatter_class=formatter_class,  # type: ignore[arg-type]
-                prefix_chars=prefix_chars,
-                fromfile_prefix_chars=fromfile_prefix_chars,
-                argument_default=argument_default,
-                conflict_handler=conflict_handler,
-                add_help=add_help,
-                allow_abbrev=allow_abbrev,
-                exit_on_error=exit_on_error,  # added in Python 3.9
-            )
+            kwargs = {
+                "suggest_on_error": suggest_on_error,
+                "color": color,
+            }
+
+        super().__init__(
+            prog=prog,
+            usage=usage,
+            description=description,
+            epilog=epilog,
+            parents=parents if parents else [],
+            formatter_class=formatter_class,  # type: ignore[arg-type]
+            prefix_chars=prefix_chars,
+            fromfile_prefix_chars=fromfile_prefix_chars,
+            argument_default=argument_default,
+            conflict_handler=conflict_handler,
+            add_help=add_help,
+            allow_abbrev=allow_abbrev,
+            exit_on_error=exit_on_error,  # added in Python 3.9
+            **kwargs,  # added in Python 3.14
+        )
 
         self.set_ap_completer_type(ap_completer_type)  # type: ignore[attr-defined]
 

cmd2/cmd2.py

@@ -42,14 +42,16 @@ import re
 import sys
 import tempfile
 import threading
-from code import (
-    InteractiveConsole,
-)
+from code import InteractiveConsole
 from collections import (
     OrderedDict,
     namedtuple,
 )
-from collections.abc import Callable, Iterable, Mapping
+from collections.abc import (
+    Callable,
+    Iterable,
+    Mapping,
+)
 from types import (
     FrameType,
     ModuleType,
@@ -254,17 +256,11 @@ class _CommandParsers:
             command = command_method.__name__[len(COMMAND_FUNC_PREFIX) :]
 
             parser_builder = getattr(command_method, constants.CMD_ATTR_ARGPARSER, None)
-            parent = self._cmd.find_commandset_for_command(command) or self._cmd
-            parser = self._cmd._build_parser(parent, parser_builder)
-            if parser is None:
+            if parser_builder is None:
                 return None
 
-            # argparser defaults the program name to sys.argv[0], but we want it to be the name of our command
-            from .decorators import (
-                _set_parser_prog,
-            )
-
-            _set_parser_prog(parser, command)
+            parent = self._cmd.find_commandset_for_command(command) or self._cmd
+            parser = self._cmd._build_parser(parent, parser_builder, 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__:
@@ -758,24 +754,39 @@ class Cmd(cmd.Cmd):
     def _build_parser(
         self,
         parent: CommandParent,
-        parser_builder: Optional[
-            Union[
-                argparse.ArgumentParser,
-                Callable[[], argparse.ArgumentParser],
-                StaticArgParseBuilder,
-                ClassArgParseBuilder,
-            ]
+        parser_builder: Union[
+            argparse.ArgumentParser,
+            Callable[[], argparse.ArgumentParser],
+            StaticArgParseBuilder,
+            ClassArgParseBuilder,
         ],
-    ) -> Optional[argparse.ArgumentParser]:
-        parser: Optional[argparse.ArgumentParser] = None
+        prog: str,
+    ) -> argparse.ArgumentParser:
+        """Build argument parser for a command/subcommand.
+
+        :param parent: CommandParent object which owns the command using the parser.
+                       When parser_builder is a classmethod, this function passes
+                       parent's class to it.
+        :param parser_builder: means used to build the parser
+        :param prog: prog value to set in new parser
+        :return: new parser
+        :raises TypeError: if parser_builder is invalid type
+        """
         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]
+            parser = parser_builder.__func__(parent.__class__)
         elif callable(parser_builder):
             parser = parser_builder()
         elif isinstance(parser_builder, argparse.ArgumentParser):
             parser = copy.deepcopy(parser_builder)
+        else:
+            raise TypeError(f"Invalid type for parser_builder: {type(parser_builder)}")
+
+        from .decorators import _set_parser_prog
+
+        _set_parser_prog(parser, prog)
+
         return parser
 
     def _install_command_function(self, command_func_name: str, command_method: CommandFunc, context: str = '') -> None:
@@ -963,12 +974,7 @@ 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}')
+            subcmd_parser = self._build_parser(cmdset, subcmd_parser_builder, f'{command_name} {subcommand_name}')
             if subcmd_parser.description is None and method.__doc__:
                 subcmd_parser.description = strip_doc_annotations(method.__doc__)
 
@@ -2610,7 +2616,7 @@ class Cmd(cmd.Cmd):
                 # caused by certain binary characters having been printed to it.
                 import subprocess
 
-                proc = subprocess.Popen(['stty', 'sane'])  # noqa: S603, S607
+                proc = subprocess.Popen(['stty', 'sane'])  # noqa: S607
                 proc.communicate()
 
         data = plugin.CommandFinalizationData(stop, statement)

cmd2/decorators.py

@@ -393,6 +393,14 @@ def with_argparser(
 
         command_name = func.__name__[len(constants.COMMAND_FUNC_PREFIX) :]
 
+        if isinstance(parser, argparse.ArgumentParser):
+            # Set parser's prog value for backward compatibility within the cmd2 2.0 family.
+            # This will be removed in cmd2 3.0 since we never reference this parser object's prog value.
+            # Since it's possible for the same parser object to be passed into multiple with_argparser()
+            # calls, we only set prog on the deep copies of this parser based on the specific do_xxxx
+            # instance method they are associated with.
+            _set_parser_prog(parser, command_name)
+
         # Set some custom attributes for this command
         setattr(cmd_wrapper, constants.CMD_ATTR_ARGPARSER, parser)
         setattr(cmd_wrapper, constants.CMD_ATTR_PRESERVE_QUOTES, preserve_quotes)

{cmd2-2.6.1.dist-info → cmd2-2.7.0.dist-info}/METADATA

@@ -1,11 +1,11 @@
 Metadata-Version: 2.4
 Name: cmd2
-Version: 2.6.1
+Version: 2.7.0
 Summary: cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python
 Author: cmd2 Contributors
 License: The MIT License (MIT)
         
-        Copyright (c) 2008-2024 Catherine Devlin and others
+        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
@@ -39,6 +39,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 :: Free Threading :: 3 - Stable
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Requires-Python: >=3.9
 Description-Content-Type: text/markdown
@@ -46,6 +47,7 @@ License-File: LICENSE
 Requires-Dist: gnureadline>=8; platform_system == "Darwin"
 Requires-Dist: pyperclip>=1.8
 Requires-Dist: pyreadline3>=3.4; platform_system == "Windows"
+Requires-Dist: rich-argparse>=1.7.1
 Requires-Dist: wcwidth>=0.2.10
 Dynamic: license-file
 
@@ -80,22 +82,22 @@ when using cmd.
 
 ![system schema](https://raw.githubusercontent.com/python-cmd2/cmd2/master/.github/images/graph.drawio.png)
 
-When creating solutions developers have no shortage of tools to create rich and smart user interfaces.
-System administrators have long been duct taping together brittle workflows based on a menagerie of simple command line
-tools created by strangers on github and the guy down the hall.
-Unfortunately, when CLIs become significantly complex the ease of command discoverability tends to fade quickly.
-On the other hand, Web and traditional desktop GUIs are first in class when it comes to easily discovering
-functionality.
-The price we pay for beautifully colored displays is complexity required to aggregate disperate applications into larger
-systems.
-`cmd2` fills the niche between high [ease of command discovery](https://clig.dev/#ease-of-discovery) applications and
-smart workflow automation systems.
-
-The `cmd2` framework provides a great mixture of both worlds. Application designers can easily create complex
-applications and rely on the cmd2 library to offer effortless user facing help and extensive tab completion.
-When users become comfortable with functionality, cmd2 turns into a feature rich library enabling a smooth transition to
-full automation. If designed with enough forethought, a well implemented cmd2 application can serve as a boutique
-workflow tool. `cmd2` pulls off this flexibility based on two pillars of philosophy:
+When creating solutions developers have no shortage of tools to create rich and smart user
+interfaces. System administrators have long been duct taping together brittle workflows based on a
+menagerie of simple command line tools created by strangers on github and the guy down the hall.
+Unfortunately, when CLIs become significantly complex the ease of command discoverability tends to
+fade quickly. On the other hand, Web and traditional desktop GUIs are first in class when it comes
+to easily discovering functionality. The price we pay for beautifully colored displays is complexity
+required to aggregate disperate applications into larger systems. `cmd2` fills the niche between
+high [ease of command discovery](https://clig.dev/#ease-of-discovery) applications and smart
+workflow automation systems.
+
+The `cmd2` framework provides a great mixture of both worlds. Application designers can easily
+create complex applications and rely on the cmd2 library to offer effortless user facing help and
+extensive tab completion. When users become comfortable with functionality, cmd2 turns into a
+feature rich library enabling a smooth transition to full automation. If designed with enough
+forethought, a well implemented cmd2 application can serve as a boutique workflow tool. `cmd2` pulls
+off this flexibility based on two pillars of philosophy:
 
 - Tab Completion
 - Automation Transition
@@ -104,8 +106,8 @@ workflow tool. `cmd2` pulls off this flexibility based on two pillars of philoso
 
 <a href="https://imgflip.com/i/63h03x"><img src="https://i.imgflip.com/63h03x.jpg" title="made at imgflip.com" width="70%" height="%70"/></a>
 
-Deep extensive tab completion and help text generation based on the argparse library create the first pillar of 'ease of
-command discovery'. The following is a list of features in this category.
+Deep extensive tab completion and help text generation based on the argparse library create the
+first pillar of 'ease of command discovery'. The following is a list of features in this category.
 
 - Great tab completion of commands, subcommands, file system paths, and shell commands.
 - Custom tab completion for user designed commands via simple function overloading.
@@ -116,13 +118,15 @@ command discovery'. The following is a list of features in this category.
 
 <a href="https://imgflip.com/i/66t0y0"><img src="https://i.imgflip.com/66t0y0.jpg" title="made at imgflip.com" width="70%" height="70%"/></a>
 
-cmd2 creates the second pillar of 'ease of transition to automation' through alias/macro creation, command line argument
-parsing and execution of cmd2 scripting.
+cmd2 creates the second pillar of 'ease of transition to automation' through alias/macro creation,
+command line argument parsing and execution of cmd2 scripting.
 
 - Flexible alias and macro creation for quick abstraction of commands.
 - Text file scripting of your application with `run_script` (`@`) and `_relative_run_script` (`@@`)
-- Powerful and flexible built-in Python scripting of your application using the `run_pyscript` command
-- Transcripts for use with built-in regression can be automatically generated from `history -t` or `run_script -t`
+- Powerful and flexible built-in Python scripting of your application using the `run_pyscript`
+  command
+- Transcripts for use with built-in regression can be automatically generated from `history -t` or
+  `run_script -t`
 
 ## Installation
 
@@ -132,11 +136,12 @@ On all operating systems, the latest stable version of `cmd2` can be installed u
 pip install -U cmd2
 ```
 
-cmd2 works with Python 3.9+ on Windows, macOS, and Linux. It is pure Python code with few 3rd-party dependencies.
+cmd2 works with Python 3.9+ on Windows, macOS, and Linux. It is pure Python code with few 3rd-party
+dependencies. It works with both conventional CPython and free-threaded variants.
 
 For information on other installation options, see
-[Installation Instructions](https://cmd2.readthedocs.io/en/latest/overview/installation.html) in the cmd2
-documentation.
+[Installation Instructions](https://cmd2.readthedocs.io/en/latest/overview/installation.html) in the
+cmd2 documentation.
 
 ## Documentation
 
@@ -144,7 +149,8 @@ The latest documentation for cmd2 can be read online here: https://cmd2.readthed
 
 It is available in HTML, PDF, and ePub formats.
 
-The best way to learn the cmd2 api is to delve into the example applications located in source under examples.
+The best way to learn the cmd2 api is to delve into the example applications located in source under
+examples.
 
 ## Tutorials
 
@@ -153,13 +159,15 @@ The best way to learn the cmd2 api is to delve into the example applications loc
     - [slides](https://github.com/python-cmd2/talks/blob/master/PyOhio_2019/cmd2-PyOhio_2019.pdf)
     - [example code](https://github.com/python-cmd2/talks/tree/master/PyOhio_2019/examples)
 - [Cookiecutter](https://github.com/cookiecutter/cookiecutter) Templates from community
-    - Basic cookiecutter template for cmd2 application : https://github.com/jayrod/cookiecutter-python-cmd2
-    - Advanced cookiecutter template with external plugin
-      support : https://github.com/jayrod/cookiecutter-python-cmd2-ext-plug
+    - Basic cookiecutter template for cmd2 application :
+      https://github.com/jayrod/cookiecutter-python-cmd2
+    - Advanced cookiecutter template with external plugin support :
+      https://github.com/jayrod/cookiecutter-python-cmd2-ext-plug
 - [cmd2 example applications](https://github.com/python-cmd2/cmd2/tree/master/examples)
     - Basic cmd2 examples to demonstrate how to use various features
 - [Advanced Examples](https://github.com/jayrod/cmd2-example-apps)
-    - More complex examples that demonstrate more featuers about how to put together a complete application
+    - More complex examples that demonstrate more featuers about how to put together a complete
+      application
 
 ## Hello World
 
@@ -187,10 +195,10 @@ if __name__ == '__main__':
 
 ## Found a bug?
 
-If you think you've found a bug, please first read through the
-open [Issues](https://github.com/python-cmd2/cmd2/issues). If you're confident it's a new bug, go ahead and create a new
-GitHub issue. Be sure to include as much information as possible so we can reproduce the bug. At a minimum, please state
-the following:
+If you think you've found a bug, please first read through the open
+[Issues](https://github.com/python-cmd2/cmd2/issues). If you're confident it's a new bug, go ahead
+and create a new GitHub issue. Be sure to include as much information as possible so we can
+reproduce the bug. At a minimum, please state the following:
 
 - `cmd2` version
 - Python version
@@ -232,4 +240,5 @@ Possibly defunct but still good examples
 | [FLASHMINGO](https://github.com/mandiant/flashmingo)                          | Automatic analysis of SWF files based on some heuristics. Extensible via plugins.      | [Mandiant](https://github.com/mandiant)                        |
 | [psiTurk](https://github.com/NYUCCL/psiTurk)                                  | An open platform for science on Amazon Mechanical Turk                                 | [NYU Computation and Cognition Lab](https://github.com/NYUCCL) |
 
-Note: If you have created an application based on `cmd2` that you would like us to mention here, please get in touch.
+Note: If you have created an application based on `cmd2` that you would like us to mention here,
+please get in touch.

{cmd2-2.6.1.dist-info → cmd2-2.7.0.dist-info}/RECORD

@@ -1,12 +1,12 @@
 cmd2/__init__.py,sha256=xRXcr4HzJrZbouMEP8AkWwxjW1lqXYLFG0SlWiw5_9g,2502
 cmd2/ansi.py,sha256=XwBvFnB51LYYjIpfEge6mcr5X63dUxiV0aJlOOJ_2tQ,31965
 cmd2/argparse_completer.py,sha256=F_5hiX9fYpEhV42mz7v7qeS7KuInAS6xU6KekLxYzsQ,35863
-cmd2/argparse_custom.py,sha256=Q7N-2TSctfjn3TEZezQNaT5y0w8sdGpmUA5_DCPa_Pk,59131
+cmd2/argparse_custom.py,sha256=uGCQ3MG_iTBvwZ6MKmZOoCjlgF8OvWJg2DMs2myHZf4,59201
 cmd2/clipboard.py,sha256=HLZWY-W3mkpF_OqQet-F8pS3rlXpiE5vxUyPV_yHvIU,507
-cmd2/cmd2.py,sha256=y2gqtQaHG4Oy5MB1VTCX6Tlgvji6NGuypS9x2dPFrUI,261541
+cmd2/cmd2.py,sha256=8HKnMWhtY0qJUtQZr0ByrMnfYKnavQu7tT6G7wrsZVk,261697
 cmd2/command_definition.py,sha256=_wF39nig5MP0grSOZ1hFehP5fCGusUNHMn9PIs6pmcU,7648
 cmd2/constants.py,sha256=duEqGhhvdUV7AYxE8VGZ4wyFBcN2y2bLPd5iefW4tSU,1943
-cmd2/decorators.py,sha256=9Jiml8HGc-UyUtWTns3TwW8ZHte4NchfGgHe-_1CcDM,20075
+cmd2/decorators.py,sha256=t0gBy3aRz5ke0jHyP5YOszdQ61t5aV8j0eNyLPX6hmg,20644
 cmd2/exceptions.py,sha256=fYciAnLCpvPYkXCtmADhxtcvjbxVagRjhp41eYwAQo8,3444
 cmd2/history.py,sha256=elJPuvV7BnUEgpWnixNyl2yGtR6sz3nwvpyFwaeFqRA,14800
 cmd2/parsing.py,sha256=BsyQTTkuEg4FiQP9o2O28KjXodFgXkXmvk_VkAe-Ryw,28057
@@ -17,8 +17,8 @@ cmd2/rl_utils.py,sha256=sWapqwDR_GvOgy5NJ7c-i6nUU4dqpKpGQ8-Olwi3tuU,11335
 cmd2/table_creator.py,sha256=nF3VEgGHvfhHBh_yoMAiV1WaDdR8hIareIAogzIPq5M,47177
 cmd2/transcript.py,sha256=Ws0lW_oBFxCQCKSwvnDUS1x3ya163YXnV-O5aTU0z7k,9207
 cmd2/utils.py,sha256=NqDIkY4LiAlnv_Un7MFHxszoH2KgEWQ7NJOwQurIn_E,50698
-cmd2-2.6.1.dist-info/licenses/LICENSE,sha256=QXrW0Z0merk9mncyUkn-sgRxhT8_o1dL5HEaBNH47Q4,1099
-cmd2-2.6.1.dist-info/METADATA,sha256=JNWrp7MjHaU-kJjMoklgq_EyEHbkSd4QscQs5x3YswA,17133
-cmd2-2.6.1.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-cmd2-2.6.1.dist-info/top_level.txt,sha256=gJbOJmyrARwLhm5diXAtzlNQdxbDZ8iRJ8HJi65_5hg,5
-cmd2-2.6.1.dist-info/RECORD,,
+cmd2-2.7.0.dist-info/licenses/LICENSE,sha256=9qPeHY4u2fkSz0JQGT-P4T3QqTWTqnQJ_8LkZUhSdFY,1099
+cmd2-2.7.0.dist-info/METADATA,sha256=HOqT-x9vnZ21-fCTSbT7HC-BQo6fPY1hyCXtS_b6GHw,17328
+cmd2-2.7.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+cmd2-2.7.0.dist-info/top_level.txt,sha256=gJbOJmyrARwLhm5diXAtzlNQdxbDZ8iRJ8HJi65_5hg,5
+cmd2-2.7.0.dist-info/RECORD,,

{cmd2-2.6.1.dist-info → cmd2-2.7.0.dist-info}/licenses/LICENSE

@@ -1,6 +1,6 @@
 The MIT License (MIT)
 
-Copyright (c) 2008-2024 Catherine Devlin and others
+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