cmd2 2.5.4__tar.gz → 2.5.6__tar.gz

{cmd2-2.5.4 → cmd2-2.5.6}/CHANGELOG.md

@@ -1,3 +1,13 @@
+## 2.5.6 (November 14, 2024)
+* Bug Fixes
+   * Fixed type hint for `with_default_category` decorator which caused type checkers to mistype
+     a subclass of `CommandSet` as a plain `CommandSet`.
+
+## 2.5.5 (November 13, 2024)
+* Bug Fixes
+   * Fixed type hints for passing a class method to `with_argparser` and `as_subcommand_to`.
+   * Fixed issue where `set` command was not always printing a settable's current value.
+
 ## 2.5.4 (November 6, 2024)
 * Bug Fixes
   * Fixed `ZeroDivisionError` in `async_alert()` when `shutil.get_terminal_size().columns` is 0.

{cmd2-2.5.4 → cmd2-2.5.6}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cmd2
-Version: 2.5.4
+Version: 2.5.6
 Summary: cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python
 Author: cmd2 Contributors
 License: The MIT License (MIT)

{cmd2-2.5.4 → cmd2-2.5.6}/cmd2/cmd2.py

@@ -3902,7 +3902,7 @@ class Cmd(cmd.Cmd):
 
     def columnize(self, str_list: Optional[List[str]], display_width: int = 80) -> None:
         """Display a list of single-line strings as a compact set of columns.
-        Override of cmd's print_topics() to handle strings with ANSI style sequences and wide characters
+        Override of cmd's columnize() to handle strings with ANSI style sequences and wide characters
 
         Each column is only as wide as necessary.
         Columns are separated by two spaces (one was not legible enough).
@@ -4226,11 +4226,11 @@ class Cmd(cmd.Cmd):
                 # Try to update the settable's value
                 try:
                     orig_value = settable.get_value()
-                    new_value = settable.set_value(utils.strip_quotes(args.value))
+                    settable.set_value(utils.strip_quotes(args.value))
                 except Exception as ex:
                     self.perror(f"Error setting {args.param}: {ex}")
                 else:
-                    self.poutput(f"{args.param} - was: {orig_value!r}\nnow: {new_value!r}")
+                    self.poutput(f"{args.param} - was: {orig_value!r}\nnow: {settable.get_value()!r}")
                     self.last_result = True
                 return
 

{cmd2-2.5.4 → cmd2-2.5.6}/cmd2/command_definition.py

@@ -10,6 +10,7 @@ from typing import (
     Mapping,
     Optional,
     Type,
+    TypeVar,
 )
 
 from .constants import (
@@ -30,8 +31,10 @@ if TYPE_CHECKING:  # pragma: no cover
 #: Further refinements are needed to define the input parameters
 CommandFunc = Callable[..., Optional[bool]]
 
+CommandSetType = TypeVar('CommandSetType', bound=Type['CommandSet'])
 
-def with_default_category(category: str, *, heritable: bool = True) -> Callable[[Type['CommandSet']], Type['CommandSet']]:
+
+def with_default_category(category: str, *, heritable: bool = True) -> Callable[[CommandSetType], CommandSetType]:
     """
     Decorator that applies a category to all ``do_*`` command methods in a class that do not already
     have a category specified.
