cmd2 2.6.0__tar.gz → 2.6.1__tar.gz

{cmd2-2.6.0 → cmd2-2.6.1}/CHANGELOG.md

@@ -1,3 +1,8 @@
+## 2.6.1 (June 8, 2025)
+
+- Bug Fixes
+    - Fixed bug that prevented `cmd2` from working with `from __future__ import annotations`
+
 ## 2.6.0 (May 31, 2025)
 
 - Breaking Change

{cmd2-2.6.0 → cmd2-2.6.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmd2
-Version: 2.6.0
+Version: 2.6.1
 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.6.0 → cmd2-2.6.1}/cmd2/cmd2.py

@@ -144,6 +144,7 @@ from .table_creator import (
 from .utils import (
     Settable,
     get_defining_class,
+    get_types,
     strip_doc_annotations,
     suggest_similar,
 )
@@ -3597,8 +3598,8 @@ class Cmd(cmd.Cmd):
         max_arg_num = 0
         arg_nums = set()
 
-        while True:
-            try:
+        try:
+            while True:
                 cur_match = normal_matches.__next__()
 
                 # Get the number string between the braces
@@ -3612,9 +3613,8 @@ class Cmd(cmd.Cmd):
                 max_arg_num = max(max_arg_num, cur_num)
 
                 arg_list.append(MacroArg(start_index=cur_match.start(), number_str=cur_num_str, is_escaped=False))
-
-            except StopIteration:
-                break
+        except StopIteration:
+            pass
 
         # Make sure the argument numbers are continuous
         if len(arg_nums) != max_arg_num:
@@ -3624,16 +3624,16 @@ class Cmd(cmd.Cmd):
         # Find all escaped arguments
         escaped_matches = re.finditer(MacroArg.macro_escaped_arg_pattern, value)
 
-        while True:
-            try:
+        try:
+            while True:
                 cur_match = escaped_matches.__next__()
 
                 # Get the number string between the braces
                 cur_num_str = re.findall(MacroArg.digit_pattern, cur_match.group())[0]
 
                 arg_list.append(MacroArg(start_index=cur_match.start(), number_str=cur_num_str, is_escaped=True))
-            except StopIteration:
-                break
+        except StopIteration:
+            pass
 
         # Set the macro
         result = "overwritten" if args.name in self.macros else "created"
@@ -5545,10 +5545,10 @@ class Cmd(cmd.Cmd):
     def _validate_prepostloop_callable(cls, func: Callable[[], None]) -> None:
         """Check parameter and return types for preloop and postloop hooks."""
         cls._validate_callable_param_count(func, 0)
-        # make sure there is no return notation
-        signature = inspect.signature(func)
-        if signature.return_annotation is not None:
-            raise TypeError(f"{func.__name__} must declare return a return type of 'None'")
+        # make sure there is no return annotation or the return is specified as None
+        _, ret_ann = get_types(func)
+        if ret_ann is not None:
+            raise TypeError(f"{func.__name__} must have a return type of 'None', got: {ret_ann}")
 
     def register_preloop_hook(self, func: Callable[[], None]) -> None:
         """Register a function to be called at the beginning of the command loop."""
@@ -5564,11 +5564,13 @@ class Cmd(cmd.Cmd):
     def _validate_postparsing_callable(cls, func: Callable[[plugin.PostparsingData], plugin.PostparsingData]) -> None:
         """Check parameter and return types for postparsing hooks."""
         cls._validate_callable_param_count(cast(Callable[..., Any], func), 1)
-        signature = inspect.signature(func)
-        _, param = next(iter(signature.parameters.items()))
-        if param.annotation != plugin.PostparsingData:
+        type_hints, ret_ann = get_types(func)
+        if not type_hints:
+            raise TypeError(f"{func.__name__} parameter is missing a type hint, expected: 'cmd2.plugin.PostparsingData'")
+        par_ann = next(iter(type_hints.values()))
+        if par_ann != plugin.PostparsingData:
             raise TypeError(f"{func.__name__} must have one parameter declared with type 'cmd2.plugin.PostparsingData'")
-        if signature.return_annotation != plugin.PostparsingData:
+        if ret_ann != plugin.PostparsingData:
             raise TypeError(f"{func.__name__} must declare return a return type of 'cmd2.plugin.PostparsingData'")
 
     def register_postparsing_hook(self, func: Callable[[plugin.PostparsingData], plugin.PostparsingData]) -> None:
@@ -5583,21 +5585,21 @@ class Cmd(cmd.Cmd):
         cls, func: Callable[[CommandDataType], CommandDataType], data_type: type[CommandDataType]
     ) -> None:
         """Check parameter and return types for pre and post command hooks."""
