cmd2 4.2.0__tar.gz → 4.2.2__tar.gz

{cmd2-4.2.0 → cmd2-4.2.2}/.pre-commit-config.yaml

@@ -14,7 +14,7 @@ repos:
       - id: trailing-whitespace
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: "v0.16.1"
+    rev: "v0.16.3"
     hooks:
       - id: ruff-format
         args: [--config=ruff.toml]
@@ -30,7 +30,7 @@ repos:
           - prettier-plugin-toml@2.0.6
 
   - repo: https://github.com/crate-ci/typos
-    rev: v1.48.0
+    rev: v1.49.0
     hooks:
       - id: typos
         exclude: |

{cmd2-4.2.0 → cmd2-4.2.2}/CHANGELOG.md

@@ -1,3 +1,17 @@
+## 4.2.2 (August 25, 2026)
+
+- Documentation Improvements
+    - Improved documentation in attempt at making some recommended best-practices more discoverable
+    - Fixed the broken `cmd_as_argument` example
+
+## 4.2.1 (August 22, 2026)
+
+- Enhancements
+    - Added bracketed paste support so multiple pasted commands execute sequentially and multiline
+      commands continue as expected.
+- Bug Fixes
+    - Enabled Ctrl-Z suspension at the prompt
+
 ## 4.2.0 (August 6, 2026)
 
 - Enhancements
