cli-components 2026.10.2__tar.gz → 2026.10.3__tar.gz

{cli_components-2026.10.2/src/cli_components.egg-info → cli_components-2026.10.3}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: cli-components
-Version: 2026.10.2
+Version: 2026.10.3
 Summary: Composable argparse commands and nested CLI modules
 License-Expression: AGPL-3.0-only
 Requires-Python: >=3.11
@@ -23,6 +23,8 @@ Examples:
 python3 docs/examples/project_cli.py --help
 python3 docs/examples/project_cli.py --daemon docker project new demo -v
 python3 docs/examples/project_cli.py project template compile --force
+python3 docs/examples/notes_cli.py find --text release --tags docs --match all
+python3 docs/examples/notes_cli.py tag clear --all
 ```
 
 Import the package as `cli_components`.

{cli_components-2026.10.2 → cli_components-2026.10.3}/README.md

@@ -13,6 +13,8 @@ Examples:
 python3 docs/examples/project_cli.py --help
 python3 docs/examples/project_cli.py --daemon docker project new demo -v
 python3 docs/examples/project_cli.py project template compile --force
+python3 docs/examples/notes_cli.py find --text release --tags docs --match all
+python3 docs/examples/notes_cli.py tag clear --all
 ```
 
 Import the package as `cli_components`.

cli_components-2026.10.3/docs/examples/notes_cli.py

@@ -0,0 +1,228 @@
+"""Runnable example: a small notes manager built with cli-components.
+
+It works on built-in sample notes and only prints what it would change, so it
+is safe to run. It shows:
+
+- root options handled by a `sub_command_func` before the selected command runs
+- list positionals (`nargs="*"`), optional positionals (`nargs="?"`), `choices`
+  with defaults, a required option, `type` and `dest`
+- command groups (`tag ...`) whose parent has no `func`, so it prints its own help
+- an exclusive group pairing a list positional with an "all" flag
+- a post-parse check reported in argparse's usage-error format
+- a reusable `run()` helper that dispatches a selection
+
+Try:
+
+    python3 docs/examples/notes_cli.py list
+    python3 docs/examples/notes_cli.py list --status open
+    python3 docs/examples/notes_cli.py find --text release --tags docs --match all
+    python3 docs/examples/notes_cli.py --store work.json add "Plan sprint" sprint planning
+    python3 docs/examples/notes_cli.py set --id 3 --status done
+    python3 docs/examples/notes_cli.py tag rename docs documentation
+    python3 docs/examples/notes_cli.py tag clear --all
+    python3 docs/examples/notes_cli.py tag
+"""
+
+from argparse import RawDescriptionHelpFormatter
+from typing import Any
+
+from cli_components import (
+    ARGUMENTS,
+    FUNC,
+    LEAF,
+    SUB_COMMANDS,
+    SUB_COMMAND_ARGS,
+    SUB_COMMAND_FUNC,
+    Argument,
+    Command,
+    ExclusiveGroup,
+    Module,
+    Parser,
+)
+
+NOTES: list[dict[str, Any]] = [
+    {"id": 1, "title": "Release checklist", "tags": ["release", "docs"], "status": "open"},
+    {"id": 2, "title": "Rename option", "tags": ["api"], "status": "done"},
+    {"id": 3, "title": "Write examples", "tags": ["docs"], "status": "open"},
+]
+STATUSES = ["open", "done", "archived"]
+
+EPILOG = """examples:
+    notes list --status open
+    notes find --text release --tags docs --match all
+    notes tag clear --all"""
+
+
+# Callbacks. Each takes the argument names of its command as keywords.
+
+def configure(store: str, quiet: bool) -> None:
+    """Root `sub_command_func`: runs before whichever command was selected."""
+    if not quiet:
+        print(f"[store: {store}]")
+
+
+def show(note: dict[str, Any]) -> None:
+    print(f"{note['id']:>3}  {note['status']:<8}  {note['title']}  "
+          f"({', '.join(note['tags'])})")
+
+
+def list_notes(status: str) -> None:
+    for note in NOTES:
+        if status == "all" or note["status"] == status:
+            show(note)
+
+
+def find_notes(text: str | None, tags: list[str] | None, match: str) -> None:
+    for note in NOTES:
+        checks = []
+        if text is not None:
+            checks.append(text.lower() in note["title"].lower())
+        if tags:
+            checks.append(any(tag in note["tags"] for tag in tags))
+        if checks and (all(checks) if match == "all" else any(checks)):
+            show(note)
+
+
+def add_note(title: str, tags: list[str]) -> None:
+    print(f"would add note {len(NOTES) + 1}: {title!r} tagged {tags or 'nothing'}")
+
+
+def set_note(note_id: int, status: str | None, title: str | None) -> None:
+    changes = []
+    if status is not None:
+        changes.append(f"status -> {status}")
+    if title is not None:
+        changes.append(f"title -> {title!r}")
+    print(f"would update note {note_id}: {', '.join(changes)}")
+
+
+def rename_tag(old: str, new: str) -> None:
+    count = sum(old in note["tags"] for note in NOTES)
+    print(f"would rename tag {old!r} to {new!r} on {count} note(s)")
+
+
+def clear_tags(tags: list[str], all_tags: bool) -> None:
+    print("would remove every tag" if all_tags else f"would remove tags {tags}")
+
+
+def build_parser() -> Parser:
+    return Parser(
+        prog_name="notes",
+        description="Keep track of short notes.",
+        epilog=EPILOG,
+        formatter_class=RawDescriptionHelpFormatter,
+        arguments=[
+            Argument("s", "store", "Notes file to use", "store", default="notes.json",
+                     help_text_placeholder_value="FILE"),
+            Argument("q", "quiet", "Do not print the store name", "store_true"),
+        ],
+        sub_command_func=configure,
+        modules=[Module(
+            module_dest="command",
+            help_text="Command to run",
+            commands=[
+                Command(
+                    name="list",
+                    help_text="List notes",
+                    arguments=[Argument(None, "status", "Only notes with this status",
+                                        "store", default="all",
+                                        choices=["all", *STATUSES])],
+                    func=list_notes,
+                ),
+                Command(
+                    name="find",
+                    help_text="Find notes by text or tag",
+                    arguments=[
+                        Argument(None, "text", "Text the title contains", "store"),
+                        Argument("t", "tags", "Tags to look for", "store", nargs="*"),
+                        Argument("m", "match", "Match any or all of the filters",
+                                 "store", default="any", choices=["any", "all"]),
+                    ],
+                    func=find_notes,
+                ),
+                Command(
+                    name="add",
+                    help_text="Add a note",
+                    arguments=[
+                        Argument(None, "title", "Note title", "store", positional=True),
+                        Argument(None, "tags", "Tags for the note", "store",
+                                 positional=True, nargs="*"),
+                    ],
+                    func=add_note,
+                ),
+                Command(
+                    name="set",
+                    help_text="Change a note",
+                    arguments=[
+                        Argument(None, "id", "Note to change", "store", type=int,
+                                 required=True, dest="note_id",
+                                 help_text_placeholder_value="ID"),
+                        Argument(None, "status", "New status", "store",
+                                 choices=STATUSES),
+                        Argument(None, "title", "New title", "store"),
+                    ],
+                    func=set_note,
+                ),
+                Command(
+                    name="tag",
+                    help_text="Manage tags",
+                    # No func: `notes tag` on its own prints this group's help.
+                    sub_modules=[Module(
+                        module_dest="tag_command",
+                        help_text="Tag operation",
+                        commands=[
+                            Command(
+                                name="rename",
+                                help_text="Rename a tag on every note",
+                                arguments=[
+                                    Argument(None, "old", "Current tag", "store",
+                                             positional=True),
+                                    Argument(None, "new", "New tag", "store",
+                                             positional=True),
+                                ],
+                                func=rename_tag,
+                            ),
+                            Command(
+                                name="clear",
+                                help_text="Remove tags from every note",
+                                exclusive_groups=[ExclusiveGroup([
+                                    Argument(None, "tags", "Tags to remove", "store",
+                                             positional=True, nargs="*"),
+                                    Argument("a", "all", "Remove every tag",
+                                             "store_true", dest="all_tags"),
+                                ], required=True)],
+                                func=clear_tags,
+                            ),
+                        ],
+                    )],
+                ),
+            ],
+        )],
+    )
+
+
+def run(parser: Parser, argv: list[str] | None = None) -> None:
+    """Parse argv and run the selection: ancestors first, then the command."""
+    selection = parser.evaluate(argv)
+
+    # Checks argparse cannot express, reported in its usage-error format.
+    if selection[FUNC] is set_note:
+        values = selection[ARGUMENTS]
+        if values["note_id"] not in {note["id"] for note in NOTES}:
+            selection[LEAF].error(f"argument --id: no note with id {values['note_id']}")
+        if values["status"] is None and values["title"] is None:
+            selection[LEAF].error("give --status, --title or both")
+
+    for ancestor in selection[SUB_COMMANDS].values():
+        if ancestor[SUB_COMMAND_FUNC] is not None:
+            ancestor[SUB_COMMAND_FUNC](**ancestor[SUB_COMMAND_ARGS])
+
+    if selection[FUNC] is None:
+        # A group (or the root) was chosen without a command: show its help.
+        selection[LEAF].argparser.print_help()
+    else:
+        selection[FUNC](**selection[ARGUMENTS])
+
+
+if __name__ == "__main__":
+    run(build_parser())

{cli_components-2026.10.2 → cli_components-2026.10.3}/docs/examples/project_cli.py

@@ -1,24 +1,35 @@
-"""Runnable nested CLI inspired by data-ops-python's dope.py."""
+"""Runnable example: a project manager with nested commands."""
+
+from argparse import RawDescriptionHelpFormatter
+from pathlib import Path
 
 from cli_components import (
     ARGUMENTS,
     FUNC,
+    LEAF,
     SUB_COMMANDS,
     SUB_COMMAND_ARGS,
     SUB_COMMAND_FUNC,
     Argument,
     Command,
+    ExclusiveGroup,
     Module,
     Parser,
 )
 
+EPILOG = """examples:
+    example --daemon docker project new demo --verbose
+    example project new demo --template-file templates/web.toml"""
+
 
 def select_daemon(daemon: str) -> None:
     print(f"daemon={daemon}")
 
 
-def new_project(name: str, verbose: bool) -> None:
-    print(f"new project: {name} (verbose={verbose})")
+def new_project(name: str, verbose: bool, template: str | None,
+                template_file: Path | None) -> None:
+    source = template_file or template or "default"
+    print(f"new project: {name} (verbose={verbose}, template={source})")
 
 
 def compile_template(force: bool) -> None:
@@ -29,18 +40,33 @@ def main() -> None:
     parser = Parser(
         prog_name="example",
         description="Example project manager",
+        epilog=EPILOG,
+        formatter_class=RawDescriptionHelpFormatter,
         arguments=[Argument("d", "daemon", "Container runtime", "store",
                             default="podman", choices=["podman", "docker"])],
         sub_command_func=select_daemon,
         modules=[Module(
             module_dest="module",
+            required=True,
             commands=[Command(
                 name="project",
+                help_text="Manage projects",
                 sub_modules=[Module(
                     module_dest="project_action",
+                    required=True,
                     commands=[
                         Command(
                             name="new",
+                            help_text="Create a project",
+                            description="Create a project from a named template "
+                                        "or a template file.",
+                            exclusive_groups=[ExclusiveGroup([
+                                Argument("t", "template", "Template name", "store",
+                                         help_text_placeholder_value="NAME"),
+                                Argument(None, "template-file", "Template file",
+                                         "store", type=Path,
+                                         help_text_placeholder_value="PATH"),
+                            ])],
                             arguments=[
                                 Argument(None, "name", "Project name", "store",
                                          positional=True),
@@ -50,8 +76,10 @@ def main() -> None:
                         ),
                         Command(
                             name="template",
+                            help_text="Work with templates",
                             sub_modules=[Module(
                                 module_dest="template_action",
+                                required=True,
                                 commands=[Command(
                                     name="compile",
                                     arguments=[Argument("f", "force", "Force build",
@@ -67,6 +95,9 @@ def main() -> None:
     )
 
     selection = parser.evaluate()
+    template_file = selection[ARGUMENTS].get("template_file")
+    if template_file is not None and template_file.suffix != ".toml":
+        selection[LEAF].error("--template-file must be a .toml file")
     for ancestor in selection[SUB_COMMANDS].values():
         callback = ancestor[SUB_COMMAND_FUNC]
         if callback is not None:

cli_components-2026.10.3/docs/usage.md

@@ -0,0 +1,310 @@
+# Using cli-components
+
+`Parser` represents the CLI root, `Module` creates an `argparse` subparser group,
+`Command` adds a choice to that group, and `Argument` adds an option or positional
+argument to a command. A typical CLI is a root parser with a module of commands,
+some of which contain further modules of their own, as in `notes tag rename` or
+`example project template compile`.
+
+## Complete examples
+
+Both examples are executable once the package is installed with
+`python3 -m pip install -e .`.
+
+[docs/examples/notes_cli.py](examples/notes_cli.py) is a small notes manager.
+It uses sample data and only prints what it would change, so it is safe to run.
+It shows most of the patterns below in one place: root options, list and
+optional positionals, `choices`, a required option, command groups, an
+exclusive group, a post-parse check and a reusable dispatch helper.
+
+```sh
+python3 docs/examples/notes_cli.py --help
+python3 docs/examples/notes_cli.py list --status open
+python3 docs/examples/notes_cli.py find --text release --tags docs --match all
+python3 docs/examples/notes_cli.py --store work.json add "Plan sprint" sprint planning
+python3 docs/examples/notes_cli.py set --id 3 --status done
+python3 docs/examples/notes_cli.py tag clear --all
+python3 docs/examples/notes_cli.py tag
+```
+
+[docs/examples/project_cli.py](examples/project_cli.py) is a project manager
+with three levels of commands, required subcommands and a root option that
+picks a container runtime:
+
+```sh
+python3 docs/examples/project_cli.py --help
+python3 docs/examples/project_cli.py project new --help
+python3 docs/examples/project_cli.py --daemon docker project new demo --verbose
+python3 docs/examples/project_cli.py project template compile --force
+```
+
+The `new` invocation prints `daemon=docker` followed by
+`new project: demo (verbose=True, template=default)`. Root options go
+**before** the subcommand; options for a command go after its name.
+
+## Constructing a CLI
+
+```python
+from cli_components import Argument, Command, Module, Parser
+
+parser = Parser(
+    prog_name="hello",
+    description="Greeting utility",
+    modules=[Module(
+        module_dest="operation",
+        commands=[Command(
+            name="greet",
+            arguments=[
+                Argument(None, "person", "Who to greet", "store", positional=True),
+                Argument("l", "loud", "Use uppercase", "store_true"),
+            ],
+            func=lambda person, loud: print(f"Hello, {person}!".upper() if loud
+                                            else f"Hello, {person}!"),
+        )],
+    )],
+)
+
+selection = parser.evaluate()  # or parser.evaluate(["greet", "Ada", "-l"])
+if selection["func"] is not None:
+    selection["func"](**selection["arguments"])
+```
+
+Run this as `hello greet Ada -l` (or pass that argument list to `evaluate`).
+`flag=None` means no short option; a non-positional argument still has a long
+option. A hyphenated `name` such as `"project-name"` becomes `--project-name`
+on the command line and `project_name` in the callback keyword arguments.
+`default`, `choices`, `nargs`, `required`, `type`, and `dest` map to their
+`argparse` equivalents, and `help_text_placeholder_value` maps to argparse's
+`metavar` (see [Argument options](#argument-options)).
+For positional arguments, `required` is implicit in `argparse` (unless `nargs`
+makes them optional). Each nested `Module` needs a distinct `module_dest`.
+
+## Selecting and executing callbacks
+
+`evaluate()` only parses; it does **not** run callbacks. It returns a dictionary
+with the exported keys `PATH`, `COMMAND`, `FUNC`, `ARGUMENTS`, `SUB_COMMANDS`,
+and `LEAF`:
+
+```python
+{
+    "path": ["hello", "greet"],          # root to selected leaf
+    "command": "greet",
+    "func": greet_callback,               # the leaf's func, or None
+    "arguments": {"person": "Ada", "loud": True},
+    "sub_commands": {                     # ancestors, root first
+        "hello": {"sc_args": {}, "sc_func": None},
+    },
+    "leaf": <Command greet>,              # the selected Command object
+}
+```
+
+A common way to dispatch is to call each ancestor's `sub_command_func` with its
+own `sc_args` (root first), then the leaf `func` with `arguments`:
+
+```python
+from cli_components import ARGUMENTS, FUNC, SUB_COMMANDS, SUB_COMMAND_ARGS, SUB_COMMAND_FUNC
+
+for ancestor in selection[SUB_COMMANDS].values():
+    if ancestor[SUB_COMMAND_FUNC] is not None:
+        ancestor[SUB_COMMAND_FUNC](**ancestor[SUB_COMMAND_ARGS])
+if selection[FUNC] is not None:
+    selection[FUNC](**selection[ARGUMENTS])
+```
+
+When no subcommand is chosen, the root `Parser` is the selected command
+(unless the module is [required](#required-subcommands)). The same applies
+one level down: `notes tag` on its own selects `tag`. If the selected command
+has no `func`, a good default is to print that command's help:
+
+```python
+from cli_components import ARGUMENTS, FUNC, LEAF, SUB_COMMANDS, SUB_COMMAND_ARGS, SUB_COMMAND_FUNC
+
+
+def run(parser, argv=None):
+    selection = parser.evaluate(argv)
+    for ancestor in selection[SUB_COMMANDS].values():
+        if ancestor[SUB_COMMAND_FUNC] is not None:
+            ancestor[SUB_COMMAND_FUNC](**ancestor[SUB_COMMAND_ARGS])
+    if selection[FUNC] is None:
+        selection[LEAF].argparser.print_help()  # e.g. `notes tag`
+    else:
+        selection[FUNC](**selection[ARGUMENTS])
+```
+
+`argparse` handles invalid choices and missing required arguments using its
+normal usage message and `SystemExit(2)`.
+
+## Common patterns
+
+**Options for the whole CLI.** Put them on the `Parser` and give it a
+`sub_command_func`; it receives those options as keywords and runs before the
+selected command (when you dispatch as above). Root options go before the
+subcommand on the command line: `notes --store work.json list`.
+
+```python
+Parser("notes", "Keep track of short notes.",
+       arguments=[Argument("s", "store", "Notes file to use", "store",
+                           default="notes.json")],
+       sub_command_func=configure,  # def configure(store): ...
+       modules=[...])
+```
+
+**Several values.** `nargs="*"` collects zero or more values into a list,
+`nargs="+"` one or more, and an integer exactly that many:
+
+```python
+Argument(None, "title", "Note title", "store", positional=True)
+Argument(None, "tags", "Tags for the note", "store", positional=True, nargs="*")
+# notes add "Plan sprint" sprint planning  ->  title="Plan sprint", tags=["sprint", "planning"]
+```
+
+**An optional positional.** `nargs="?"` makes a positional optional; it is
+`None` (or its `default`) when left out:
+
+```python
+Argument(None, "name", "Project to deploy (default: current)", "store",
+         positional=True, nargs="?")
+```
+
+**A fixed set of values.** Combine `choices` with a `default`:
+
+```python
+Argument("m", "match", "Match any or all of the filters", "store",
+         default="any", choices=["any", "all"])
+```
+
+**A required option.** Options are optional unless `required=True`. Use `type`
+to convert the value and `dest` to give the callback a clearer keyword:
+
+```python
+Argument(None, "id", "Note to change", "store", type=int, required=True,
+         dest="note_id")  # --id 3  ->  note_id=3
+```
+
+**Some values, or all of them.** An exclusive group can pair a list positional
+with an "all" flag, so exactly one of them must be given:
+
+```python
+ExclusiveGroup([
+    Argument(None, "tags", "Tags to remove", "store", positional=True, nargs="*"),
+    Argument("a", "all", "Remove every tag", "store_true", dest="all_tags"),
+], required=True)
+# notes tag clear old stale  ->  tags=["old", "stale"], all_tags=False
+# notes tag clear --all      ->  tags=[], all_tags=True
+```
+
+**A group of related commands.** Give a `Command` a `sub_modules` list instead
+of a `func`. Either make its module `required=True`, so `notes tag` alone is a
+usage error, or leave it optional and print the group's help, as in `run()`
+above.
+
+## Argument options
+
+```python
+from pathlib import Path
+
+Argument(None, "row", "Row number", "store", type=int)
+Argument("o", "output", "Output file", "store", type=Path, default="out.csv")
+Argument(None, "cell", "Cell to edit", "store", type=int, nargs=2,
+         help_text_placeholder_value=("ROW", "COLUMN"))
+Argument(None, "output-file", "Output file", "store", dest="target")
+```
+
+- `type` converts and validates the value while parsing. If the callable raises
+  `ValueError`, `TypeError` or `argparse.ArgumentTypeError`, argparse prints its
+  normal usage error and exits with status 2. argparse also passes string
+  defaults through `type`, so `default="out.csv"` arrives as `Path("out.csv")`.
+- `help_text_placeholder_value` (argparse's `metavar`) is the placeholder
+  shown for the value in help, usage lines and error messages. It only changes
+  how the argument is displayed, not the parsed value or the callback keyword.
+  A tuple gives one name per value and must match `nargs`; the example above
+  shows as `--cell ROW COLUMN` and still arrives as `cell=[row, column]`.
+  Tuple placeholders on *positional* arguments need Python 3.12 or newer (argparse
+  cannot format them on 3.11, so cli-components raises `ValueError`).
+- `dest` changes the key in `arguments` (and the callback keyword) without
+  changing the option name. For a positional, the original `name` is still
+  shown in help.
+- `default` is passed through whenever it is given, including `None`, `0`,
+  `""` and `False`. Leave it out to keep argparse's own default (for example
+  `False` for `store_true`).
+
+## Help pages
+
+Every `Command` gets its own `--help` page. `help_text` is the one-line summary
+in the parent's command list; `description` is shown at the top of the
+command's own page and defaults to `help_text`. `epilog` is shown at the end.
+
+```python
+from argparse import RawDescriptionHelpFormatter
+
+SIGNATURE = """eval signature:
+    f(row, column, value) -> new value"""
+
+Parser("tool", "CSV tool", epilog=SIGNATURE,
+       formatter_class=RawDescriptionHelpFormatter,
+       modules=[Module("cmd", commands=[
+           Command("apply", help_text="Apply a script",
+                   description="Apply a Python expression to selected cells.",
+                   epilog=SIGNATURE),
+       ])])
+```
+
+The default formatter re-wraps descriptions and epilogs into paragraphs. Use
+`RawDescriptionHelpFormatter` to keep line breaks. A `Command` without its own
+`formatter_class` uses its parent's, so setting it on the `Parser` is enough.
+
+## Required subcommands
+
+By default, leaving out the subcommand selects the parent command. With
+`Module(..., required=True)`, argparse reports
+`the following arguments are required: <module_dest>` and exits with status 2.
+
+## Mutually exclusive arguments
+
+```python
+from cli_components import ExclusiveGroup
+
+Command("apply", exclusive_groups=[
+    ExclusiveGroup([
+        Argument(None, "script", "Inline script", "store"),
+        Argument(None, "script-file", "Script file", "store", type=Path),
+    ], required=True),
+    ExclusiveGroup([
+        Argument(None, "row", "Row", "store", type=int),
+        Argument(None, "column", "Column", "store", type=int),
+        Argument(None, "cell", "Cell", "store", type=int, nargs=2,
+                 help_text_placeholder_value=("ROW", "COLUMN")),
+    ], required=True),
+])
+```
+
+Each group maps to `add_mutually_exclusive_group`. With `required=True`, exactly
+one member must be given; otherwise at most one. Group members appear in
+`arguments` like any other argument, with `None` for the ones not given.
+Commands and the `Parser` both accept `exclusive_groups`.
+
+- Members cannot set `required=True`; put it on the group.
+- Positional members need `nargs="?"` or `nargs="*"`.
+- Keep member defaults as `None` (the default). argparse decides whether a
+  member was given by checking `value is not default`, so with `default=0`
+  an explicit `--row 0` would not count as given.
+
+## Reporting your own usage errors
+
+For checks that argparse cannot express, report them after parsing in the same
+format. `evaluate()` returns the selected `Command` under `LEAF`:
+
+```python
+from cli_components import ARGUMENTS, LEAF
+
+selection = parser.evaluate()
+if selection[ARGUMENTS].get("row", 1) > 1000:
+    selection[LEAF].error("--row must be 1000 or less")  # exits with status 2
+```
+
+`Command.error(message)` prints that command's usage line (for example
+`usage: tool apply ...`) and the message to stderr, then exits with status 2.
+`Command.print_usage(file=None)` prints the usage line only. Both work on the
+`Parser` at any time; on other commands they work once `evaluate()` has built
+the parser (before that, `RuntimeError`). The underlying
+`argparse.ArgumentParser` is available as the `argparser` property.

{cli_components-2026.10.2 → cli_components-2026.10.3}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "cli-components"
-version = "2026.10.2"
+version = "2026.10.3"
 description = "Composable argparse commands and nested CLI modules"
 readme = "README.md"
 requires-python = ">=3.11"