@@ -42,7 +45,7 @@ def with_default_category(category: str, *, heritable: bool = True) -> Callable[
     override the default category.
 
     If `heritable` is set to False, then only the commands declared locally to this CommandSet will be placed in the
-    specified category. Dynamically created commands, and commands declared in sub-classes will not receive this
+    specified category. Dynamically created commands and commands declared in sub-classes will not receive this
     category.
 
     :param category: category to put all uncategorized commands in
@@ -50,7 +53,7 @@ def with_default_category(category: str, *, heritable: bool = True) -> Callable[
     :return: decorator function
     """
 
-    def decorate_class(cls: Type[CommandSet]) -> Type[CommandSet]:
+    def decorate_class(cls: CommandSetType) -> CommandSetType:
         if heritable:
             setattr(cls, CLASS_ATTR_DEFAULT_HELP_CATEGORY, category)
 

{cmd2-2.5.4 → cmd2-2.5.6}/cmd2/decorators.py

@@ -11,9 +11,9 @@ from typing import (
     Optional,
     Sequence,
     Tuple,
+    Type,
     TypeVar,
     Union,
-    overload,
 )
 
 from . import (
@@ -65,19 +65,18 @@ def with_category(category: str) -> Callable[[CommandFunc], CommandFunc]:
     return cat_decorator
 
 
-##########################
-# The _parse_positionals and _arg_swap functions allow for additional positional args to be preserved
-# in cmd2 command functions/callables. As long as the 2-ple of arguments we expect to be there can be
-# found we can swap out the statement with each decorator's specific parameters
-##########################
-
-
 CommandParent = TypeVar('CommandParent', bound=Union['cmd2.Cmd', CommandSet])
+CommandParentType = TypeVar('CommandParentType', bound=Union[Type['cmd2.Cmd'], Type[CommandSet]])
 
 
 RawCommandFuncOptionalBoolReturn = Callable[[CommandParent, Union[Statement, str]], Optional[bool]]
 
 
+##########################
+# The _parse_positionals and _arg_swap functions allow for additional positional args to be preserved
+# in cmd2 command functions/callables. As long as the 2-ple of arguments we expect to be there can be
+# found we can swap out the statement with each decorator's specific parameters
+##########################
 def _parse_positionals(args: Tuple[Any, ...]) -> Tuple['cmd2.Cmd', Union[Statement, str]]:
     """
     Helper function for cmd2 decorators to inspect the positional arguments until the cmd2.Cmd argument is found
@@ -265,28 +264,12 @@ ArgparseCommandFunc = Union[
 ]
 
 
-@overload
-def with_argparser(
-    parser: argparse.ArgumentParser,
-    *,
-    ns_provider: Optional[Callable[..., argparse.Namespace]] = None,
-    preserve_quotes: bool = False,
-    with_unknown_args: bool = False,
-) -> Callable[[ArgparseCommandFunc[CommandParent]], RawCommandFuncOptionalBoolReturn[CommandParent]]: ...  # pragma: no cover
-
-
-@overload
-def with_argparser(
-    parser: Callable[[], argparse.ArgumentParser],
-    *,
-    ns_provider: Optional[Callable[..., argparse.Namespace]] = None,
-    preserve_quotes: bool = False,
-    with_unknown_args: bool = False,
-) -> Callable[[ArgparseCommandFunc[CommandParent]], RawCommandFuncOptionalBoolReturn[CommandParent]]: ...  # pragma: no cover
-
-
 def with_argparser(
-    parser: Union[argparse.ArgumentParser, Callable[[], argparse.ArgumentParser]],
+    parser: Union[
+        argparse.ArgumentParser,  # existing parser
+        Callable[[], argparse.ArgumentParser],  # function or staticmethod
+        Callable[[CommandParentType], argparse.ArgumentParser],  # Cmd or CommandSet classmethod
+    ],
     *,
     ns_provider: Optional[Callable[..., argparse.Namespace]] = None,
     preserve_quotes: bool = False,
@@ -413,32 +396,14 @@ def with_argparser(
     return arg_decorator
 
 
-@overload
-def as_subcommand_to(
-    command: str,
-    subcommand: str,
-    parser: argparse.ArgumentParser,
-    *,
-    help: Optional[str] = None,
-    aliases: Optional[List[str]] = None,
-) -> Callable[[ArgparseCommandFunc[CommandParent]], ArgparseCommandFunc[CommandParent]]: ...  # pragma: no cover
-
-
-@overload
-def as_subcommand_to(
-    command: str,
-    subcommand: str,
-    parser: Callable[[], argparse.ArgumentParser],
-    *,
-    help: Optional[str] = None,
-    aliases: Optional[List[str]] = None,
-) -> Callable[[ArgparseCommandFunc[CommandParent]], ArgparseCommandFunc[CommandParent]]: ...  # pragma: no cover
-
-
 def as_subcommand_to(
     command: str,
     subcommand: str,
-    parser: Union[argparse.ArgumentParser, Callable[[], argparse.ArgumentParser]],
+    parser: Union[
+        argparse.ArgumentParser,  # existing parser
+        Callable[[], argparse.ArgumentParser],  # function or staticmethod
+        Callable[[CommandParentType], argparse.ArgumentParser],  # Cmd or CommandSet classmethod
+    ],
     *,
     help: Optional[str] = None,
     aliases: Optional[List[str]] = None,
@@ -450,9 +415,9 @@ def as_subcommand_to(
     :param subcommand: Subcommand name
     :param parser: argparse Parser for this subcommand
     :param help: Help message for this subcommand which displays in the list of subcommands of the command we are adding to.
-                 This is passed as the help argument to ArgumentParser.add_subparser().
+                 This is passed as the help argument to subparsers.add_parser().
     :param aliases: Alternative names for this subcommand. This is passed as the alias argument to
-                    ArgumentParser.add_subparser().
+                    subparsers.add_parser().
     :return: Wrapper function that can receive an argparse.Namespace
     """
 
@@ -462,7 +427,7 @@ def as_subcommand_to(
         setattr(func, constants.CMD_ATTR_ARGPARSER, parser)
         setattr(func, constants.SUBCMD_ATTR_NAME, subcommand)
 
-        # Keyword arguments for ArgumentParser.add_subparser()
+        # Keyword arguments for subparsers.add_parser()
         add_parser_kwargs: Dict[str, Any] = dict()
         if help is not None:
             add_parser_kwargs['help'] = help

{cmd2-2.5.4 → cmd2-2.5.6}/cmd2/utils.py

@@ -178,17 +178,14 @@ class Settable:
         self.completer = completer
 
     def get_value(self) -> Any:
-        """
-        Get the value of the settable attribute
-        :return:
-        """
+        """Get the value of the settable attribute."""
         return getattr(self.settable_obj, self.settable_attrib_name)
 
-    def set_value(self, value: Any) -> Any:
+    def set_value(self, value: Any) -> None:
         """
-        Set the settable attribute on the specified destination object
-        :param value: New value to set
-        :return: New value that the attribute was set to
+        Set the settable attribute on the specified destination object.
+
+        :param value: new value to set
         """
         # Run the value through its type function to handle any conversion or validation
         new_value = self.val_type(value)
@@ -205,7 +202,6 @@ class Settable:
         # Check if we need to call an onchange callback
         if orig_value != new_value and self.onchange_cb:
             self.onchange_cb(self.name, orig_value, new_value)
-        return new_value
 
 
 def is_text_file(file_path: str) -> bool:

{cmd2-2.5.4 → cmd2-2.5.6}/cmd2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: cmd2
-Version: 2.5.4
+Version: 2.5.6
 Summary: cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python
 Author: cmd2 Contributors
 License: The MIT License (MIT)

{cmd2-2.5.4 → cmd2-2.5.6}/docs/conf.py

@@ -184,7 +184,9 @@ autodoc_default_options = {'member-order': 'bysource'}
 nitpick_ignore = [
     ('py:class', 'ArgparseCommandFunc'),
     ('py:class', 'argparse._SubParsersAction'),
+    ('py:class', 'cmd2.command_definition.CommandSetType'),
     ('py:class', 'cmd2.decorators.CommandParent'),
+    ('py:class', 'cmd2.decorators.CommandParentType'),
     ('py:class', 'cmd2.utils._T'),
     ('py:class', 'CommandParent'),
     ('py:class', 'frame'),