-        signature = inspect.signature(func)
         # validate that the callable has the right number of parameters
         cls._validate_callable_param_count(cast(Callable[..., Any], func), 1)
+
+        type_hints, ret_ann = get_types(func)
+        if not type_hints:
+            raise TypeError(f"{func.__name__} parameter is missing a type hint, expected: {data_type}")
+        param_name, par_ann = next(iter(type_hints.items()))
         # validate the parameter has the right annotation
-        paramname = next(iter(signature.parameters.keys()))
-        param = signature.parameters[paramname]
-        if param.annotation != data_type:
-            raise TypeError(f'argument 1 of {func.__name__} has incompatible type {param.annotation}, expected {data_type}')
+        if par_ann != data_type:
+            raise TypeError(f'argument 1 of {func.__name__} has incompatible type {par_ann}, expected {data_type}')
         # validate the return value has the right annotation
-        if signature.return_annotation == signature.empty:
+        if ret_ann is None:
             raise TypeError(f'{func.__name__} does not have a declared return type, expected {data_type}')
-        if signature.return_annotation != data_type:
-            raise TypeError(
-                f'{func.__name__} has incompatible return type {signature.return_annotation}, expected {data_type}'
-            )
+        if ret_ann != data_type:
+            raise TypeError(f'{func.__name__} has incompatible return type {ret_ann}, expected {data_type}')
 
     def register_precmd_hook(self, func: Callable[[plugin.PrecommandData], plugin.PrecommandData]) -> None:
         """Register a hook to be called before the command function."""
@@ -5615,12 +5617,16 @@ class Cmd(cmd.Cmd):
     ) -> None:
         """Check parameter and return types for command finalization hooks."""
         cls._validate_callable_param_count(func, 1)
