invoke-toolkit 0.0.63__tar.gz → 0.0.65b1__tar.gz

{invoke_toolkit-0.0.63 → invoke_toolkit-0.0.65b1}/.gitignore

@@ -18,3 +18,4 @@ invoke.yaml
 # Makrdowns
 *.md
 !docs/**/*.md
+.worktrees/

{invoke_toolkit-0.0.63 → invoke_toolkit-0.0.65b1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: invoke-toolkit
-Version: 0.0.63
+Version: 0.0.65b1
 Summary: Extended APIs for PyInvoke: composable task plugins, typed CLI args, Rich output, shell completion, and PEP 723 script support
 Project-URL: Documentation, https://github.com/D3f0/invoke-toolkit#readme
 Project-URL: Issues, https://github.com/D3f0/invoke-toolkit/issues

invoke_toolkit-0.0.65b1/src/invoke_toolkit/context/async_tools.py

@@ -0,0 +1,198 @@
+"""Async execution helpers for :class:`ToolkitContext`."""
+
+from __future__ import annotations
+
+import asyncio
+import asyncio.subprocess as async_subprocess
+import contextvars
+import os
+import sys
+from contextlib import contextmanager
+from typing import Any, Awaitable, Iterator
+
+from invoke.exceptions import CommandTimedOut, UnexpectedExit
+from invoke.runners import Result, default_encoding, normalize_hide
+
+
+_async_task_context: contextvars.ContextVar[bool] = contextvars.ContextVar(
+    "invoke_toolkit_async_task_context", default=False
+)
+
+
+@contextmanager
+def async_task_context() -> Iterator[None]:
+    """Mark synchronous context methods called from an async task."""
+    token = _async_task_context.set(True)
+    try:
+        yield
+    finally:
+        _async_task_context.reset(token)
+
+
+def in_async_task_context() -> bool:
+    """Return whether the current execution is an invoke-toolkit async task."""
+    return _async_task_context.get()
+
+
+class AsyncGatherScope:
+    """Schedule awaitables and await them together when the scope exits.
+
+    Submitted awaitables start immediately. ``results`` contains their return
+    values in submission order after a successful scope exit.
+    """
+
+    def __init__(self) -> None:
+        self._tasks: list[asyncio.Future[Any]] = []
+        self.results: tuple[Any, ...] = ()
+
+    async def __aenter__(self) -> "AsyncGatherScope":
+        return self
+
+    def __call__(self, awaitable: Awaitable[Any]) -> asyncio.Future[Any]:
+        """Schedule *awaitable* and return its task handle."""
+        task = asyncio.ensure_future(awaitable)
+        self._tasks.append(task)
+        return task
+
+    async def __aexit__(self, exc_type, exc_value, traceback) -> bool:
+        if exc_type is not None:
+            await self._cancel_remaining()
+            return False
+
+        try:
+            self.results = tuple(await asyncio.gather(*self._tasks))
+        except BaseException:
+            await self._cancel_remaining()
+            raise
+        return False
+
+    async def _cancel_remaining(self) -> None:
+        pending = [task for task in self._tasks if not task.done()]
+        for task in pending:
+            task.cancel()
+        if pending:
+            await asyncio.gather(*pending, return_exceptions=True)
+
+
+async def run_async_command(  # pylint: disable=too-many-branches,too-many-locals
+    context: Any, command: str, **kwargs: Any
+) -> Result:
+    """Run a shell command without blocking the current event loop."""
+    options = dict(context.config.run.items())
+    for key, value in kwargs.items():
+        if key not in options and key != "timeout":
+            raise TypeError(f"run_async() got an unexpected keyword argument '{key}'")
+        options[key] = value
+
+    timeout = options.pop("timeout", context.config.timeouts.command)
+    if options.get("asynchronous") or options.get("disown"):
+        raise ValueError("run_async() cannot use asynchronous or disown")
+    if options.get("pty"):
+        raise ValueError("run_async() does not support pty=True")
+    if options.get("watchers"):
+        raise ValueError("run_async() does not support stream watchers")
+    if options.get("echo_stdin"):
+        raise ValueError("run_async() does not support echo_stdin")
+    if options.get("in_stream") not in (None, False):
+        raise ValueError("run_async() only supports disabled stdin")
+
+    command = context._prefix_commands(command)  # pylint: disable=protected-access
+    shell = options.get("shell") or "bash"
+    encoding = options.get("encoding") or default_encoding()
+    hide = normalize_hide(
+        options.get("hide"), options.get("out_stream"), options.get("err_stream")
+    )
+    env_values = options.get("env") or {}
+    env = (
+        dict(env_values)
+        if options.get("replace_env")
+        else dict(os.environ, **env_values)
+    )
+
+    if options.get("echo"):
+        print(options.get("echo_format", "{command}").format(command=command))
+    if options.get("dry"):
+        return Result(
+            command=command,
+            shell=shell,
+            env=env,
+            encoding=encoding,
+            exited=0,
+            hide=hide,
+        )
+
+    process = await asyncio.create_subprocess_shell(
+        command,
+        executable=shell,
+        stdout=async_subprocess.PIPE,
+        stderr=async_subprocess.PIPE,
+        stdin=async_subprocess.DEVNULL,
+        env=env,
+    )
+    try:
+        communicate = process.communicate()
+        if timeout is None:
+            stdout, stderr = await communicate
+        else:
+            stdout, stderr = await asyncio.wait_for(communicate, timeout=timeout)
+    except asyncio.TimeoutError as exc:
+        await _terminate_process(process)
+        result = _result(command, shell, env, encoding, process, b"", b"", hide)
+        raise CommandTimedOut(result, timeout=timeout) from exc
+    except asyncio.CancelledError:
+        await _terminate_process(process)
+        raise
+
+    result = _result(command, shell, env, encoding, process, stdout, stderr, hide)
+    _write_streams(result, options)
+    if not result.ok and not options.get("warn"):
+        raise UnexpectedExit(result)
+    return result
+
+
+async def _terminate_process(process: async_subprocess.Process) -> None:
+    if process.returncode is not None:
+        return
+    process.terminate()
+    try:
+        await asyncio.wait_for(process.wait(), timeout=1)
+    except asyncio.TimeoutError:
+        process.kill()
+        await process.wait()
+
+
+def _result(
+    command: str,
+    shell: str,
+    env: dict[str, str],
+    encoding: str,
+    process: async_subprocess.Process,
+    stdout: bytes,
+    stderr: bytes,
+    hide: tuple[str, ...],
+) -> Result:
+    exited = process.returncode
+    if exited is None:
+        raise RuntimeError("Process completed without an exit code")
+    return Result(
+        stdout=stdout.decode(encoding, errors="replace"),
+        stderr=stderr.decode(encoding, errors="replace"),
+        command=command,
+        shell=shell,
+        env=env,
+        encoding=encoding,
+        exited=exited,
+        hide=hide,
+        pid=process.pid,
+    )
+
+
+def _write_streams(result: Result, options: dict[str, Any]) -> None:
+    out_stream = options.get("out_stream") or sys.stdout
+    err_stream = options.get("err_stream") or sys.stderr
+    if "out" not in result.hide and out_stream is not False:
+        out_stream.write(result.stdout)
+        out_stream.flush()
+    if "err" not in result.hide and err_stream is not False:
+        err_stream.write(result.stderr)
+        err_stream.flush()

{invoke_toolkit-0.0.63 → invoke_toolkit-0.0.65b1}/src/invoke_toolkit/context/context.py

@@ -29,7 +29,8 @@ from invoke_toolkit.config import ToolkitConfig
 from invoke_toolkit.config.status_helper import StatusHelper
 from invoke_toolkit.output.console import get_console
 
-from .types import BoundPrintProtocol, ContextRunProtocol
+from .types import AsyncContextRunProtocol, BoundPrintProtocol, ContextRunProtocol
+from .async_tools import AsyncGatherScope, in_async_task_context, run_async_command
 
 if TYPE_CHECKING:
     from rich.console import Console
@@ -58,10 +59,10 @@ class ConfigProtocol(Protocol):
 
 
 class ToolkitContext(Context, ConfigProtocol):
-    """Type annotated override"""
+    """Type annotated override with async task support."""
 
     run: ContextRunProtocol
-    _console: "Console"
+    run_async: AsyncContextRunProtocol
     _config: ToolkitConfig
     _status_helper: StatusHelper
 
@@ -93,8 +94,22 @@ class ToolkitContext(Context, ConfigProtocol):
     @property
     def console(self) -> "Console":
         """A console instance to do rich output"""
-        console = get_console()
-        return console
+        return get_console()
+
+    def run(self, command: str, **kwargs: Any):
+        """Run a command synchronously, or return a coroutine in async tasks."""
+        if in_async_task_context() and not kwargs.get("asynchronous", False):
+            return self.run_async(command, **kwargs)
+        runner = self.config.runners.local(self)
+        return self._run(runner, command, **kwargs)
+
+    async def run_async(self, command: str, **kwargs: Any):
+        """Run a command without blocking the current asyncio event loop."""
+        return await run_async_command(self, command, **kwargs)
+
+    def gather(self) -> AsyncGatherScope:
+        """Return an async context manager for explicit concurrent work."""
+        return AsyncGatherScope()
 
     # @contextmanager
     @property

{invoke_toolkit-0.0.63 → invoke_toolkit-0.0.65b1}/src/invoke_toolkit/context/types.py

@@ -3,7 +3,7 @@ Type annotations for finding out what's there in ctx.attribute
 """
 
 import sys
-from typing import IO, Any, Optional, Union
+from typing import IO, Any, Awaitable, Optional, Union
 
 from invoke.runners import Result
 from invoke.watchers import StreamWatcher
@@ -11,6 +11,12 @@ from rich.console import JustifyMethod, OverflowMethod, Style
 from typing_extensions import Annotated, Protocol
 
 
+class AsyncContextRunProtocol(Protocol):
+    """Coroutine API for native asyncio command execution."""
+
+    def __call__(self, command: str, **kwargs: Any) -> Awaitable[Result]: ...
+
+
 class BoundPrintProtocol(Protocol):
     def __call__(
         self,

{invoke_toolkit-0.0.63 → invoke_toolkit-0.0.65b1}/src/invoke_toolkit/executor.py

@@ -2,6 +2,7 @@
 Custom executor class to for Syntax highlighted output
 """
 
+import inspect
 from pathlib import Path
 from typing import Any, Dict, List, Optional, Tuple, Union
 
@@ -13,6 +14,7 @@ from invoke.util import debug
 
 from invoke_toolkit.collections import ToolkitCollection
 from invoke_toolkit.config import ToolkitConfig
+from invoke_toolkit.context.async_tools import async_task_context
 from invoke_toolkit.output import get_console
 from invoke_toolkit.tasks.tasks import ToolkitCall, ToolkitTask
 
@@ -50,110 +52,69 @@ class ToolkitExecutor(Executor):
         self.config = config if config is not None else ToolkitConfig()
         self.core = core if core is not None else ParseResult()
 
+    async def execute_async(
+        self, *tasks: Union[str, Tuple[str, Dict[str, Any]], ParserContext]
+    ) -> Dict["ToolkitTask", Any]:
+        """Execute task calls in order, awaiting coroutine task results."""
+        calls = self.normalize(tasks)
+        direct = list(calls)
+        expanded = self.expand_calls(calls)
+        try:
+            dedupe = self.config.tasks.dedupe
+        except AttributeError:
+            dedupe = True
+        calls = self.dedupe(expanded) if dedupe else expanded
+        results: Dict["ToolkitTask", Any] = {}
+        for call in calls:
+            autoprint = call in direct and call.autoprint
+            config = self.config
+            collection_config = self.collection.configuration(call.called_as)
+            config.load_collection(collection_config)
+            config.load_shell_env()
+            context = call.make_context(config, core_parse_result=self.core)
+            args = (context, *call.args)
+            with async_task_context():
+                result = call.task(*args, **call.kwargs)
+                if inspect.isawaitable(result):
+                    result = await result
+            if autoprint:
+                if isinstance(result, (str, Path)):
+                    print(result)
+                else:
+                    get_console("out").print(result)
+            results[call.task] = result  # ty: ignore[invalid-assignment]
+        return results
+
     def execute(
         self, *tasks: Union[str, Tuple[str, Dict[str, Any]], ParserContext]
     ) -> Dict["ToolkitTask", "Result"]:
-        """
-        Execute one or more ``tasks`` in sequence.
-
-        :param tasks:
-            An all-purpose iterable of "tasks to execute", each member of which
-            may take one of the following forms:
-
-            **A string** naming a task from the Executor's `.Collection`. This
-            name may contain dotted syntax appropriate for calling namespaced
-            tasks, e.g. ``subcollection.taskname``. Such tasks are executed
-            without arguments.
-
-            **A two-tuple** whose first element is a task name string (as
-            above) and whose second element is a dict suitable for use as
-            ``**kwargs`` when calling the named task. E.g.::
-
-                [
-                    ('task1', {}),
-                    ('task2', {'arg1': 'val1'}),
-                    ...
-                ]
-
-            is equivalent, roughly, to::
-
-                task1()
-                task2(arg1='val1')
-
-            **A `.ParserContext`** instance, whose ``.name`` attribute is used
-            as the task name and whose ``.as_kwargs`` attribute is used as the
-            task kwargs (again following the above specifications).
-
-            .. note::
-                When called without any arguments at all (i.e. when ``*tasks``
-                is empty), the default task from ``self.collection`` is used
-                instead, if defined.
-
-        :returns:
-            A dict mapping task objects to their return values.
-
-            This dict may include pre- and post-tasks if any were executed. For
-            example, in a collection with a ``build`` task depending on another
-            task named ``setup``, executing ``build`` will result in a dict
-            with two keys, one for ``build`` and one for ``setup``.
-
-        .. versionadded:: 1.0
-        """
+        """Execute one or more tasks in sequence."""
         # Normalize input
-        debug("Examining top level tasks {!r}".format(list(tasks)))  # pylint: disable=W1202
+        debug("Examining top level tasks {!r}".format(list(tasks)))
         calls = self.normalize(tasks)
-        debug("Tasks (now Calls) with kwargs: {!r}".format(calls))  # pylint: disable=W1202
-        # Obtain copy of directly-given tasks since they should sometimes
-        # behave differently
         direct = list(calls)
-        # Expand pre/post tasks
-        # TODO: may make sense to bundle expansion & deduping now eh?
         expanded = self.expand_calls(calls)
-        # Get some good value for dedupe option, even if config doesn't have
-        # the tree we expect. (This is a concession to testing.)
         try:
             dedupe = self.config.tasks.dedupe
         except AttributeError:
             dedupe = True
-        # Dedupe across entire run now that we know about all calls in order
         calls = self.dedupe(expanded) if dedupe else expanded
-        # Execute
         results = {}
-        # TODO: maybe clone initial config here? Probably not necessary,
-        # especially given Executor is not designed to execute() >1 time at the
-        # moment...
         for call in calls:
             autoprint = call in direct and call.autoprint
-            debug("Executing {!r}".format(call))  # pylint: disable=W1202
-            # Hand in reference to our config, which will preserve user
-            # modifications across the lifetime of the session.
             config = self.config
-            # But make sure we reset its task-sensitive levels each time
-            # (collection & shell env)
-            # TODO: load_collection needs to be skipped if task is anonymous
-            # (Fabric 2 or other subclassing libs only)
-            collection_config = self.collection.configuration(call.called_as)  # type: ignore[attr-defined]
+            collection_config = self.collection.configuration(call.called_as)
             config.load_collection(collection_config)
             config.load_shell_env()
-            debug("Finished loading collection & shell env configs")
-            # Get final context from the Call (which will know how to generate
-            # an appropriate one; e.g. subclasses might use extra data from
-            # being parameterized), handing in this config for use there.
-            context = call.make_context(config, core_parse_result=self.core)  # type: ignore[attr-defined]
-            args = (context, *call.args)  # type: ignore[attr-defined]
-            result = call.task(*args, **call.kwargs)  # type: ignore[attr-defined]
+            context = call.make_context(config, core_parse_result=self.core)
+            args = (context, *call.args)
+            result = call.task(*args, **call.kwargs)
             if autoprint:
-                # NOTE: Long strings will get wrapped when using autoprint in a console
-                #       we will use print for strings, for the case of piping output
-                #       and any non string type will be formatted by the console
                 if isinstance(result, (str, Path)):
                     print(result)
                 else:
                     get_console("out").print(result)
-                # print(result)
-            # TODO: handle the non-dedupe case / the same-task-different-args
-            # case, wherein one task obj maps to >1 result.
-            results[call.task] = result  # type: ignore[attr-defined]
+            results[call.task] = result
         return results
 
     def normalize(

{invoke_toolkit-0.0.63 → invoke_toolkit-0.0.65b1}/src/invoke_toolkit/program/program.py

@@ -7,15 +7,16 @@ It allows three classes to be parametrized: Loader, Config and Executor
 __all__ = ["ToolkitProgram"]
 
 import ast
+import asyncio
 import inspect
 import os
 import re
 import sys
-from importlib import metadata
+from importlib import import_module, metadata
 from importlib.util import module_from_spec
 from logging import getLogger
 from pathlib import Path
-from typing import Dict, List, Optional, Sequence, Tuple, Union
+from typing import Dict, List, Literal, Optional, Sequence, Tuple, Union
 
 from rich.table import Table
 
@@ -81,6 +82,9 @@ class ToolkitProgram(Program):
             config_class,
             binary_names,
         )
+        # Names of sub-collections that were loaded from entry-point plugins.
+        # Populated in load_collection(); used by --list-tasks / --list-plugins.
+        self._plugin_collection_names: set[str] = set()
 
     def get_version(self) -> str:
         """Compute version
@@ -126,13 +130,12 @@ class ToolkitProgram(Program):
             self.parse_tasks()
             # End of parsing (typically bailout stuff like --list, --help)
             self.parse_cleanup()
-            # Update the earlier Config with new values from the parse step -
-            # runtime config file contents and flag-derived overrides (e.g. for
-            # run()'s echo, warn, etc options.)
+            # Apply runtime config and CLI-derived overrides before execution.
             self.update_config()
-            # Create an Executor, passing in the data resulting from the prior
-            # steps, then tell it to execute the tasks.
-            self.execute()
+            if self._contains_async_task():
+                asyncio.run(self._execute_async())
+            else:
+                self.execute()
         except (UnexpectedExit, Exit, ParseError) as e:
             debug("Received a possibly-skippable exception: {!r}".format(e))
             # Print error messages from parser, runner, etc if necessary;
@@ -159,6 +162,31 @@ class ToolkitProgram(Program):
         except KeyboardInterrupt:
             sys.exit(1)  # Same behavior as Python itself outside of REPL
 
+    def _contains_async_task(self) -> bool:
+        """Return whether the requested task graph contains coroutine work."""
+        for parser_context in self.tasks:
+            task = self.collection[parser_context.name]
+            calls = [task, *task.pre, *task.post]
+            if any(inspect.iscoroutinefunction(call.body) for call in calls):
+                return True
+        default = self.collection.default
+        return bool(
+            default and inspect.iscoroutinefunction(self.collection[default].body)
+        )
+
+    async def _execute_async(self) -> None:
+        """Execute parsed tasks through the async executor path."""
+        klass = self.executor_class
+        config_path = self.config.tasks.executor_class
+        if config_path is not None:
+            module_path, _, class_name = config_path.rpartition(".")
+            module = import_module(module_path)
+            klass = getattr(module, class_name)
+        executor = klass(self.collection, self.config, self.core)
+        if not hasattr(executor, "execute_async"):
+            raise TypeError("Async tasks require an executor with execute_async()")
+        await executor.execute_async(*self.tasks)  # ty: ignore[call-non-callable]
+
     def setup_consoles(self):
         """Pre-populate the console objects"""
         patterns = self.args["redact_pattern"].value
@@ -368,10 +396,92 @@ class ToolkitProgram(Program):
                 default=False,
                 help="Initializes shell for runner via CLI flag",
             ),
+            ToolkitArgument(
+                names=("list-tasks", "lt"),
+                kind=bool,
+                default=False,
+                help="List only the main tasks discovered in the current directory (excludes plugins)",
+            ),
+            ToolkitArgument(
+                names=("list-plugins", "lp"),
+                kind=bool,
+                default=False,
+                help="List only the plugin-provided task collections (excludes main tasks)",
+            ),
         ]
         args.extend(toolkit_program_arguments)
         return args
 
+    def _handle_list_flags(self) -> None:
+        """
+        Handle --list, --list-tasks, and --list-plugins flags.
+
+        Sets ``list_format`` / ``list_depth`` / ``scoped_collection`` as needed
+        and raises `Exit` when any listing flag is active.
+        """
+        self.list_format = self.args["list-format"].value
+        self.list_depth = self.args["list-depth"].value
+
+        # --list [root]: standard task listing (optionally scoped to a sub-collection)
+        list_root = self.args.list.value  # True or a string namespace
+        if list_root:
+            if isinstance(list_root, str):
+                self.list_root = list_root
+                try:
+                    sub = self.collection.subcollection_from_path(list_root)
+                    self.scoped_collection = sub
+                except KeyError:
+                    msg = "Sub-collection '{}' not found!"
+                    raise Exit(msg.format(list_root))
+            self.list_tasks()
+            raise Exit
+
+        # --list-tasks: show only main (non-plugin) tasks
+        if self.args["list-tasks"].value:
+            debug("Saw --list-tasks, listing main tasks only & exiting")
+            self.scoped_collection = self._make_filtered_collection("tasks")
+            self.list_tasks()
+            raise Exit
+
+        # --list-plugins: show only plugin-provided collections
+        if self.args["list-plugins"].value:
+            debug("Saw --list-plugins, listing plugin collections only & exiting")
+            if not self._plugin_collection_names:
+                raise Exit("No plugin collections found.")
+            self.scoped_collection = self._make_filtered_collection("plugins")
+            self.list_tasks()
+            raise Exit
+
+    def _make_filtered_collection(
+        self, mode: "Literal['tasks', 'plugins']"
+    ) -> "ToolkitCollection":
+        """
+        Return a shallow copy of ``self.scoped_collection`` containing only
+        the subset of tasks and sub-collections appropriate for *mode*.
+
+        - ``'tasks'``   – direct tasks + non-plugin sub-collections only
+        - ``'plugins'`` – plugin sub-collections only (no direct tasks)
+        """
+        source = self.scoped_collection
+        filtered = ToolkitCollection(source.name or "")
+        if mode == "tasks":
+            # Include all direct tasks on the scoped collection
+            for task_name, task in source.tasks.items():
+                filtered.add_task(task, name=task_name)
+            # Include sub-collections that are NOT from plugins
+            for coll_name, coll in source.collections.items():
+                if coll_name not in self._plugin_collection_names:
+                    filtered.add_collection(coll, name=coll_name)
+        else:  # mode == "plugins"
+            # Include only the plugin sub-collections
+            for coll_name, coll in source.collections.items():
+                if coll_name in self._plugin_collection_names:
+                    filtered.add_collection(coll, name=coll_name)
+        # Preserve the default task pointer when it still makes sense
+        if source.default and source.default in filtered.tasks:
+            filtered.default = source.default
+        return filtered
+
     def _load_entry_points_collection(self, start: str) -> "ToolkitCollection | None":
         """
         Load task collections from entry points.
@@ -453,6 +563,7 @@ class ToolkitProgram(Program):
                 debug("Merging entry point collections with tasks.py")
                 for name, collection in ep_collection.collections.items():
                     self.collection.add_collection(collection, name=name)
+                    self._plugin_collection_names.add(name)
         except CollectionNotFound as e:
             start = self.args["search-root"].value or "."
             # First try to load entry points (for packages without tasks.py)
@@ -460,6 +571,7 @@ class ToolkitProgram(Program):
             if ep_collection is not None:
                 debug("Loading collections from entry points")
                 self.collection = ep_collection
+                self._plugin_collection_names.update(ep_collection.collections.keys())
             else:
                 # If entry points weren't found, try local_tasks or fail
                 if not (Path(start) / "local_tasks.py").exists():
@@ -571,23 +683,8 @@ class ToolkitProgram(Program):
                 # should?
                 raise ParseError("No idea what '{}' is!".format(halp))
 
-        # Print discovered tasks if necessary
-        list_root = self.args.list.value  # will be True or string
-
-        self.list_format = self.args["list-format"].value
-        self.list_depth = self.args["list-depth"].value
-        if list_root:
-            # Not just --list, but --list some-root - do moar work
-            if isinstance(list_root, str):
-                self.list_root = list_root
-                try:
-                    sub = self.collection.subcollection_from_path(list_root)
-                    self.scoped_collection = sub
-                except KeyError:
-                    msg = "Sub-collection '{}' not found!"
-                    raise Exit(msg.format(list_root))
-            self.list_tasks()
-            raise Exit
+        # Handle --list / --list-tasks / --list-plugins (raises Exit if triggered)
+        self._handle_list_flags()
 
         # Print completion helpers if necessary
         if self.args.complete.value: