cmd2 4.2.3__tar.gz → 4.3.0__tar.gz

{cmd2-4.2.3 → cmd2-4.3.0}/.pre-commit-config.yaml

@@ -15,7 +15,7 @@ repos:
       - id: trailing-whitespace
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: "v0.16.5"
+    rev: "v0.17.0"
     hooks:
       - id: ruff-format
         args: [--config=ruff.toml]
@@ -31,7 +31,7 @@ repos:
           - prettier-plugin-toml@2.0.6
 
   - repo: https://github.com/crate-ci/typos
-    rev: v1.50.0
+    rev: v1.51.1
     hooks:
       - id: typos
         exclude: |

{cmd2-4.2.3 → cmd2-4.3.0}/.prettierrc

@@ -1,4 +1,5 @@
 {
+  "endOfLine": "lf",
   "printWidth": 100,
   "proseWrap": "always",
   "overrides": [

{cmd2-4.2.3 → cmd2-4.3.0}/AGENTS.md

@@ -15,6 +15,8 @@ project, which utilizes `uv` for environment and package management.
 - **New Dependencies:** If a new dependency is required, please state the reason for its inclusion.
 - Do not commit spec, plan, or markdown documents to git without asking first.
 - Save plans to `~/.superpowers/plans/` instead of the project directory.
+- This project uses a 127 character maximum line length for all Python code, including for comments.
+- This project uses a 100 character maximum line length for Markdown files.
 
 ## Python Code Standards
 

{cmd2-4.2.3 → cmd2-4.3.0}/CHANGELOG.md

@@ -1,3 +1,47 @@
+## 4.3.0 (October 13, 2026)
+
+- Stabilized features
+    - `@with_annotated` is no longer experimental. It was introduced as an experimental feature in
+      4.0.0 and is now a fully supported way to define a command's arguments, alongside
+      `@with_argparser`. This covers the decorator and its supporting API in `cmd2.annotated`,
+      including `Argument`, `Option`, `Group`, and `ArgumentBlock`.
+      [Annotated Argument Processing](https://cmd2.readthedocs.io/en/latest/features/annotated/).
+- Bug Fixes
+    - On POSIX, piping a command's output to an interactive program such as `less`
+      (`help -v | less`) now runs that program as the terminal's foreground job, as a shell pipeline
+      does. It had run in a separate session that never received the terminal, so Ctrl-Z and `fg`
+      did not suspend and resume it together with cmd2. The program now owns the terminal as it
+      starts, so a pager can set its terminal modes, and Ctrl-C and Ctrl-Z reach the whole pipeline.
+      Pipes started from a worker thread, or whose output does not go to the terminal, such as one
+      nested in a command whose own output is piped, still run in their own session
+    - A `shell` command piped to an interactive program, such as `shell git log | less`, now joins
+      the pipeline's job, so both processes receive Ctrl-C and Ctrl-Z
+    - On Windows, fixed piped output appearing garbled in console programs such as `more`
+      (`help -v | more`), a regression in 4.2.4. Pipes are written as UTF-8, but console programs
+      decode their input with the console's code page. While a pipe or the pager runs, cmd2 now sets
+      the console to UTF-8 (code page 65001, as `chcp 65001` does) and restores its code pages
+      afterward, so console programs and UTF-8 tools such as `rg` both read the output correctly
+    - When copying a command's output to the clipboard (`help >`) fails, later commands' output is
+      no longer written to the temporary file that held it
+    - When a pipe's process cannot be started, for instance because no more processes can be created
+      or `$SHELL` names a program that cannot run, both ends of the pipe are now closed rather than
+      left open
+    - When a pipe's process exits before the command runs, what it wrote, such as the shell's
+      "command not found", is no longer lost when cmd2 captures the output, as in a pyscript
+
+## 4.2.4 (September 8, 2026)
+
+- Bug Fixes
+    - Fixed output redirection and piping raising `UnicodeEncodeError` and leaving an empty file
+      behind. Command output is rendered by Rich and contains box-drawing characters, which no
+      `cp125x` Windows ANSI code page can represent, so redirecting or piping it failed. This
+      affects current Windows 11 with default settings on Python 3.11 through 3.14, not only older
+      systems. Redirection targets and pipes now use UTF-8 explicitly
+    - Fixed the right prompt being redrawn beside every accepted command line in the scrollback.
+      prompt-toolkit includes it in the final frame of each prompt, which is the frame left on the
+      terminal; it is now hidden there, as the bottom toolbar already was, and stays on the live
+      prompt line only
+
 ## 4.2.3 (September 2, 2026)
 
 - Bug Fixes

cmd2-4.3.0/CLAUDE.md

@@ -0,0 +1,126 @@
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this
+repository.
+
+## Project
+
+`cmd2` is a framework for building interactive command-line applications (REPLs) in Python. It
+extends the stdlib `cmd` module and is built on **prompt-toolkit** (interactive input, key bindings,
+completion, toolbars) and **Rich** / **rich-argparse** (all output rendering, help formatting,
+theming). Requires Python >= 3.11. Environment/package management is **uv**.
+
+## Commands
+
+All work happens inside the uv-managed venv — run Python via `uv run ...`, and `uvx ...` for one-off
+tools. Never `pip install`; if a new dependency is needed, state why before adding it.
+
+```bash
+make install     # create the venv, install prek git hooks + prettier (one time)
+make check       # lock check + prek (ruff format/lint, prettier, typos) + ty + mypy
+make test        # pytest with coverage over tests/
+make docs-test   # verify the docs build cleanly (zensical)
+make docs        # build + serve docs with live reload
+make help        # list all targets
+```
+
+`make check`, `make test`, and `make docs-test` must all pass before committing. Run `make check`
+before creating or modifying any `.py` file as well.
+
+Narrower targets: `make format`, `make lint`, `make mypy`, `make ty`, `make typecheck`.
+
+Running a single test or file (coverage flags come from `pyproject.toml` `addopts`, so pass
+`--no-cov` when you just want a fast run):
+
+```bash
+uv run pytest tests/test_cmd2.py --no-cov
+uv run pytest tests/test_cmd2.py::test_base_help -x --no-cov
+uv run pytest -k "toolbar" --no-cov
+```
+
+On Windows-sensitive code, note `make test` runs pytest under `python -Xutf8`.
+
+## Architecture
+
+### Command dispatch
+
+`cmd2/cmd2.py` (the `Cmd` class) is the core and by far the largest module. The flow for one line of
+input is:
+
+1. `cmdloop()` → `_cmdloop()` drives a prompt-toolkit `PromptSession` (created in
+   `_create_prompt_session`), not readline. Completion, history, lexing, and key bindings are all
+   supplied by prompt-toolkit adapters in `cmd2/pt_utils.py` (`Cmd2Completer`, `Cmd2History`,
+   `Cmd2Lexer`).
+2. `onecmd_plus_hooks()` parses the line into a `Statement` (`cmd2/parsing.py` — handles shortcuts,
+   aliases, macros, terminators, multiline commands, redirection and pipe tokens), then runs the
+   plugin hook chain.
+3. `_redirect_output()` swaps `self.stdout` for a file or subprocess pipe when the statement has
+   redirection, and restores it in the `finally` path.
+4. `onecmd()` looks up and calls the `do_*` method.
+
+Hooks (`cmd2/plugin.py` dataclasses, registered via `register_postparsing_hook`,
+`register_precmd_hook`, `register_postcmd_hook`, `register_cmdfinalization_hook`,
+`register_preloop_hook`, `register_postloop_hook`) are the supported extension points; the legacy
+`precmd`/`postcmd` overrides still exist but are weaker.
+
+### Argument parsing and completion
+
+Three layers, all producing a `Cmd2ArgumentParser`:
+
+- `cmd2/argparse_utils.py` — `Cmd2ArgumentParser` plus monkey-patching that extends argparse with
+  range `nargs` tuples, per-argument completion metadata, and subcommand records.
+- `cmd2/decorators.py` — `@with_argparser`, `@with_argument_list`, `@with_category`,
+  `@as_subcommand_to` attach parsers/metadata to `do_*` methods.
+- `cmd2/annotated.py` — the newer Typer-style path (experimental in 4.0.0, stable as of 4.3.0):
+  `@with_annotated` builds a parser from a function's type hints, with `Argument`/`Option` metadata
+  via `typing.Annotated`.
+
+Parsers are built lazily and cached by the `CommandParsers` class in `cmd2.py` (`_build_parser`), so
+that `CommandSet`-supplied subcommands can be attached and detached at runtime.
+`cmd2/argparse_completer.py` walks a parser to produce tab completions; completion results are
+`Completions`/`CompletionItem` objects from `cmd2/completion.py`.
+
+### Output and theming
+
+Never print directly — go through `Cmd.print_to` / `poutput` / `perror` / `pwarning` / `pfeedback` /
+`ppaged`, which route to Rich consoles defined in `cmd2/rich_utils.py` (`Cmd2GeneralConsole`,
+`Cmd2RichArgparseConsole`, `Cmd2ExceptionConsole`). Styling flows one way: `cmd2/styles.py`
+(style-name StrEnum + defaults) → `cmd2/theme.py` (single global theme, updated in-place for Rich
+and exposed to prompt-toolkit through a `DynamicStyle`) → `cmd2/pt_utils.py` (`rich_to_pt_style`
+converts Rich styles into prompt-toolkit ones). Adding a color or style means touching
+`styles.py`/`colors.py`/`theme.py`, not hardcoding ANSI.
+
+`cmd2/command_toolbar.py` and `cmd2/pager.py` are the trickiest parts of the codebase: they keep a
+prompt-toolkit application alive _during_ synchronous command execution (bottom toolbar refresh,
+paging) while stdout is proxied and redirection may be active. Changes there need care around
+threads, signals, and Windows behavior.
+
+### Modularity
+
+`cmd2/command_set.py` (`CommandSet`) lets commands live in separate classes that are registered and
+unregistered at runtime via `Cmd.register_command_set`; `cmd2/py_bridge.py` exposes the app to
+embedded Python/IPython shells and `run_pyscript` while keeping isolation.
+
+## Conventions
+
+- Ruff is authoritative for format and lint (`ruff.toml`, line length 127, double quotes). Do not
+  suppress lint errors in code you write; broad ignores already exist for `examples/` and `tests/`.
+- Both `mypy --strict` and `ty` must pass on the `cmd2` package. Full type annotations are required
+  on all library code (excluded: `tests/`, `examples/`, `docs/`).
+- Docstrings are enforced by pydocstyle rules; public API items are documented in `docs/api/*.md`
+  and rendered by mkdocstrings, so keep docstrings accurate when changing signatures.
+- Anything not documented under `docs/api/` is not public API (`cmd2/constants.py` says so
+  explicitly).
+- Add user-visible changes to `CHANGELOG.md` under the current in-progress version heading.
+- `main` is the branch for the next release, whether PATCH, MINOR, or MAJOR. Feature branches merge
+  into `main`, and all releases are tagged and published from it.
+- Do not commit spec, plan, or markdown documents without asking first. Save plans to
+  `~/.superpowers/plans/` rather than the project directory.
+- This project uses a 127 character maximum line length for all Python code, including for comments.
+- This project uses a 100 character maximum line length for Markdown files.
+
+## Commit conventions
+
+Never add "Co-Authored-By" lines to commits. Do not include Claude attribution in commit messages,
+PR descriptions, or any git metadata. Do not include Claude session URL in commit messages, PR
+descriptions, or any git metadata.

{cmd2-4.2.3 → cmd2-4.3.0}/GEMINI.md

@@ -15,6 +15,8 @@ Python project, which utilizes `uv` for environment and package management.
 - **New Dependencies:** If a new dependency is required, please state the reason for its inclusion.
 - Do not commit spec, plan, or markdown documents to git without asking first.
 - Save plans to `~/.superpowers/plans/` instead of the project directory.
+- This project uses a 127 character maximum line length for all Python code, including for comments.
+- This project uses a 100 character maximum line length for Markdown files.
 
 ## Python Code Standards
 

{cmd2-4.2.3 → cmd2-4.3.0}/Makefile

@@ -5,8 +5,8 @@
 .PHONY: install
 install: ## Install the virtual environment with dependencies
 	@echo "🚀 Creating uv Python virtual environment"
-	@uv python install 3.14
-	@uv sync --python=3.14
+	@uv python install 3.15
+	@uv sync --python=3.15
 	@echo "🚀 Installing Git prek hooks locally"
 	@uv run prek install -f
 	@echo "🚀 Installing Prettier using npm"
@@ -47,7 +47,7 @@ typecheck: ## Perform type checking using both mypy and ty
 .PHONY: test
 test: ## Test the code with pytest.
 	@echo "🚀 Testing code: Running pytest"
-	@uv run python -Xutf8 -m pytest --cov --cov-config=pyproject.toml --cov-report=xml tests
+	@uv run python -Xutf8 -m pytest tests
 
 .PHONY: docs-test
 docs-test: ## Test if documentation can be built without warnings or errors

{cmd2-4.2.3 → cmd2-4.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmd2
-Version: 4.2.3
+Version: 4.3.0
 Summary: cmd2 - quickly build feature-rich and user-friendly interactive command line applications in Python
 Author: cmd2 Contributors
 License-Expression: MIT
@@ -27,7 +27,10 @@ Requires-Dist: rich>=15.0.0
 Requires-Dist: rich-argparse>=1.7.2
 Dynamic: license-file
 
-<h1 align="center">cmd2: build feature-rich command-line applications in Python</h1>
+<p align="center">
+  <a href="https://github.com/python-cmd2/cmd2"><img src="https://raw.githubusercontent.com/python-cmd2/cmd2/main/docs/assets/cmd2-logo.png" alt="cmd2 logo" width="160"></a>
+</p>
+<h1 align="center">cmd2: build feature-rich command-line apps in Python</h1>
 
 [![Latest Version](https://img.shields.io/pypi/v/cmd2.svg?style=flat-square&label=latest%20stable%20version)](https://pypi.python.org/pypi/cmd2/)
 [![Tests](https://github.com/python-cmd2/cmd2/actions/workflows/tests.yml/badge.svg)](https://github.com/python-cmd2/cmd2/actions/workflows/tests.yml)
@@ -115,7 +118,9 @@ to build a more complete application.
 
 - Define commands as Python methods and use familiar
   [`argparse`](https://cmd2.readthedocs.io/en/latest/features/argument_processing/) parsers for
-  arguments and subcommands. A single parser definition drives validation, help, and completion.
+  arguments and subcommands, or plain type hints via
+  [`@with_annotated`](https://cmd2.readthedocs.io/en/latest/features/annotated/). A single parser
+  definition drives validation, help, and completion.
 - Render Rich tables and other styled objects, with consistent helpers for
   [normal output, errors, warnings, and paging](https://cmd2.readthedocs.io/en/latest/features/generating_output/).
 - Organize large applications into independently testable and dynamically loadable
@@ -251,6 +256,7 @@ reproduce the bug. At a minimum, please state the following:
 | [Falcon Toolkit](https://github.com/CrowdStrike/Falcon-Toolkit) | Unleash the power of the CrowdStrike Falcon Platform at the CLI                                                                  | [CrowdStrike](https://github.com/CrowdStrike)                         |
 | [EXPLIoT](https://gitlab.com/expliot_framework/expliot)         | Internet of Things Security Testing and Exploitation framework                                                                   | [expliot_framework](https://gitlab.com/expliot_framework/)            |
 | [Pobshell](https://github.com/pdalloz/pobshell)                 | A Bash‑like shell for live Python objects: `cd`, `ls`, `cat`, `find` and _CLI piping_ for object code, str values & more         | [Peter Dalloz](https://www.linkedin.com/in/pdalloz)                   |
+| [Wtsh](https://gitee.com/wazzge/wtsh)                           | WTSH is a shell built with Python cmd2(v4), which uses third-party plugins to construct a universal shell installed via Pip      | [wazzge](https://gitee.com/wazzge)                                    |
 
 Possibly defunct but still good examples
 

{cmd2-4.2.3 → cmd2-4.3.0}/README.md

@@ -1,4 +1,7 @@
-<h1 align="center">cmd2: build feature-rich command-line applications in Python</h1>
+<p align="center">
+  <a href="https://github.com/python-cmd2/cmd2"><img src="https://raw.githubusercontent.com/python-cmd2/cmd2/main/docs/assets/cmd2-logo.png" alt="cmd2 logo" width="160"></a>
+</p>
+<h1 align="center">cmd2: build feature-rich command-line apps in Python</h1>
 
 [![Latest Version](https://img.shields.io/pypi/v/cmd2.svg?style=flat-square&label=latest%20stable%20version)](https://pypi.python.org/pypi/cmd2/)
 [![Tests](https://github.com/python-cmd2/cmd2/actions/workflows/tests.yml/badge.svg)](https://github.com/python-cmd2/cmd2/actions/workflows/tests.yml)
@@ -86,7 +89,9 @@ to build a more complete application.
 
 - Define commands as Python methods and use familiar
   [`argparse`](https://cmd2.readthedocs.io/en/latest/features/argument_processing/) parsers for
-  arguments and subcommands. A single parser definition drives validation, help, and completion.
+  arguments and subcommands, or plain type hints via
+  [`@with_annotated`](https://cmd2.readthedocs.io/en/latest/features/annotated/). A single parser
+  definition drives validation, help, and completion.
 - Render Rich tables and other styled objects, with consistent helpers for
   [normal output, errors, warnings, and paging](https://cmd2.readthedocs.io/en/latest/features/generating_output/).
 - Organize large applications into independently testable and dynamically loadable
@@ -222,6 +227,7 @@ reproduce the bug. At a minimum, please state the following:
 | [Falcon Toolkit](https://github.com/CrowdStrike/Falcon-Toolkit) | Unleash the power of the CrowdStrike Falcon Platform at the CLI                                                                  | [CrowdStrike](https://github.com/CrowdStrike)                         |
 | [EXPLIoT](https://gitlab.com/expliot_framework/expliot)         | Internet of Things Security Testing and Exploitation framework                                                                   | [expliot_framework](https://gitlab.com/expliot_framework/)            |
 | [Pobshell](https://github.com/pdalloz/pobshell)                 | A Bash‑like shell for live Python objects: `cd`, `ls`, `cat`, `find` and _CLI piping_ for object code, str values & more         | [Peter Dalloz](https://www.linkedin.com/in/pdalloz)                   |
+| [Wtsh](https://gitee.com/wazzge/wtsh)                           | WTSH is a shell built with Python cmd2(v4), which uses third-party plugins to construct a universal shell installed via Pip      | [wazzge](https://gitee.com/wazzge)                                    |
 
 Possibly defunct but still good examples
 

{cmd2-4.2.3 → cmd2-4.3.0}/cmd2/annotated.py

@@ -1,9 +1,5 @@
 """Build argparse parsers from type-annotated function signatures.
 
-!!! warning "Experimental"
-
-    This module is experimental and its behavior may change in future releases.
-
 The [`with_annotated`][cmd2.annotated.with_annotated] decorator inspects a command function's type hints and
 default values to build a ``Cmd2ArgumentParser``.  [`Argument`][cmd2.annotated.Argument] and
 [`Option`][cmd2.annotated.Option] metadata classes give finer per-parameter control via
@@ -313,6 +309,7 @@ from .rich_utils import Cmd2HelpFormatter, HelpContent
 from .types import (
     BoundCommandFunc,
     CmdOrSetT,
+    CmdOrSetT_contra,
     UnboundChoicesProvider,
     UnboundCompleter,
 )
@@ -712,7 +709,7 @@ def _make_enum_type(enum_class: type[enum.Enum], *, allow_unknown_entry: bool =
         raise _invalid_choice(value, _value_map)
 
     _convert.__name__ = enum_class.__name__
-    _convert._cmd2_enum_class = enum_class  # type: ignore[attr-defined, ty:unresolved-attribute]
+    _convert._cmd2_enum_class = enum_class  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
     return _convert
 
 
@@ -988,7 +985,7 @@ def _unwrap_optional(tp: Any) -> tuple[Any, bool]:
     there alone, so this helper never validates union members itself.
     """
     origin = get_origin(tp)
-    if origin is Union or origin is types.UnionType:  # type: ignore[comparison-overlap]
+    if origin is Union or origin is types.UnionType:
         all_args = get_args(tp)
         non_none = [a for a in all_args if a is not type(None)]
         has_none = len(non_none) < len(all_args)
@@ -1013,14 +1010,14 @@ def _normalize_annotation(annotation: Any) -> _NormalizedAnnotation:
     tp, unwrapped = _unwrap_optional(tp)
     if unwrapped:
         is_optional = True
-        if get_origin(tp) is Annotated:  # type: ignore[comparison-overlap]
+        if get_origin(tp) is Annotated:
             inner_tp = get_args(tp)[0]
             inner_origin = get_origin(inner_tp)
-            inner_is_union = inner_origin is Union or inner_origin is types.UnionType  # type: ignore[comparison-overlap]
+            inner_is_union = inner_origin is Union or inner_origin is types.UnionType
             if not (inner_is_union and type(None) in get_args(inner_tp)):
                 raise TypeError("Annotated[T, meta] | None is ambiguous. Use Annotated[T | None, meta] instead.")
 
-    if get_origin(tp) is Annotated:  # type: ignore[comparison-overlap]
+    if get_origin(tp) is Annotated:
         args = get_args(tp)
         tp = args[0]
         for meta in args[1:]:
@@ -1118,7 +1115,7 @@ def _compose_preprocess(preprocess: Callable[[str], str], converter: Callable[[s
     _convert.__name__ = getattr(converter, "__name__", "preprocess")
     enum_class = getattr(converter, "_cmd2_enum_class", None)
     if enum_class is not None:
-        _convert._cmd2_enum_class = enum_class  # type: ignore[attr-defined, ty:unresolved-attribute]
+        _convert._cmd2_enum_class = enum_class  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
     return _convert
 
 
@@ -2907,23 +2904,25 @@ class _BoundAnnotatedCommand(Protocol[_CommandParams, _CommandReturn_co]):
     def __call__(self, *args: _CommandParams.args, **kwargs: _CommandParams.kwargs) -> _CommandReturn_co: ...
 
 
-class _AnnotatedCommand(Protocol[CmdOrSetT, _CommandParams, _CommandReturn_co]):
+class _AnnotatedCommand(Protocol[CmdOrSetT_contra, _CommandParams, _CommandReturn_co]):
     """A callable command method with the metadata used by ``with_annotated``."""
 
     __name__: str
     __qualname__: str
 
     def __call__(
-        self, __self: CmdOrSetT, /, *args: _CommandParams.args, **kwargs: _CommandParams.kwargs
+        self, __self: CmdOrSetT_contra, /, *args: _CommandParams.args, **kwargs: _CommandParams.kwargs
     ) -> _CommandReturn_co: ...
 
     @overload
     def __get__(
         self, instance: None, owner: Any = ...
-    ) -> "_AnnotatedCommand[CmdOrSetT, _CommandParams, _CommandReturn_co]": ...
+    ) -> "_AnnotatedCommand[CmdOrSetT_contra, _CommandParams, _CommandReturn_co]": ...
 
     @overload
-    def __get__(self, instance: CmdOrSetT, owner: Any = ...) -> _BoundAnnotatedCommand[_CommandParams, _CommandReturn_co]: ...
+    def __get__(
+        self, instance: CmdOrSetT_contra, owner: Any = ...
+    ) -> _BoundAnnotatedCommand[_CommandParams, _CommandReturn_co]: ...
 
 
 class _WithAnnotatedDecorator(Protocol):

{cmd2-4.2.3 → cmd2-4.3.0}/cmd2/argparse_completer.py

@@ -52,7 +52,7 @@ ARG_TOKENS = "arg_tokens"
 def _build_hint(parser: Cmd2ArgumentParser, arg_action: argparse.Action) -> str:
     """Build completion hint for a given argument."""
     # Check if hinting is disabled for this argument
-    suppress_hint = arg_action.get_suppress_tab_hint()  # type: ignore[attr-defined, ty:unresolved-attribute]
+    suppress_hint = arg_action.get_suppress_tab_hint()  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
     if suppress_hint or arg_action.help == argparse.SUPPRESS:
         return ""
 
@@ -104,7 +104,7 @@ class _ArgumentState:
         self.is_remainder = self.action.nargs == argparse.REMAINDER
 
         # Check if nargs is a range
-        nargs_range: tuple[int, int | float] | None = self.action.get_nargs_range()  # type: ignore[attr-defined, ty:unresolved-attribute]
+        nargs_range: tuple[int, int | float] | None = self.action.get_nargs_range()  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
         if nargs_range is not None:
             self.min = nargs_range[0]
             self.max = nargs_range[1]
@@ -575,7 +575,7 @@ class ArgparseCompleter:
 
         :raises ValueError: if there is an error with the data.
         """
-        table_columns = arg_state.action.get_table_columns()  # type: ignore[attr-defined, ty:unresolved-attribute]
+        table_columns = arg_state.action.get_table_columns()  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
         has_table_data = any(item.table_data for item in completions)
 
         if table_columns is None:
@@ -606,7 +606,7 @@ class ArgparseCompleter:
 
         table_columns = cast(
             Sequence[str | Column] | None,
-            arg_state.action.get_table_columns(),  # type: ignore[attr-defined, ty:unresolved-attribute]
+            arg_state.action.get_table_columns(),  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
         )
 
         # Skip table generation if results are outside thresholds or no columns are defined
@@ -761,7 +761,7 @@ class ArgparseCompleter:
         :raises CompletionError: if the completer or choices function this calls raises one
         """
         # Check if the argument uses a completer
-        completer = arg_state.action.get_completer()  # type: ignore[attr-defined, ty:unresolved-attribute]
+        completer = arg_state.action.get_completer()  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
         if completer is not None:
             args, kwargs = self._prepare_callable_params(
                 completer,
@@ -775,7 +775,7 @@ class ArgparseCompleter:
 
         # Otherwise it uses a choices provider or choices list
         else:
-            choices_provider = arg_state.action.get_choices_provider()  # type: ignore[attr-defined, ty:unresolved-attribute]
+            choices_provider = arg_state.action.get_choices_provider()  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
             if choices_provider is not None:
                 args, kwargs = self._prepare_callable_params(
                     choices_provider,

{cmd2-4.2.3 → cmd2-4.3.0}/cmd2/argparse_utils.py

@@ -232,8 +232,8 @@ import threading
 from argparse import ArgumentError
 from collections.abc import (
     Callable,
+    Generator,
     Iterable,
-    Iterator,
     Sequence,
 )
 from dataclasses import dataclass
@@ -564,11 +564,11 @@ def _ActionsContainer_add_argument(  # noqa: N802
     new_arg = orig_actions_container_add_argument(self, *args, **kwargs)
 
     # Set the cmd2-specific attributes
-    new_arg.set_nargs_range(nargs_range)  # type: ignore[attr-defined, ty:unresolved-attribute]
-    new_arg.set_choices_provider(choices_provider)  # type: ignore[attr-defined, ty:unresolved-attribute]
-    new_arg.set_completer(completer)  # type: ignore[attr-defined, ty:unresolved-attribute]
-    new_arg.set_suppress_tab_hint(suppress_tab_hint)  # type: ignore[attr-defined, ty:unresolved-attribute]
-    new_arg.set_table_columns(table_columns)  # type: ignore[attr-defined, ty:unresolved-attribute]
+    new_arg.set_nargs_range(nargs_range)  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
+    new_arg.set_choices_provider(choices_provider)  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
+    new_arg.set_completer(completer)  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
+    new_arg.set_suppress_tab_hint(suppress_tab_hint)  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
+    new_arg.set_table_columns(table_columns)  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
 
     # Set other registered custom attributes
     for keyword, value in custom_attribs.items():
@@ -666,14 +666,14 @@ def _SubParsersAction_remove_all_parsers(  # noqa: N802
         # Get the next subcommand name. remove_parser() will remove
         # it and any associated aliases from _name_parser_map.
         name = next(iter(self._name_parser_map))
-        record = self.remove_parser(name)  # type: ignore[attr-defined, ty:unresolved-attribute]
+        record = self.remove_parser(name)  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
         records.append(record)
 
     return records
 
 
-argparse._SubParsersAction.remove_parser = _SubParsersAction_remove_parser  # type: ignore[attr-defined, ty:unresolved-attribute]
-argparse._SubParsersAction.remove_all_parsers = _SubParsersAction_remove_all_parsers  # type: ignore[attr-defined, ty:unresolved-attribute]
+argparse._SubParsersAction.remove_parser = _SubParsersAction_remove_parser  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
+argparse._SubParsersAction.remove_all_parsers = _SubParsersAction_remove_all_parsers  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
 
 
 @dataclass
@@ -695,7 +695,7 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
     _thread_locals: ClassVar[_ParserThreadLocals] = _ParserThreadLocals()
 
     @contextlib.contextmanager
-    def output_to(self, file: IO[str] | None) -> Iterator[None]:
+    def output_to(self, file: IO[str] | None) -> Generator[None]:
         """Context manager to temporarily set the output stream during argparse operations.
 
         This is helpful for directing output for functions like `parse_args()`, which
@@ -747,8 +747,8 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
         super().__init__(
             prog=prog,
             usage=usage,
-            description=description,  # type: ignore[arg-type, ty:invalid-argument-type]
-            epilog=epilog,  # type: ignore[arg-type, ty:invalid-argument-type]
+            description=description,  # type: ignore[arg-type]  # ty: ignore[invalid-argument-type]
+            epilog=epilog,  # type: ignore[arg-type]  # ty: ignore[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, ty:invalid-method-override]
+    def print_usage(self, file: IO[str] | None = None) -> None:  # type: ignore[override]  # ty: ignore[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, ty:invalid-method-override]
+    def print_help(self, file: IO[str] | None = None) -> None:  # type: ignore[override]  # ty: ignore[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
@@ -984,7 +984,7 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
         try:
             record = cast(
                 SubcommandRecord,
-                subparsers_action.remove_parser(subcommand),  # type: ignore[attr-defined, ty:unresolved-attribute]
+                subparsers_action.remove_parser(subcommand),  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
             )
         except ValueError:
             raise ValueError(f"Subcommand '{subcommand}' does not exist for '{target_parser.prog}'") from None
@@ -1006,7 +1006,7 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
 
         records = cast(
             list[SubcommandRecord],
-            subparsers_action.remove_all_parsers(),  # type: ignore[attr-defined, ty:unresolved-attribute]
+            subparsers_action.remove_all_parsers(),  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
         )
         # Update command for each detached subcommand
         for record in records:
@@ -1046,7 +1046,7 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
 
     def _get_nargs_pattern(self, action: argparse.Action) -> str:
         """Override to support nargs ranges."""
-        nargs_range = action.get_nargs_range()  # type: ignore[attr-defined, ty:unresolved-attribute]
+        nargs_range = action.get_nargs_range()  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
         if nargs_range:
             range_max = "" if nargs_range[1] == constants.INFINITY else nargs_range[1]
             nargs_pattern = f"(-*A{{{nargs_range[0]},{range_max}}}-*)"
@@ -1066,7 +1066,7 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
 
         # raise an exception if we weren't able to find a match
         if match is None:
-            nargs_range = action.get_nargs_range()  # type: ignore[attr-defined, ty:unresolved-attribute]
+            nargs_range = action.get_nargs_range()  # type: ignore[attr-defined]  # ty: ignore[unresolved-attribute]
             if nargs_range is not None:
                 raise ArgumentError(action, build_range_error(nargs_range[0], nargs_range[1]))