@@ -1886,7 +1900,7 @@ time reading the [rich documentation](https://rich.readthedocs.io/).
         - **with_argument_list** decorator to change argument type from str to List[str]
             - **do\_\*** commands get a single argument which is a list of strings, as pre-parsed by
               shlex.split()
-        - **with_arparser** decorator for strict argparse-based argument parsing of command
+        - **with_argparser** decorator for strict argparse-based argument parsing of command
           arguments
             - **do\_\*** commands get a single argument which is the output of argparse.parse_args()
         - **with_argparser_and_unknown_args** decorator for argparse-based argument parsing, but

{cmd2-4.2.0 → cmd2-4.2.2}/Makefile

@@ -18,8 +18,8 @@ check: ## Run code quality tools.
 	@uv lock --locked
 	@echo "🚀 Auto-formatting/Linting code and documentation: Running prek"
 	@uv run prek run -a
-	@echo "🚀 Static type checking: Running mypy"
-	@uv run mypy
+	@echo "🚀 Static type checking: Running ty"
+	@uv run ty check
 
 .PHONY: format
 format: ## Perform ruff formatting
@@ -31,7 +31,7 @@ lint: ## Perform ruff linting
 
 .PHONY: typecheck
 typecheck: ## Perform type checking
-	@uv run mypy
+	@uv run ty check
 
 .PHONY: test
 test: ## Test the code with pytest.
@@ -76,7 +76,7 @@ publish: validate-tag build ## Publish a release to PyPI, uses token from ~/.pyp
 # Define variables for files/directories to clean
 BUILD_DIRS = build dist *.egg-info
 DOC_DIRS = build
-MYPY_DIRS = .mypy_cache dmypy.json dmypy.sock
+TY_DIRS = .ty_cache .red_knot_cache
 TEST_DIRS = .cache .pytest_cache htmlcov
 TEST_FILES = .coverage coverage.xml
 
@@ -90,10 +90,10 @@ clean-docs: ## Clean documentation artifacts
 	@echo "🚀 Removing documentation artifacts"
 	@uv run python -c "import shutil; import os; [shutil.rmtree(d, ignore_errors=True) for d in '$(DOC_DIRS)'.split() if os.path.isdir(d)]"
 
-.PHONY: clean-mypy
-clean-mypy: ## Clean mypy artifacts
-	@echo "🚀 Removing mypy artifacts"
-	@uv run python -c "import shutil; import os; [shutil.rmtree(d, ignore_errors=True) for d in '$(MYPY_DIRS)'.split() if os.path.isdir(d)]"
+.PHONY: clean-ty
+clean-ty: ## Clean ty artifacts
+	@echo "🚀 Removing ty artifacts"
+	@uv run python -c "import shutil; import os; [shutil.rmtree(d, ignore_errors=True) for d in '$(TY_DIRS)'.split() if os.path.isdir(d)]"
 
 .PHONY: clean-pycache
 clean-pycache: ## Clean pycache artifacts
@@ -112,7 +112,7 @@ clean-test: ## Clean test artifacts
 	@uv run python -c "from pathlib import Path; [Path(f).unlink(missing_ok=True) for f in '$(TEST_FILES)'.split()]"
 
 .PHONY: clean
-clean: clean-build clean-docs clean-mypy clean-pycache clean-ruff clean-test ## Clean all artifacts
+clean: clean-build clean-docs clean-ty clean-pycache clean-ruff clean-test ## Clean all artifacts
 	@echo "🚀 Cleaned all artifacts"
 
 .PHONY: help

{cmd2-4.2.0 → cmd2-4.2.2}/PKG-INFO

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

{cmd2-4.2.0 → cmd2-4.2.2}/cmd2/annotated.py

@@ -708,10 +708,10 @@ class _CollectionCastingAction(argparse._StoreAction):
 
     def __call__(
         self,
-        _parser: argparse.ArgumentParser,
+        parser: argparse.ArgumentParser,  # noqa: ARG002
         namespace: argparse.Namespace,
         values: Any,
-        _option_string: str | None = None,
+        option_string: str | None = None,  # noqa: ARG002
     ) -> None:
         result = values
         if self._container_factory is not None and isinstance(values, list):
@@ -879,7 +879,7 @@ def _resolve_union(
         raise TypeError(f"Union type {type_names} is ambiguous for auto-resolution.")
 
     parts = [_resolve_base_type(member, allow_unknown_entry=allow_unknown_entry) for member in non_none]
-    # Every part is an Enum (guarded above), so each has a converter; the None-filter keeps mypy happy.
+    # Every part is an Enum (guarded above), so each has a converter; the None-filter keeps the type checker happy.
     converters = [part.converter for part in parts if part.converter is not None]
     choices = _dedupe_choices(choice for part in parts for choice in (part.choices or []))
 
@@ -2189,7 +2189,7 @@ def _find_argument_block(hint: Any) -> type[ArgumentBlock] | None:
     return None
 
 
-def _init_field_names(dc_type: type) -> list[str]:
+def _init_field_names(dc_type: Any) -> list[str]:
     """Names of a dataclass's ``init`` fields in definition order (the flat argument names of a block)."""
     return [f.name for f in fields(dc_type) if f.init]
 
@@ -3113,6 +3113,9 @@ def with_annotated(
             except SystemExit as exc:
                 raise Cmd2ArgparseError from exc
 
+            if ns is None:
+                raise ValueError("ns is None")
+
             setattr(ns, constants.NS_ATTR_STATEMENT, statement)
             handler = getattr(ns, constants.NS_ATTR_SUBCOMMAND_FUNC, None)
             if base_command and handler is not None:

{cmd2-4.2.0 → cmd2-4.2.2}/cmd2/argparse_utils.py

@@ -747,8 +747,8 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
         super().__init__(
             prog=prog,
             usage=usage,
-            description=description,  # type: ignore[arg-type]
-            epilog=epilog,  # type: ignore[arg-type]
+            description=description,  # type: ignore[arg-type, ty:invalid-argument-type]
+            epilog=epilog,  # type: ignore[arg-type, ty:invalid-argument-type]
             parents=parents,
             formatter_class=formatter_class,
             prefix_chars=prefix_chars,
@@ -772,7 +772,7 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
         self.description: HelpContent | None  # type: ignore[assignment]
         self.epilog: HelpContent | None  # type: ignore[assignment]
 
-    def print_usage(self, file: IO[str] | None = None) -> None:  # type:ignore[override]
+    def print_usage(self, file: IO[str] | None = None) -> None:  # type: ignore[override, ty:invalid-method-override]
         """Override to ensure the formatter is aware of the target file."""
         if file is None:
             file = self._thread_locals.current_output_file
@@ -780,7 +780,7 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
         with self.output_to(file):
             super().print_usage(file)
 
-    def print_help(self, file: IO[str] | None = None) -> None:  # type:ignore[override]
+    def print_help(self, file: IO[str] | None = None) -> None:  # type: ignore[override, ty:invalid-method-override]
         """Override to ensure the formatter is aware of the target file."""
         if file is None:
             file = self._thread_locals.current_output_file
@@ -831,7 +831,7 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
         temp_parser = Cmd2ArgumentParser(
             prog=self.prog,
             usage=None,
-            formatter_class=self.formatter_class,
+            formatter_class=cast(type[Cmd2HelpFormatter], self.formatter_class),
             add_help=False,
         )
 
@@ -1037,7 +1037,8 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
 
     def _get_formatter(self, *_args: Any, **_kwargs: Any) -> Cmd2HelpFormatter:
         """Override with customizations for Cmd2HelpFormatter."""
-        return self.formatter_class(prog=self.prog, file=self._thread_locals.current_output_file)
+        formatter_class = cast(type[Cmd2HelpFormatter], self.formatter_class)
+        return formatter_class(prog=self.prog, file=self._thread_locals.current_output_file)
 
     def format_help(self, *args: Any, **kwargs: Any) -> str:
         """Override to add a newline."""

{cmd2-4.2.0 → cmd2-4.2.2}/cmd2/cmd2.py

@@ -78,6 +78,8 @@ from prompt_toolkit.formatted_text import ANSI, AnyFormattedText
 from prompt_toolkit.history import InMemoryHistory
 from prompt_toolkit.input import DummyInput, create_input
 from prompt_toolkit.key_binding import KeyBindings
+from prompt_toolkit.key_binding.key_processor import KeyPress, KeyPressEvent
+from prompt_toolkit.keys import Keys
 from prompt_toolkit.output import DummyOutput, create_output
 from prompt_toolkit.patch_stdout import patch_stdout
 from prompt_toolkit.shortcuts import CompleteStyle, PromptSession, choice, set_title
@@ -740,6 +742,50 @@ class Cmd:
                 # No macro found or already processed. The statement is complete.
                 return False
 
+    def _create_key_bindings(self, completekey: str) -> KeyBindings:
+        """Create and configure custom key bindings for the PromptSession."""
+        key_bindings = KeyBindings()
+
+        if completekey != self.DEFAULT_COMPLETEKEY:
+
+            @key_bindings.add(completekey)
+            def _trigger_completion(event: KeyPressEvent) -> None:  # pragma: no cover
+                """Trigger completion using the custom completion key."""
+                b = event.current_buffer
+                if b.complete_state:
+                    b.complete_next()
+                else:
+                    b.start_completion(select_first=False)
+
+        @key_bindings.add("enter", filter=filters.completion_is_selected)
+        def _accept_completion(event: KeyPressEvent) -> None:  # pragma: no cover
+            """Accept a selected completion on Enter without submitting the command."""
+            event.current_buffer.complete_state = None
+
+        @key_bindings.add(Keys.BracketedPaste)
+        def _handle_bracketed_paste(event: KeyPressEvent) -> None:
+            """Handle bracketed paste by feeding lines as keystrokes separated by Enter.
+
+            By default, prompt_toolkit inserts pasted text as a single buffer blob.
+            Translating newlines into Enter keystrokes allows multiple pasted commands
+            to execute sequentially and multiline commands to continue as expected.
+            """
+            data = event.data.replace("\r\n", "\n").replace("\r", "\n")
+            if "\n" not in data:
+                event.current_buffer.insert_text(data)
+                return
+
+            key_presses = []
+            for i, line in enumerate(data.split("\n")):
+                if i > 0:
+                    key_presses.append(KeyPress(Keys.ControlM, "\r"))
+                if line:
+                    key_presses.append(KeyPress(Keys.Any, line))
+
+            event.key_processor.feed_multiple(key_presses)
+
+        return key_bindings
+
     def _create_main_session(
         self,
         *,
@@ -756,26 +802,6 @@ class Cmd:
         Otherwise, uses dummy drivers to support non-interactive streams like
         pipes or files.
         """
-        # Configure custom key bindings
-        key_bindings = KeyBindings()
-
-        # Add a binding for 'enter' that triggers only when a completion is selected.
-        # This allows accepting a completion without submitting the command.
-        @key_bindings.add("enter", filter=filters.completion_is_selected)
-        def _(event: Any) -> None:  # pragma: no cover
-            event.current_buffer.complete_state = None
-
-        if completekey != self.DEFAULT_COMPLETEKEY:
-            # Configure prompt_toolkit `KeyBindings` with the custom key for completion
-            @key_bindings.add(completekey)
-            def _(event: Any) -> None:  # pragma: no cover
-                """Trigger completion."""
-                b = event.current_buffer
-                if b.complete_state:
-                    b.complete_next()
-                else:
-                    b.start_completion(select_first=False)
-
         # Base configuration
         kwargs: dict[str, Any] = {
             "auto_suggest": AutoSuggestFromHistory() if auto_suggest else None,
@@ -785,8 +811,9 @@ class Cmd:
             "complete_in_thread": complete_in_thread,
             "complete_while_typing": False,
             "completer": Cmd2Completer(self),
+            "enable_suspend": True,
             "history": Cmd2History(item.raw for item in self.history),
-            "key_bindings": key_bindings,
+            "key_bindings": self._create_key_bindings(completekey),
             "lexer": Cmd2Lexer(self),
             "multiline": filters.Condition(self._should_continue_multiline),
             "prompt_continuation": self.continuation_prompt,
@@ -849,7 +876,7 @@ class Cmd:
         all_commandset_defs = CommandSet.__subclasses__()
         existing_commandset_types = [type(command_set) for command_set in self._installed_command_sets]
 
-        def load_commandset_by_type(commandset_types: list[type[CommandSet[Any]]]) -> None:
+        def load_commandset_by_type(commandset_types: Sequence[type[CommandSet[Any]]]) -> None:
             for cmdset_type in commandset_types:
                 # check if the type has sub-classes. We will only auto-load leaf class types.
                 subclasses = cmdset_type.__subclasses__()
@@ -2547,11 +2574,11 @@ class Cmd:
                             completer.complete, tokens=raw_tokens[1:] if spec.preserve_quotes else tokens[1:], cmd_set=cmd_set
                         )
                     else:
-                        completer_func = self.completedefault  # type: ignore[assignment]
+                        completer_func = self.completedefault  # type: ignore[assignment, ty:invalid-assignment]
 
             # Not a recognized macro or command
             else:
-                completer_func = self.completedefault  # type: ignore[assignment]
+                completer_func = self.completedefault  # type: ignore[assignment, ty:invalid-assignment]
 
         # Otherwise we are completing the command token or performing custom completion
         else:
@@ -2968,7 +2995,7 @@ class Cmd:
                 with self.sigint_protection:
                     if py_bridge_call:
                         # Start saving command's stdout at this point
-                        self.stdout.pause_storage = False  # type: ignore[attr-defined]
+                        self.stdout.pause_storage = False  # type: ignore[attr-defined, ty:invalid-assignment]
 
                     redir_saved_state = self._redirect_output(statement)
 
@@ -3007,7 +3034,7 @@ class Cmd:
 
                     if py_bridge_call:
                         # Stop saving command's stdout before command finalization hooks run
-                        self.stdout.pause_storage = True  # type: ignore[attr-defined]
+                        self.stdout.pause_storage = True  # type: ignore[attr-defined, ty:invalid-assignment]
         except (SkipPostcommandHooks, EmptyStatement):
             # Don't do anything, but do allow command finalization hooks to run
             pass
@@ -3512,7 +3539,7 @@ class Cmd:
                     self.active_session = self.main_session
 
         # We're not at a terminal, so we're likely reading from a file or a pipe.
-        prompt_obj = prompt() if callable(prompt) else prompt
+        prompt_obj = prompt if isinstance(prompt, (ANSI, str)) else prompt()
         prompt_str = prompt_obj.value if isinstance(prompt_obj, ANSI) else prompt_obj
 
         # If this is an interactive pipe, then display the prompt first
@@ -3613,6 +3640,7 @@ class Cmd:
             complete_in_thread=self.main_session.complete_in_thread,
             complete_while_typing=self.main_session.complete_while_typing,
             completer=completer_to_use,
+            enable_suspend=self.main_session.enable_suspend,
             history=InMemoryHistory(history) if history is not None else InMemoryHistory(),
             key_bindings=self.main_session.key_bindings,
             input=self.main_session.input,
@@ -3635,6 +3663,7 @@ class Cmd:
         """
         temp_session: PromptSession[str] = PromptSession(
             color_depth=self.main_session.color_depth,
+            enable_suspend=self.main_session.enable_suspend,
             input=self.main_session.input,
             output=self.main_session.output,
             style=self.main_session.style,
@@ -3800,7 +3829,7 @@ class Cmd:
             "An alias is a command that enables replacement of a word by another string.",
         )
         alias_parser = argparse_utils.DEFAULT_ARGUMENT_PARSER(description=alias_description)
-        alias_parser.epilog = TextGroup(
+        alias_parser.epilog = TextGroup(  # type: ignore[assignment, ty:invalid-assignment]
             "See Also",
             "macro",
         )
@@ -3832,7 +3861,7 @@ class Cmd:
                 "for the actual command the alias resolves to."
             ),
         )
-        alias_create_parser.epilog = TextGroup("Notes", alias_create_notes)
+        alias_create_parser.epilog = TextGroup("Notes", alias_create_notes)  # type: ignore[assignment, ty:invalid-assignment]
 
         # Add arguments
         alias_create_parser.add_argument("name", help="name of this alias")
@@ -4014,7 +4043,7 @@ class Cmd:
             "A macro is similar to an alias, but it can contain argument placeholders.",
         )
         macro_parser = argparse_utils.DEFAULT_ARGUMENT_PARSER(description=macro_description)
-        macro_parser.epilog = TextGroup(
+        macro_parser.epilog = TextGroup(  # type: ignore[assignment, ty:invalid-assignment]
             "See Also",
             "alias",
         )
@@ -4077,7 +4106,7 @@ class Cmd:
                 "This default behavior changes if custom completion for macro arguments has been implemented."
             ),
         )
-        macro_create_parser.epilog = TextGroup("Notes", macro_create_notes)
+        macro_create_parser.epilog = TextGroup("Notes", macro_create_notes)  # type: ignore[assignment, ty:invalid-assignment]
 
         # Add arguments
         macro_create_parser.add_argument("name", help="name of this macro")
@@ -4572,7 +4601,7 @@ class Cmd:
     @staticmethod
     def _build__eof_parser() -> Cmd2ArgumentParser:
         _eof_parser = argparse_utils.DEFAULT_ARGUMENT_PARSER(description="Called when Ctrl-D is pressed.")
-        _eof_parser.epilog = TextGroup(
+        _eof_parser.epilog = TextGroup(  # type: ignore[assignment, ty:invalid-assignment]
             "Note",
             "This command is for internal use and is not intended to be called from the command line.",
         )
@@ -5032,7 +5061,7 @@ class Cmd:
             # Check if we are running Python code
             if py_code_to_run:
                 try:  # noqa: SIM105
-                    interp.runcode(py_code_to_run)  # type: ignore[arg-type]
+                    interp.runcode(py_code_to_run)  # type: ignore[arg-type, ty:invalid-argument-type]
                 except BaseException:  # noqa: BLE001, S110
                     # We don't care about any exception that happened in the Python code
                     pass
@@ -5418,11 +5447,11 @@ class Cmd:
         try:
             import lzma as decompress_lib
 
-            decompress_exceptions: tuple[type[Exception]] = (decompress_lib.LZMAError,)
+            decompress_exceptions: tuple[type[Exception], ...] = (decompress_lib.LZMAError,)
         except ModuleNotFoundError:  # pragma: no cover
             import bz2 as decompress_lib  # type: ignore[no-redef]
 
-            decompress_exceptions: tuple[type[Exception]] = (OSError, ValueError)  # type: ignore[no-redef]
+            decompress_exceptions: tuple[type[Exception], ...] = (OSError, ValueError)  # type: ignore[no-redef]
 
         try:
             history_json = decompress_lib.decompress(compressed_bytes).decode(encoding="utf-8")
@@ -5471,7 +5500,7 @@ class Cmd:
     def _build_edit_parser(cls) -> Cmd2ArgumentParser:
         edit_description = "Run a text editor and optionally open a file with it."
         edit_parser = argparse_utils.DEFAULT_ARGUMENT_PARSER(description=edit_description)
-        edit_parser.epilog = TextGroup(
+        edit_parser.epilog = TextGroup(  # type: ignore[assignment, ty:invalid-assignment]
             "Note",
             Text.assemble(
                 "To set a new editor, run: ",
@@ -5593,7 +5622,7 @@ class Cmd:
         _relative_run_script_parser = cls._build_base_run_script_parser()
 
         # Append to existing description
-        _relative_run_script_parser.description = Group(
+        _relative_run_script_parser.description = Group(  # type: ignore[assignment, ty:invalid-assignment]
             cast(Group, _relative_run_script_parser.description),
             "\n",
             (
@@ -5602,7 +5631,7 @@ class Cmd:
             ),
         )
 
-        _relative_run_script_parser.epilog = TextGroup(
+        _relative_run_script_parser.epilog = TextGroup(  # type: ignore[assignment, ty:invalid-assignment]
             "Note",
             "This command is intended to be used from within a text script.",
         )

{cmd2-4.2.0 → cmd2-4.2.2}/cmd2/decorators.py

@@ -310,7 +310,7 @@ def with_argparser(
         :return: Function that takes raw input and converts to an argparse Namespace to passed to the wrapped function.
         """
 
-        @functools.wraps(func)
+        @functools.wraps(func)  # type: ignore[arg-type, ty:invalid-argument-type]
         def cmd_wrapper(*args: Any, **kwargs: Any) -> bool | None:
             """Command function wrapper which translates command line into argparse Namespace and call actual command function.
 
@@ -345,9 +345,9 @@ def with_argparser(
                 parsing_results: tuple[argparse.Namespace] | tuple[argparse.Namespace, list[str]]
                 with arg_parser.output_to(cmd_app.stdout):
                     if with_unknown_args:
-                        parsing_results = arg_parser.parse_known_args(command_arg_list, initial_namespace)
+                        parsing_results = arg_parser.parse_known_args(command_arg_list, initial_namespace)  # type: ignore[assignment, ty:invalid-assignment]
                     else:
-                        parsing_results = (arg_parser.parse_args(command_arg_list, initial_namespace),)
+                        parsing_results = (arg_parser.parse_args(command_arg_list, initial_namespace),)  # type: ignore[assignment, ty:invalid-assignment]
             except SystemExit as exc:
                 raise Cmd2ArgparseError from exc
 

{cmd2-4.2.0 → cmd2-4.2.2}/cmd2/parsing.py

@@ -248,7 +248,7 @@ class PartialStatement:
 
     Note:
         Unlike [cmd2.parsing.Statement][], this is a simple data object
-        and does not inherit from [str][].
+        and does not inherit from `str`.
 
     """
 
@@ -552,7 +552,7 @@ class StatementParser:
     def parse_command_only(self, rawinput: str) -> PartialStatement:
         """Identify the command and arguments from raw input.
 
-        Partially parse input into a [cmd2.PartialStatement][] object.
+        Partially parse input into a [cmd2.parsing.PartialStatement][] object.
 
         The command is identified, and shortcuts and aliases are expanded.
         Multiline commands are identified, but terminators and output
@@ -561,7 +561,7 @@ class StatementParser:
         This method is optimized for completion code and gracefully handles
         unclosed quotes without raising exceptions.
 
-        [cmd2.parsing.PartialStatement.args][] will include all output redirection
+        `cmd2.parsing.PartialStatement.args` will include all output redirection
         clauses and command terminators.
 
         Note:
@@ -571,7 +571,7 @@ class StatementParser:
             whitespace only if all quotes are closed.
 
         :param rawinput: the command line as entered by the user
-        :return: a [cmd2.PartialStatement][] object representing the split input
+        :return: a `PartialStatement` object representing the split input
 
         """
         # Expand shortcuts and aliases

{cmd2-4.2.0 → cmd2-4.2.2}/cmd2/pt_utils.py

@@ -148,7 +148,7 @@ class Cmd2Completer(Completer):
         self._cmd_app = cmd_app
         self.custom_settings = custom_settings
 
-    def get_completions(self, document: Document, _complete_event: object) -> Iterable[Completion]:
+    def get_completions(self, document: Document, complete_event: object) -> Iterable[Completion]:  # noqa: ARG002
         """Get completions for the current input."""
         # Find the beginning of the current word based on delimiters
         line = document.text

{cmd2-4.2.0 → cmd2-4.2.2}/cmd2/rich_utils.py

@@ -105,7 +105,7 @@ class AllowStyle(Enum):
 
 
 # Controls when ANSI style sequences are allowed in output
-ALLOW_STYLE = AllowStyle.TERMINAL
+ALLOW_STYLE: AllowStyle = AllowStyle.TERMINAL
 
 
 class Cmd2HelpFormatter(RichHelpFormatter):

{cmd2-4.2.0 → cmd2-4.2.2}/cmd2.egg-info/PKG-INFO

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

{cmd2-4.2.0 → cmd2-4.2.2}/cmd2.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ mkdocs.yml
 package.json
 pyproject.toml
 ruff.toml
+ty.toml
 cmd2/__init__.py
 cmd2/annotated.py
 cmd2/argparse_completer.py
@@ -128,6 +129,7 @@ examples/async_call.py
 examples/async_commands.py
 examples/async_printing.py
 examples/basic_completion.py
+examples/cmd2_history.dat
 examples/cmd_as_argument.py
 examples/color.py
 examples/command_sets.py