-        signature = inspect.signature(func)
-        _, param = next(iter(signature.parameters.items()))
-        if param.annotation != plugin.CommandFinalizationData:
-            raise TypeError(f"{func.__name__} must have one parameter declared with type {plugin.CommandFinalizationData}")
-        if signature.return_annotation != plugin.CommandFinalizationData:
-            raise TypeError("{func.__name__} must declare return a return type of {plugin.CommandFinalizationData}")
+        type_hints, ret_ann = get_types(func)
+        if not type_hints:
+            raise TypeError(f"{func.__name__} parameter is missing a type hint, expected: {plugin.CommandFinalizationData}")
+        _, par_ann = next(iter(type_hints.items()))
+        if par_ann != plugin.CommandFinalizationData:
+            raise TypeError(
+                f"{func.__name__} must have one parameter declared with type {plugin.CommandFinalizationData}, got: {par_ann}"
+            )
+        if ret_ann != plugin.CommandFinalizationData:
+            raise TypeError(f"{func.__name__} must declare return a return type of {plugin.CommandFinalizationData}")
 
     def register_cmdfinalization_hook(
         self, func: Callable[[plugin.CommandFinalizationData], plugin.CommandFinalizationData]

{cmd2-2.6.0 → cmd2-2.6.1}/cmd2/utils.py

@@ -14,29 +14,12 @@ import sys
 import threading
 import unicodedata
 from collections.abc import Callable, Iterable
-from difflib import (
-    SequenceMatcher,
-)
-from enum import (
-    Enum,
-)
-from typing import (
-    TYPE_CHECKING,
-    Any,
-    Optional,
-    TextIO,
-    TypeVar,
-    Union,
-    cast,
-)
-
-from . import (
-    constants,
-)
-from .argparse_custom import (
-    ChoicesProviderFunc,
-    CompleterFunc,
-)
+from difflib import SequenceMatcher
+from enum import Enum
+from typing import TYPE_CHECKING, Any, Optional, TextIO, TypeVar, Union, cast, get_type_hints
+
+from . import constants
+from .argparse_custom import ChoicesProviderFunc, CompleterFunc
 
 if TYPE_CHECKING:  # pragma: no cover
     import cmd2  # noqa: F401
@@ -1261,3 +1244,27 @@ def suggest_similar(
             best_simil = simil
             proposed_command = each
     return proposed_command
+
+
+def get_types(func_or_method: Callable[..., Any]) -> tuple[dict[str, Any], Any]:
+    """Use typing.get_type_hints() to extract type hints for parameters and return value.
+
+    This exists because the inspect module doesn't have a safe way of doing this that works
+    both with and without importing annotations from __future__ until Python 3.10.
+
+    TODO: Once cmd2 only supports Python 3.10+, change to use inspect.get_annotations(eval_str=True)
+
+    :param func_or_method: Function or method to return the type hints for
+    :return tuple with first element being dictionary mapping param names to type hints
+            and second element being return type hint, unspecified, returns None
+    """
+    try:
+        type_hints = get_type_hints(func_or_method)  # Get dictionary of type hints
+    except TypeError as exc:
+        raise ValueError("Argument passed to get_types should be a function or method") from exc
+    ret_ann = type_hints.pop('return', None)  # Pop off the return annotation if it exists
+    if inspect.ismethod(func_or_method):
+        type_hints.pop('self', None)  # Pop off `self` hint for methods
+    if ret_ann is type(None):
+        ret_ann = None  # Simplify logic to just return None instead of NoneType
+    return type_hints, ret_ann

{cmd2-2.6.0 → cmd2-2.6.1}/cmd2.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmd2
-Version: 2.6.0
+Version: 2.6.1
 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.6.0 → cmd2-2.6.1}/cmd2.egg-info/SOURCES.txt

@@ -309,6 +309,7 @@ tests/test_argparse_completer.py
 tests/test_argparse_custom.py
 tests/test_cmd2.py
 tests/test_completion.py
+tests/test_future_annotations.py
 tests/test_history.py
 tests/test_parsing.py
 tests/test_plugin.py

{cmd2-2.6.0 → cmd2-2.6.1}/pyproject.toml

@@ -147,9 +147,7 @@ exclude = [
 # Same as Black.
 line-length = 127
 indent-width = 4
-
-# Assume Python 3.13
-target-version = "py313"
+target-version = "py39" # Minimum supported version of Python
 output-format = "full"
 
 [tool.ruff.lint]
@@ -235,6 +233,7 @@ ignore = [
     "E111",   # Conflicts with ruff format
     "E114",   # Conflicts with ruff format
     "E117",   # Conflicts with ruff format
+    "FA100",  # Adding from __future__ import annotations screws up cmd2 because of how use inspect to validate type annotations at runtime
     "ISC002", # Conflicts with ruff format
     "Q000",   # Conflicts with ruff format
     "Q001",   # Conflicts with ruff format
@@ -258,36 +257,26 @@ dummy-variable-rgx = "^(_+|(_+[a-zA-Z0-9_]*[a-zA-Z0-9]+?))$"
 
 mccabe.max-complexity = 49
 
-per-file-ignores."cmd2/__init__.py" = [
-    "E402", # Module level import not at top of file
-    "F401", # Unused import
-]
+[tool.ruff.lint.per-file-ignores]
+# Module level import not at top of file and unused import
+"cmd2/__init__.py" = ["E402", "F401"]
 
-per-file-ignores."cmd2/argparse_custom.py" = [
-    "B010", # Do not call setattr with a constant attribute value
-]
+# Do not call setattr with constant attribute value
+"cmd2/argparse_custom.py" = ["B010"]
 
-per-file-ignores."examples/*.py" = [
+# Ignore various varnings in examples/ directory
+"examples/*.py" = [
     "ANN",     # Ignore all type annotation rules in examples folder
     "D",       # Ignore all pydocstyle rules in examples folder
     "INP001",  # Module is part of an implicit namespace
     "PLW2901", # loop variable overwritten inside loop
     "S",       # Ignore all Security rules in examples folder
 ]
+"examples/scripts/*.py" = ["F821"] # Undefined name `app`
+"plugins/*.py" = ["INP001"] # Module is part of an implicit namespace
 
-per-file-ignores."examples/scripts/*.py" = [
-    "F821", # Undefined name `app`
-]
-
-per-file-ignores."plugins/*.py" = [
-    "ANN",    # Ignore all type annotation rules in test folders
-    "D",      # Ignore all pydocstyle rules in test folders
-    "INP001", # Module is part of an implicit namespace
-    "S",      # Ignore all Security rules in test folders
-    "SLF",    # Ignore all warnings about private or protected member access in test folders
-]
-
-per-file-ignores."tests/*.py" = [
+# Ingore various rulesets in test and plugins directories
+"{plugins,tests,tests_isolated}/*.py" = [
     "ANN",  # Ignore all type annotation rules in test folders
     "ARG",  # Ignore all unused argument warnings in test folders
     "D",    # Ignore all pydocstyle rules in test folders
@@ -295,19 +284,8 @@ per-file-ignores."tests/*.py" = [
     "S",    # Ignore all Security rules in test folders
     "SLF",  # Ignore all warnings about private or protected member access in test folders
 ]
-
-per-file-ignores."tests/pyscript/*.py" = [
-    "F821",   # Undefined name `app`
-    "INP001", # Module is part of an implicit namespace
-]
-
-per-file-ignores."tests_isolated/*.py" = [
-    "ANN", # Ignore all type annotation rules in test folders
-    "ARG", # Ignore all unused argument warnings in test folders
-    "D",   # Ignore all pydocstyle rules in test folders
-    "S",   # Ignore all Security rules in test folders
-    "SLF", # Ignore all warnings about private or protected member access in test folders
-]
+# Undefined name `app` and module is part of an implicit namespace
+"tests/pyscript/*.py" = ["F821", "INP001"]
 
 [tool.ruff.format]
 # Like Black, use double quotes for strings.

cmd2-2.6.1/tests/test_future_annotations.py

@@ -0,0 +1,22 @@
+from __future__ import annotations
+
+import cmd2
+
+from .conftest import normalize, run_cmd
+
+
+def test_hooks_work_with_future_annotations() -> None:
+    class HookApp(cmd2.Cmd):
+        def __init__(self, *args, **kwargs) -> None:
+            super().__init__(*args, **kwargs)
+            self.register_cmdfinalization_hook(self.hook)
+
+        def hook(self: cmd2.Cmd, data: cmd2.plugin.CommandFinalizationData) -> cmd2.plugin.CommandFinalizationData:
+            if self.in_script():
+                self.poutput("WE ARE IN SCRIPT")
+            return data
+
+    hook_app = HookApp()
+    out, err = run_cmd(hook_app, '')
+    expected = normalize('')
+    assert out == expected

{cmd2-2.6.0 → cmd2-2.6.1}/tests/test_utils.py

@@ -892,3 +892,44 @@ def test_similarity_overwrite_function() -> None:
 
     suggested_command = cu.suggest_similar("test", ["test"], similarity_function_to_use=custom_similarity_function)
     assert suggested_command is None
+
+
+def test_get_types_invalid_input() -> None:
+    x = 1
+    with pytest.raises(ValueError, match="Argument passed to get_types should be a function or method"):
+        cu.get_types(x)
+
+
+def test_get_types_empty() -> None:
+    def a(b):
+        print(b)
+
+    param_ann, ret_ann = cu.get_types(a)
+    assert ret_ann is None
+    assert param_ann == {}
+
+
+def test_get_types_non_empty() -> None:
+    def foo(x: int) -> str:
+        return f"{x * x}"
+
+    param_ann, ret_ann = cu.get_types(foo)
+    assert ret_ann is str
+    param_name, param_value = next(iter(param_ann.items()))
+    assert param_name == 'x'
+    assert param_value is int
+
+
+def test_get_types_method() -> None:
+    class Foo:
+        def bar(self, x: bool) -> None:
+            print(x)
+
+    f = Foo()
+
+    param_ann, ret_ann = cu.get_types(f.bar)
+    assert ret_ann is None
+    assert len(param_ann) == 1
+    param_name, param_value = next(iter(param_ann.items()))
+    assert param_name == 'x'
+    assert param_value is bool