cmd2 4.2.4__tar.gz → 4.3.1__tar.gz

{cmd2-4.2.4 → cmd2-4.3.1}/.pre-commit-config.yaml

@@ -15,7 +15,7 @@ repos:
       - id: trailing-whitespace
 
   - repo: https://github.com/astral-sh/ruff-pre-commit
-    rev: "v0.16.6"
+    rev: "v0.17.1"
     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.4 → cmd2-4.3.1}/.prettierrc

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

{cmd2-4.2.4 → cmd2-4.3.1}/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.4 → cmd2-4.3.1}/CHANGELOG.md

@@ -1,3 +1,48 @@
+## 4.3.1 (October 24, 2026)
+
+- Bug Fixes
+    - Fixed `@with_annotated` command `--help` output bypassing the application's output stream,
+      leaving redirected help files empty and preventing help from being captured by embedded apps.
+- Enhancements
+    - Added the
+      [textual_tty_embed.py](https://github.com/python-cmd2/cmd2/blob/main/examples/textual_tty_embed.py)
+      example, which embeds a `cmd2` application in a [Textual](https://textual.textualize.io/)
+      application using [textual-tty](https://github.com/ttygroup/textual-tty). The Textual
+      application shows a realtime status panel beside the `cmd2` application, which can display
+      much richer information than a bottom toolbar. See the
+      [Embedding in Textual](docs/examples/embedding_in_textual.md) documentation for details.
+
+## 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

{cmd2-4.2.4 → cmd2-4.3.1}/CLAUDE.md

@@ -71,8 +71,9 @@ Three layers, all producing a `Cmd2ArgumentParser`:
   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, still-experimental Typer-style path: `@with_annotated` builds a
-  parser from a function's type hints, with `Argument`/`Option` metadata via `typing.Annotated`.
+- `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.
@@ -111,10 +112,12 @@ embedded Python/IPython shells and `run_pyscript` while keeping isolation.
 - 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 PATCH release; MAJOR/MINOR work happens on a branch named for
-  the target version. Releases are tagged and published from `main`.
+- `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
 

{cmd2-4.2.4 → cmd2-4.3.1}/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.4 → cmd2-4.3.1}/MANIFEST.in

@@ -5,4 +5,4 @@ recursive-include docs *
 prune .github
 prune build
 exclude .github .gitignore .readthedocs.yaml
-global-exclude htmlcov/** .coverage* __pycache__/** .gitignore
+global-exclude htmlcov/** .coverage* __pycache__/** .gitignore .DS_Store

{cmd2-4.2.4 → cmd2-4.3.1}/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.4 → cmd2-4.3.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cmd2
-Version: 4.2.4
+Version: 4.3.1
 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)
@@ -52,6 +55,12 @@ completion, command history, scripting, output styling, and much more.
 You can use `cmd2` for a small internal tool and grow the same application into an extensible,
 scriptable interface without replacing the framework or writing the usual CLI boilerplate.
 
+Want a richer visual display than a prompt and toolbar can offer? Your `cmd2` application can run
+inside a terminal pane of a [Textual](https://textual.textualize.io/) application, right next to
+dashboards and panels that show realtime status and other information. See
+[Embedding in Textual](https://cmd2.readthedocs.io/en/latest/examples/embedding_in_textual/) for an
+example.
+
 ## Quick start
 
 Install `cmd2`:
@@ -115,7 +124,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

{cmd2-4.2.4 → cmd2-4.3.1}/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)
@@ -23,6 +26,12 @@ completion, command history, scripting, output styling, and much more.
 You can use `cmd2` for a small internal tool and grow the same application into an extensible,
 scriptable interface without replacing the framework or writing the usual CLI boilerplate.
 
+Want a richer visual display than a prompt and toolbar can offer? Your `cmd2` application can run
+inside a terminal pane of a [Textual](https://textual.textualize.io/) application, right next to
+dashboards and panels that show realtime status and other information. See
+[Embedding in Textual](https://cmd2.readthedocs.io/en/latest/examples/embedding_in_textual/) for an
+example.
+
 ## Quick start
 
 Install `cmd2`:
@@ -86,7 +95,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

{cmd2-4.2.4 → cmd2-4.3.1}/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
@@ -713,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
 
 
@@ -989,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)
@@ -1014,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:]:
@@ -1119,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
 
 
@@ -3158,28 +3154,29 @@ def with_annotated(
 
         @functools.wraps(command_func)
         def cmd_wrapper(*args: Any, **kwargs: Any) -> _CommandReturn:
-            cmd2_app, statement_arg = _parse_positionals(args)
+            cmd_app, statement_arg = _parse_positionals(args)
             owner = args[0]  # Cmd or CommandSet instance
-            statement, parsed_arglist = cmd2_app.statement_parser.get_command_arg_list(
+            statement, parsed_arglist = cmd_app.statement_parser.get_command_arg_list(
                 command_name, statement_arg, preserve_quotes
             )
 
-            arg_parser = cmd2_app.command_parsers.get(cast(BoundCommandFunc[...], cmd_wrapper))
+            arg_parser = cmd_app.command_parsers.get(cast(BoundCommandFunc[...], cmd_wrapper))
             if arg_parser is None:
                 raise ValueError(f"No argument parser found for {command_name}")
 
             if ns_provider is None:
                 namespace = None
             else:
-                provider_self = cmd2_app._resolve_func_self(ns_provider, args[0])
-                namespace = ns_provider(provider_self if provider_self is not None else cmd2_app)
+                provider_self = cmd_app._resolve_func_self(ns_provider, args[0])
+                namespace = ns_provider(provider_self if provider_self is not None else cmd_app)
 
             try:
-                if with_unknown_args:
-                    ns, unknown = arg_parser.parse_known_args(parsed_arglist, namespace)
-                else:
-                    ns = arg_parser.parse_args(parsed_arglist, namespace)
-                    unknown = None
+                with arg_parser.output_to(cmd_app.stdout):
+                    if with_unknown_args:
+                        ns, unknown = arg_parser.parse_known_args(parsed_arglist, namespace)
+                    else:
+                        ns = arg_parser.parse_args(parsed_arglist, namespace)
+                        unknown = None
             except SystemExit as exc:
                 raise Cmd2ArgparseError from exc
 

{cmd2-4.2.4 → cmd2-4.3.1}/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.4 → cmd2-4.3.1}/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,
@@ -768,11 +768,11 @@ class Cmd2ArgumentParser(argparse.ArgumentParser):
         self.completer_class = completer_class
 
         # To assist type checkers, recast these to reflect our usage of rich-argparse.
-        self.formatter_class: type[Cmd2HelpFormatter]
-        self.description: HelpContent | None  # type: ignore[assignment]
-        self.epilog: HelpContent | None  # type: ignore[assignment]
+        self.formatter_class: type[Cmd2HelpFormatter]  # ty: ignore[invalid-mutable-override]
+        self.description: HelpContent | None  # type: ignore[assignment]  # ty: ignore[invalid-attribute-override]
+        self.epilog: HelpContent | None  # type: ignore[assignment]  # ty: ignore[invalid-attribute-override]
 
-    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]))