cmd2 4.0.0b4__tar.gz → 4.0.0b5__tar.gz

{cmd2-4.0.0b4 → cmd2-4.0.0b5}/CHANGELOG.md

@@ -96,6 +96,9 @@ prompt is displayed.
         - Replaced the global `APP_THEME` constant in `rich_utils.py` with `get_theme()` and
           `set_theme()` functions to support lazy initialization and safer in-place updates of the
           theme.
+    - Renamed `Cmd._command_parsers` to `Cmd.command_parsers`.
+    - Removed `RichPrintKwargs` `TypedDict` in favor of using `Mapping[str, Any]`, allowing for
+      greater flexibility in passing keyword arguments to `console.print()` calls.
 - Enhancements
     - New `cmd2.Cmd` parameters
         - **auto_suggest**: (boolean) if `True`, provide fish shell style auto-suggestions. These
@@ -113,8 +116,9 @@ prompt is displayed.
         - **read_secret**: read secrets like passwords without displaying them to the terminal
         - **ppretty**: a cmd2-compatible replacement for `rich.pretty.pprint()`
     - New settables:
-        - **max_column_completion_results**: (int) the maximum number of completion results to
-          display in a single column
+        - **max_column_completion_results**: (int) Maximum number of completion results to display
+          in a single column
+        - **traceback_show_locals**: (bool) Display local variables in tracebacks
     - `cmd2.Cmd.select` has been revamped to use the
       [choice](https://python-prompt-toolkit.readthedocs.io/en/3.0.52/pages/asking_for_a_choice.html)
       function from `prompt-toolkit` when both **stdin** and **stdout** are TTYs
@@ -130,6 +134,7 @@ prompt is displayed.
       specific `cmd2.Cmd` subclass (e.g.,`class MyCommandSet(CommandSet[MyApp]):`). This provides
       full type hints and IDE autocompletion for `self._cmd` without needing to override and cast
       the property.
+    - Added `traceback_kwargs` attribute to allow customization of Rich-based tracebacks.
 
 ## 3.5.0 (April 13, 2026)
 

{cmd2-4.0.0b4 → cmd2-4.0.0b5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmd2
-Version: 4.0.0b4
+Version: 4.0.0b5
 Summary: cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python
 Author: cmd2 Contributors
 License-Expression: MIT

{cmd2-4.0.0b4 → cmd2-4.0.0b5}/cmd2/__init__.py

@@ -50,7 +50,6 @@ from .rich_utils import (
     MetavarTypeCmd2HelpFormatter,
     RawDescriptionCmd2HelpFormatter,
     RawTextCmd2HelpFormatter,
-    RichPrintKwargs,
     TextGroup,
     get_theme,
     set_theme,
@@ -105,7 +104,6 @@ __all__: list[str] = [  # noqa: RUF022
     "MetavarTypeCmd2HelpFormatter",
     "RawDescriptionCmd2HelpFormatter",
     "RawTextCmd2HelpFormatter",
-    "RichPrintKwargs",
     "set_theme",
     "TextGroup",
     # String Utils

{cmd2-4.0.0b4 → cmd2-4.0.0b5}/cmd2/argparse_utils.py

@@ -494,6 +494,52 @@ def _ActionsContainer_add_argument(  # noqa: N802
 # Overwrite _ActionsContainer.add_argument with our patch
 argparse._ActionsContainer.add_argument = _ActionsContainer_add_argument  # type: ignore[method-assign]
 
+############################################################################################################
+# Patch argparse._SubParsersAction by adding remove_parser() function
+############################################################################################################
+
+
+def _SubParsersAction_remove_parser(  # noqa: N802
+    self: argparse._SubParsersAction,  # type: ignore[type-arg]
+    name: str,
+) -> argparse.ArgumentParser:
+    """Remove a subparser from a subparsers group.
+
+    This function is added by cmd2 as a method called ``remove_parser()``
+    to ``argparse._SubParsersAction`` class.
+
+    To call: ``action.remove_parser(name)``
+
+    :param self: instance of the _SubParsersAction being edited
+    :param name: name of the subcommand for the subparser to remove
+    :return: the removed parser
+    :raises ValueError: if the subcommand doesn't exist
+    """
+    if name not in self._name_parser_map:
+        raise ValueError(f"Subcommand '{name}' does not exist")
+
+    subparser = self._name_parser_map[name]
+
+    # Find all names (primary and aliases) that map to this subparser
+    all_names = [cur_name for cur_name, cur_parser in self._name_parser_map.items() if cur_parser is subparser]
+
+    # Remove the help entry for this subparser. To handle the case where
+    # name is an alias, we remove the action whose 'dest' matches any of
+    # the names mapped to this subparser.
+    for choice_action in self._choices_actions:
+        if choice_action.dest in all_names:
+            self._choices_actions.remove(choice_action)
+            break
+
+    # Remove all references to this subparser, including aliases.
+    for cur_name in all_names:
+        del self._name_parser_map[cur_name]
+
+    return cast(argparse.ArgumentParser, subparser)
+
+
+argparse._SubParsersAction.remove_parser = _SubParsersAction_remove_parser  # type: ignore[attr-defined]
+
 
 class Cmd2ArgumentParser(argparse.ArgumentParser):
     """Custom ArgumentParser class that improves error and help output."""
@@ -556,7 +602,7 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
         self.description: RenderableType | None  # type: ignore[assignment]
         self.epilog: RenderableType | None  # type: ignore[assignment]
 
-    def _get_subparsers_action(self) -> "argparse._SubParsersAction[Cmd2ArgumentParser]":
+    def get_subparsers_action(self) -> "argparse._SubParsersAction[Cmd2ArgumentParser]":
         """Get the _SubParsersAction for this parser if it exists.
 
         :return: the _SubParsersAction for this parser
@@ -619,7 +665,7 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
         self.prog = prog
 
         try:
-            subparsers_action = self._get_subparsers_action()
+            subparsers_action = self.get_subparsers_action()
         except ValueError:
             # This parser has no subcommands
             return
@@ -638,12 +684,14 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
         # add_parser() will have the correct prog value.
         subparsers_action._prog_prefix = self._build_subparsers_prog_prefix(positionals)
 
-        # subparsers_action.choices includes aliases. Since primary names are inserted first,
-        # we skip already updated parsers to ensure primary names are used in 'prog'.
+        # subparsers_action._name_parser_map includes aliases. Since primary names are inserted
+        # first, we skip already updated parsers to ensure primary names are used in 'prog'.
+        # We can't rely on subparsers_action._choices_actions to filter out aliases because while
+        # it contains only primary names, it omits any subcommands that lack help text.
         updated_parsers: set[Cmd2ArgumentParser] = set()
 
         # Set the prog value for each subcommand's parser
-        for subcmd_name, subcmd_parser in subparsers_action.choices.items():
+        for subcmd_name, subcmd_parser in subparsers_action._name_parser_map.items():
             if subcmd_parser in updated_parsers:
                 continue
 
@@ -651,7 +699,7 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
             subcmd_parser.update_prog(subcmd_prog)
             updated_parsers.add(subcmd_parser)
 
-    def _find_parser(self, subcommand_path: Iterable[str]) -> "Cmd2ArgumentParser":
+    def find_parser(self, subcommand_path: Iterable[str]) -> "Cmd2ArgumentParser":
         """Find a parser in the hierarchy based on a sequence of subcommand names.
 
         :param subcommand_path: sequence of subcommand names leading to the target parser
@@ -660,10 +708,10 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
         """
         parser = self
         for name in subcommand_path:
-            subparsers_action = parser._get_subparsers_action()
-            if name not in subparsers_action.choices:
-                raise ValueError(f"Subcommand '{name}' not found in '{parser.prog}'")
-            parser = subparsers_action.choices[name]
+            subparsers_action = parser.get_subparsers_action()
+            if name not in subparsers_action._name_parser_map:
+                raise ValueError(f"Subcommand '{name}' does not exist for '{parser.prog}'")
+            parser = subparsers_action._name_parser_map[name]
         return parser
 
     def attach_subcommand(
@@ -683,7 +731,8 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
         :raises TypeError: if subcommand_parser is not an instance of the following or their subclasses:
                            1. Cmd2ArgumentParser
                            2. The parser_class configured for the target subcommand group
-        :raises ValueError: if the command path is invalid or doesn't support subcommands
+        :raises ValueError: if the command path is invalid, doesn't support subcommands, or the
+                            subcommand already exists
         """
         if not isinstance(subcommand_parser, Cmd2ArgumentParser):
             raise TypeError(
@@ -691,8 +740,8 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
                 f"Received: '{type(subcommand_parser).__name__}'."
             )
 
-        target_parser = self._find_parser(subcommand_path)
-        subparsers_action = target_parser._get_subparsers_action()
+        target_parser = self.find_parser(subcommand_path)
+        subparsers_action = target_parser.get_subparsers_action()
 
         # Verify the parser is compatible with the 'parser_class' configured for this
         # subcommand group. We use isinstance() here to allow for subclasses, providing
@@ -705,6 +754,12 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
                 f"Received: '{type(subcommand_parser).__name__}'."
             )
 
+        # Do not overwrite existing subcommands or aliases
+        all_names = (subcommand, *add_parser_kwargs.get("aliases", ()))
+        for name in all_names:
+            if name in subparsers_action._name_parser_map:
+                raise ValueError(f"Subcommand '{name}' already exists for '{target_parser.prog}'")
+
         # Use add_parser to register the subcommand name and any aliases
         placeholder_parser = subparsers_action.add_parser(subcommand, **add_parser_kwargs)
 
@@ -728,28 +783,16 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
         :return: the detached parser
         :raises ValueError: if the command path is invalid or the subcommand doesn't exist
         """
-        target_parser = self._find_parser(subcommand_path)
-        subparsers_action = target_parser._get_subparsers_action()
-
-        subparser = subparsers_action._name_parser_map.get(subcommand)
-        if subparser is None:
-            raise ValueError(f"Subcommand '{subcommand}' not found in '{target_parser.prog}'")
-
-        # Remove this subcommand and all its aliases from the base command
-        to_remove = []
-        for cur_name, cur_parser in subparsers_action._name_parser_map.items():
-            if cur_parser is subparser:
-                to_remove.append(cur_name)
-        for cur_name in to_remove:
-            del subparsers_action._name_parser_map[cur_name]
-
-        # Remove this subcommand from its base command's help text
-        for choice_action in subparsers_action._choices_actions:
-            if choice_action.dest == subcommand:
-                subparsers_action._choices_actions.remove(choice_action)
-                break
+        target_parser = self.find_parser(subcommand_path)
+        subparsers_action = target_parser.get_subparsers_action()
 
-        return subparser
+        try:
+            return cast(
+                Cmd2ArgumentParser,
+                subparsers_action.remove_parser(subcommand),  # type: ignore[attr-defined]
+            )
+        except ValueError:
+            raise ValueError(f"Subcommand '{subcommand}' does not exist for '{target_parser.prog}'") from None
 
     def error(self, message: str) -> NoReturn:
         """Override that applies custom formatting to the error message."""