invoke-toolkit 0.0.61__tar.gz → 0.0.63__tar.gz

{invoke_toolkit-0.0.61 → invoke_toolkit-0.0.63}/.gitignore

@@ -15,3 +15,6 @@ _scratchpad.py
 _[a-z]*.py
 _test/*
 invoke.yaml
+# Makrdowns
+*.md
+!docs/**/*.md

{invoke_toolkit-0.0.61 → invoke_toolkit-0.0.63}/PKG-INFO

@@ -1,20 +1,26 @@
 Metadata-Version: 2.4
 Name: invoke-toolkit
-Version: 0.0.61
-Summary: A set of extended APIs for PyInvoke for composable scripts, plugins and richer output
+Version: 0.0.63
+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
 Project-URL: Source, https://github.com/D3f0/invoke-toolkit
 Author-email: Nahuel Defossé <D3f0@users.noreply.github.com>
 License-Expression: MIT
 License-File: LICENSE.txt
+Keywords: automation,cli,completion,devtools,fzf,invoke,plugin,pyinvoke,rich,task
 Classifier: Development Status :: 4 - Beta
 Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
 Classifier: Operating System :: MacOS :: MacOS X
 Classifier: Operating System :: POSIX
 Classifier: Operating System :: Unix
 Classifier: Programming Language :: Python
 Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
 Classifier: Programming Language :: Python :: Implementation :: CPython
 Classifier: Topic :: Software Development
 Classifier: Topic :: Software Development :: Build Tools
@@ -22,13 +28,15 @@ Classifier: Topic :: Software Development :: Libraries
 Classifier: Topic :: Software Development :: Libraries :: Python Modules
 Classifier: Topic :: System :: Software Distribution
 Classifier: Topic :: System :: Systems Administration
+Classifier: Topic :: Terminals
+Classifier: Topic :: Utilities
+Classifier: Typing :: Typed
 Requires-Python: >=3.10
 Requires-Dist: appdirs
 Requires-Dist: attrs>=24.1.0
 Requires-Dist: cattrs>=24.1.0
 Requires-Dist: httpx>=0.28.1
-Requires-Dist: invoke>=2.2.1
-Requires-Dist: pdbpp>=0.11.7
+Requires-Dist: invoke>=3.0.3
 Requires-Dist: platformdirs>=4.5.0
 Requires-Dist: pyyaml>=6.0.3
 Requires-Dist: rich>=13
@@ -38,17 +46,17 @@ Requires-Dist: typing-extensions>=4.13.2
 Provides-Extra: cache
 Requires-Dist: diskcache>=5.6.0; extra == 'cache'
 Provides-Extra: copier
-Requires-Dist: copier>=9.10.3; extra == 'copier'
+Requires-Dist: copier>=9.16.0; extra == 'copier'
 Provides-Extra: debug
 Requires-Dist: hunter>=3.7.0; extra == 'debug'
 Requires-Dist: pdbpp>=0.11.7; extra == 'debug'
 Provides-Extra: full
-Requires-Dist: copier>=9.10.3; extra == 'full'
+Requires-Dist: copier>=9.16.0; extra == 'full'
 Requires-Dist: diskcache>=5.6.0; extra == 'full'
 Requires-Dist: hunter>=3.7.0; extra == 'full'
 Requires-Dist: pdbpp>=0.11.7; extra == 'full'
 Provides-Extra: templating
-Requires-Dist: copier>=9.10.3; extra == 'templating'
+Requires-Dist: copier>=9.16.0; extra == 'templating'
 Description-Content-Type: text/markdown
 
 # invoke-toolkit

{invoke_toolkit-0.0.61 → invoke_toolkit-0.0.63}/pyproject.toml

@@ -1,19 +1,35 @@
 [project]
 name = "invoke-toolkit"
 dynamic = ["version"]
-description = "A set of extended APIs for PyInvoke for composable scripts, plugins and richer output"
+description = "Extended APIs for PyInvoke: composable task plugins, typed CLI args, Rich output, shell completion, and PEP 723 script support"
 readme = "README.md"
 requires-python = ">=3.10"
 license = "MIT"
-keywords = []
+keywords = [
+  "invoke",
+  "task",
+  "cli",
+  "automation",
+  "plugin",
+  "completion",
+  "rich",
+  "pyinvoke",
+  "devtools",
+  "fzf",
+]
 authors = [
   { name = "Nahuel Defossé", email = "D3f0@users.noreply.github.com" },
 ]
 classifiers = [
   "Development Status :: 4 - Beta",
   "Environment :: Console",
+  "Intended Audience :: Developers",
   "Programming Language :: Python",
   "Programming Language :: Python :: 3",
+  "Programming Language :: Python :: 3.10",
+  "Programming Language :: Python :: 3.11",
+  "Programming Language :: Python :: 3.12",
+  "Programming Language :: Python :: 3.13",
   "Programming Language :: Python :: Implementation :: CPython",
   "Operating System :: POSIX",
   "Operating System :: Unix",
@@ -24,15 +40,17 @@ classifiers = [
   "Topic :: Software Development :: Libraries :: Python Modules",
   "Topic :: System :: Software Distribution",
   "Topic :: System :: Systems Administration",
+  "Topic :: Terminals",
+  "Topic :: Utilities",
+  "Typing :: Typed",
 ]
 dependencies = [
-    "invoke>=2.2.1",
+    "invoke>=3.0.3",
     "rich>=13",
     "typing-extensions>=4.13.2",
     "appdirs",
     "tomlkit>=0.13.3",
     "pyyaml>=6.0.3",
-    "pdbpp >=0.11.7",
     "platformdirs>=4.5.0",
     "httpx>=0.28.1",
     "setproctitle>=1.3.7",
@@ -119,17 +137,17 @@ cache = [
   "diskcache>=5.6.0",
 ]
 copier = [
-  "copier>=9.10.3",
+  "copier>=9.16.0",
 ]
 templating = [
-  "copier>=9.10.3",
+  "copier>=9.16.0",
 ]
 debug = [
   "hunter>=3.7.0",
   "pdbpp>=0.11.7",
 ]
 full = [
-  "copier>=9.10.3",
+  "copier>=9.16.0",
   "diskcache>=5.6.0",
   "hunter>=3.7.0",
   "pdbpp>=0.11.7",
@@ -141,7 +159,7 @@ ci = [
 ]
 dev = [
 
-    "copier>=9.10.3",
+    "copier>=9.16.0",
     "diskcache>=5.6.0",
     "hunter>=3.7.0",
     "pdbpp>=0.11.7",
@@ -149,7 +167,7 @@ dev = [
     "pre-commit-uv>=4.2.0",
     "pylint>=3.2.7",
     "pylint-per-file-ignores>=1.0.0",
-    "pytest>=8.3.5",
+    "pytest>=9.1.1",
     "pytest-cov>=5.0.0",
     "pytest-html>=4.1.1",
     "pytest-picked>=0.5.1",

invoke_toolkit-0.0.63/src/invoke_toolkit/config/status_helper.py

@@ -0,0 +1,246 @@
+"""
+Class that implements the ctx.status through the config class
+"""
+
+from collections import deque
+from contextlib import contextmanager
+from typing import Generator, Optional, Union
+
+from rich.console import Console, Group, RenderableType
+from rich.live import Live
+from rich.panel import Panel
+from rich.spinner import Spinner
+from rich.status import Status
+from rich.style import StyleType
+from rich.text import Text
+
+from invoke_toolkit.output import get_console
+
+MAX_OUTPUT_LINES = 3
+
+
+class NoOpStatus:
+    """A no-op status object that prints messages on enter and exit"""
+
+    def __init__(
+        self,
+        status: Optional[RenderableType] = None,
+        console: Optional[Console] = None,
+    ):
+        self.status = status
+        self.console = console or get_console()
+
+    def __enter__(self) -> "NoOpStatus":
+        """Print status message on enter"""
+        if self.status:
+            self.console.print(f"[bold blue]→[/bold blue] {self.status}")
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        """Print status message on exit"""
+        if self.status:
+            self.console.print(f"[bold green]✓[/bold green] {self.status}")
+
+    def update(
+        self,
+        status: Optional[RenderableType] = None,
+        *,
+        spinner: Optional[str] = None,
+        spinner_style: Optional[StyleType] = None,
+        speed: Optional[float] = None,
+    ) -> None:
+        """No-op update"""
+
+    def stop(self) -> None:
+        """No-op stop"""
+
+    def capture_line(self, line: str) -> None:
+        """No-op capture"""
+
+
+class VerboseStatus:  # pylint: disable=too-many-instance-attributes
+    """Status that shows the last N lines of command output below the spinner."""
+
+    def __init__(
+        self,
+        status: RenderableType,
+        *,
+        console: Optional[Console] = None,
+        spinner: str = "dots",
+        spinner_style: StyleType = "status.spinner",
+        speed: float = 1.0,
+        refresh_per_second: float = 12.5,
+        max_lines: int = MAX_OUTPUT_LINES,
+    ):
+        self.status = status
+        self.spinner_style = spinner_style
+        self.speed = speed
+        self._lines: deque[str] = deque(maxlen=max_lines)
+        self._spinner = Spinner(spinner, text=status, style=spinner_style, speed=speed)
+        self._console = console or get_console()
+        self._live = Live(
+            self._build_renderable(),
+            console=self._console,
+            refresh_per_second=refresh_per_second,
+            transient=True,
+        )
+
+    def _build_renderable(self) -> RenderableType:
+        """Build the composite renderable: spinner + output panel."""
+        if not self._lines:
+            return self._spinner
+        output_text = Text("\n".join(self._lines), style="dim")
+        panel = Panel(
+            output_text,
+            border_style="dim",
+            padding=(0, 1),
+            expand=True,
+        )
+        return Group(self._spinner, panel)
+
+    def capture_line(self, line: str) -> None:
+        """Append a line of output and refresh the live display."""
+        self._lines.append(line.rstrip("\n\r"))
+        self._live.update(self._build_renderable())
+
+    def update(
+        self,
+        status: Optional[RenderableType] = None,
+        *,
+        spinner: Optional[str] = None,
+        spinner_style: Optional[StyleType] = None,
+        speed: Optional[float] = None,
+    ) -> None:
+        """Update the status text or spinner parameters."""
+        if status is not None:
+            self.status = status
+        if spinner_style is not None:
+            self.spinner_style = spinner_style
+        if speed is not None:
+            self.speed = speed
+        if spinner is not None:
+            self._spinner = Spinner(
+                spinner, text=self.status, style=self.spinner_style, speed=self.speed
+            )
+        else:
+            self._spinner.update(
+                text=self.status, style=self.spinner_style, speed=self.speed
+            )
+        self._live.update(self._build_renderable())
+
+    def start(self) -> None:
+        """Start the live display."""
+        self._live.start()
+
+    def stop(self) -> None:
+        """Stop the live display."""
+        self._live.stop()
+
+    def __enter__(self) -> "VerboseStatus":
+        self.start()
+        return self
+
+    def __exit__(self, exc_type, exc_val, exc_tb) -> None:
+        self.stop()
+
+
+class StatusHelper:
+    """
+    A bridge to insert rich's status bound to a console into a invoke config, so
+    it can be accessed from the task's context
+    """
+
+    _current_status: Optional[Union[Status, VerboseStatus]]
+    _disabled: bool
+    _show_command_output: bool
+
+    def __init__(
+        self,
+        console: Console,
+        disabled: bool = False,
+        show_command_output: bool = False,
+    ):
+        self.console = console or get_console()
+        self._current_status = None
+        self._disabled = disabled
+        self._show_command_output = show_command_output
+
+    @contextmanager
+    def status(
+        self,
+        status: RenderableType,
+        *,
+        spinner: str = "dots",
+        spinner_style: StyleType = "status.spinner",
+        speed: float = 1.0,
+        refresh_per_second: float = 12.5,
+    ) -> Generator[Union[Status, VerboseStatus], None, None]:
+        """Context manager for status management"""
+        if self._disabled:
+            with NoOpStatus(status=status, console=self.console) as noop:
+                yield noop  # type: ignore[misc]
+            return
+
+        if self._current_status is not None:
+            # Nested status: update the existing one
+            self._current_status.update(
+                status, spinner=spinner, spinner_style=spinner_style, speed=speed
+            )
+            yield self._current_status
+        elif self._show_command_output:
+            verbose = VerboseStatus(
+                status=status,
+                console=self.console,
+                spinner=spinner,
+                spinner_style=spinner_style,
+                speed=speed,
+                refresh_per_second=refresh_per_second,
+            )
+            with verbose as self._current_status:  # type: ignore[assignment]
+                yield self._current_status
+            self._current_status = None
+        else:
+            with self.console.status(
+                status=status,
+                spinner=spinner,
+                spinner_style=spinner_style,
+                speed=speed,
+                refresh_per_second=refresh_per_second,
+            ) as self._current_status:
+                yield self._current_status
+            self._current_status = None
+
+    def capture_line(self, line: str) -> None:
+        """Feed a line of output to the current verbose status display."""
+        if isinstance(self._current_status, VerboseStatus):
+            self._current_status.capture_line(line)
+
+    @property
+    def is_verbose(self) -> bool:
+        """Whether the current status is a VerboseStatus."""
+        return isinstance(self._current_status, VerboseStatus)
+
+    def status_update(
+        self,
+        status: Optional[RenderableType] = None,
+        *,
+        spinner: Optional[str] = None,
+        spinner_style: Optional[StyleType] = None,
+        speed: Optional[float] = None,
+    ) -> None:
+        """Wrapper on Status.update"""
+        if self._disabled:
+            return
+
+        if self._current_status:
+            self._current_status.update(
+                status, spinner=spinner, spinner_style=spinner_style, speed=speed
+            )
+
+    def status_stop(self) -> None:
+        """Cancels the status. This will allow to use the REPL in debugging breakpoints"""
+        if self._disabled:
+            return
+
+        if self._current_status:
+            self._current_status.stop()

{invoke_toolkit-0.0.61 → invoke_toolkit-0.0.63}/src/invoke_toolkit/context/context.py

@@ -70,15 +70,24 @@ class ToolkitContext(Context, ConfigProtocol):
         [Union[PathLike[str], str]], _GeneratorContextManager[None, None, None]
     ]
 
-    def __init__(self, config: Optional[ToolkitConfig] = None) -> None:
-        super().__init__(config)
+    def __init__(
+        self, config: Optional[ToolkitConfig] = None, remainder: str = ""
+    ) -> None:
+        super().__init__(config, remainder=remainder)
         self._set("_console", get_console())
         # Check if status is disabled in the config
         disabled = False
+        show_command_output = False
         if config and hasattr(config, "get"):
             disabled = config.get("disable_status", False)
+            show_command_output = config.get("show_command_output", False)
         self._set(
-            "_status_helper", StatusHelper(console=self._console, disabled=disabled)
+            "_status_helper",
+            StatusHelper(
+                console=self._console,
+                disabled=disabled,
+                show_command_output=show_command_output,
+            ),
         )
 
     @property

{invoke_toolkit-0.0.61 → invoke_toolkit-0.0.63}/src/invoke_toolkit/executor.py

@@ -39,11 +39,16 @@ class ToolkitExecutor(Executor):
 
         :param core:
             An optional `.ParseResult` holding parsed core program arguments.
-            Defaults to ``None``.
+            Defaults to an empty `.ParseResult` if not given.
+
+        .. versionchanged:: invoke 3.0
+            ``self.core`` now defaults to ``ParseResult()`` instead of
+            ``None``, matching upstream ``Executor`` behaviour and ensuring
+            ``core_parse_result.remainder`` is always accessible.
         """
         self.collection = collection
         self.config = config if config is not None else ToolkitConfig()
-        self.core = core
+        self.core = core if core is not None else ParseResult()
 
     def execute(
         self, *tasks: Union[str, Tuple[str, Dict[str, Any]], ParserContext]
@@ -134,7 +139,7 @@ class ToolkitExecutor(Executor):
             # 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)  # type: ignore[attr-defined]
+            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]
             if autoprint:

{invoke_toolkit-0.0.61 → invoke_toolkit-0.0.63}/src/invoke_toolkit/extensions/tasks/config.py

@@ -195,6 +195,38 @@ def _set_nested_value(config_dict: dict, path: str, value: Any) -> dict:
     return config_dict
 
 
+def _remove_nested_value(config_dict: dict, path: str) -> dict:
+    """Remove a value from a nested dictionary using dot notation.
+    Args:
+        config_dict: The config dictionary to modify
+        path: Dot-separated path (e.g., 'group.subgroup.key')
+    Returns:
+        The modified config dictionary
+    """
+    keys = path.split(".")
+    path_dicts = [config_dict]
+    for key in keys[:-1]:
+        last_dict = path_dicts[-1]
+        if key in last_dict and isinstance(last_dict.get(key), dict):
+            path_dicts.append(last_dict[key])
+        else:
+            # Path doesn't exist
+            return config_dict
+
+    # Remove the final key
+    if keys[-1] in path_dicts[-1]:
+        del path_dicts[-1][keys[-1]]
+
+    # Clean up empty parent dictionaries
+    for i in range(len(path_dicts) - 2, -1, -1):
+        if not path_dicts[i + 1]:
+            del path_dicts[i][keys[i]]
+        else:
+            break
+
+    return config_dict
+
+
 def _load_config_file(path: Path) -> dict:
     """Load a config file and return its contents as a dictionary.
 
@@ -676,6 +708,55 @@ def set_(
     ctx.print(f"  [dim]Saved to: {config_path}[/dim]")
 
 
+@task(
+    name="unset",
+    help={
+        "path": "Dot-separated path to unset (e.g., 'run.echo', 'custom.api_key')",
+        "location": "Where to save: 'local' (default), 'user', or 'system'",
+    },
+)
+def unset(
+    ctx: Context,
+    path: Annotated[str | None, _complete_config_path] = None,
+    location: ConfigLocation = ConfigLocation.LOCAL,
+):
+    """
+    Unset a configuration value in a config file.
+
+    Examples:
+        invoke-toolkit -x config.unset run.echo
+        invoke-toolkit -x config.unset custom.ports
+    """
+    if path is None:
+        ctx.print_err(
+            "[red]Error:[/red] 'path' is required.\n"
+            "[dim]Usage: config.unset <path>[/dim]\n"
+            "[dim]Use --help for more information.[/dim]"
+        )
+        return
+
+    config_path = _find_existing_config_file(ctx, location)
+    if not config_path or not config_path.exists():
+        ctx.print_err(
+            f"[yellow]No config file found at location '{location}'. Nothing to do.[/yellow]"
+        )
+        return
+
+    config_dict = _load_config_file(config_path)
+    original_config = config_dict.copy()
+    config_dict = _remove_nested_value(config_dict, path)
+
+    if config_dict == original_config:
+        ctx.print_err(
+            f"[yellow]Path '[bold]{path}[/bold]' not found in the configuration. Nothing to do.[/yellow]"
+        )
+        return
+
+    _save_config_file(config_path, config_dict)
+    ctx.print(f"[green]✓[/green] Unset [bold]{path}[/bold]")
+    ctx.print(f"  [dim]Saved to: {config_path}[/dim]")
+
+
 def _print_nested_schema(
     ctx: Context, prefix: str, data: dict, indent: int = 2
 ) -> None:

{invoke_toolkit-0.0.61 → invoke_toolkit-0.0.63}/src/invoke_toolkit/program/program.py

@@ -195,6 +195,11 @@ class ToolkitProgram(Program):
             debug("Disabling status context manager via CLI flag")
             self.config["disable_status"] = True  # type: ignore[index]
 
+        # Update config with show_command_output flag from CLI
+        if self.args["show_command_output"].value:
+            debug("Enabling command output display below status via CLI flag")
+            self.config["show_command_output"] = True  # type: ignore[index]
+
         # Update config with init_shell flag from CLI
         if self.args["init_shell"].value:
             debug("Initializing shell for runner via CLI flag")
@@ -351,6 +356,12 @@ class ToolkitProgram(Program):
                 default=False,
                 help="Disables the rich status context manager for debugging (useful when debugging breakpoints or using REPL)",
             ),
+            ToolkitArgument(
+                names=("show_command_output", "O"),
+                kind=bool,
+                default=False,
+                help="Shows last few lines of command output below the status spinner",
+            ),
             ToolkitArgument(
                 names=("init_shell",),
                 kind=bool,

{invoke_toolkit-0.0.61 → invoke_toolkit-0.0.63}/src/invoke_toolkit/runners/rich.py

@@ -4,6 +4,7 @@ in tasks.
 """
 
 import sys
+from typing import TYPE_CHECKING, Optional
 
 from invoke.runners import Local
 from invoke.util import debug
@@ -11,6 +12,9 @@ from rich.syntax import Syntax
 
 from invoke_toolkit.output import get_console
 
+if TYPE_CHECKING:
+    from invoke_toolkit.config.status_helper import StatusHelper
+
 
 class RedactingStream:
     """A file-like wrapper that redacts secrets before writing output."""
@@ -51,6 +55,46 @@ class RedactingStream:
         return getattr(self.original_stream, name)
 
 
+class OutputCapturingStream:
+    """A file-like wrapper that captures output lines and feeds them to a StatusHelper."""
+
+    def __init__(self, status_helper: "StatusHelper", original_stream):
+        self._status_helper = status_helper
+        self.original_stream = original_stream
+        self.encoding = getattr(original_stream, "encoding", "utf-8") or "utf-8"
+        self._buffer = ""
+
+    def write(self, text: str) -> int:
+        """Write text, splitting into lines for capture."""
+        if not text:
+            return 0
+
+        self._buffer += text
+        while "\n" in self._buffer:
+            line, self._buffer = self._buffer.split("\n", 1)
+            self._status_helper.capture_line(line)
+
+        return len(text)
+
+    def flush(self) -> None:
+        """Flush remaining buffer content."""
+        if self._buffer:
+            self._status_helper.capture_line(self._buffer)
+            self._buffer = ""
+        if hasattr(self.original_stream, "flush"):
+            self.original_stream.flush()
+
+    def isatty(self) -> bool:
+        """Return whether the underlying stream is a tty."""
+        if hasattr(self.original_stream, "isatty"):
+            return self.original_stream.isatty()
+        return False
+
+    def __getattr__(self, name):
+        """Delegate other attributes to the original stream."""
+        return getattr(self.original_stream, name)
+
+
 class NoStdoutRunner(Local):
     """Invoke runner that prints to stderr when invoke is used with -e/--echo
     and redacts secrets from subprocess output when redaction is enabled.
@@ -65,8 +109,13 @@ class NoStdoutRunner(Local):
             debug("context is missing print")
             print(self.opts["echo_format"].format(command=command), file=sys.stderr)
 
+    def _get_status_helper(self) -> "Optional[StatusHelper]":
+        if hasattr(self.context, "_status_helper"):
+            return self.context._status_helper  # pylint: disable=protected-access
+        return None
+
     def run(self, command, **kwargs):
-        """Execute command with redacting streams if redaction is enabled."""
+        """Execute command with redacting streams and optional output capture."""
         # Get the configured console objects
         out_console = get_console("out")
         err_console = get_console("err")
@@ -92,4 +141,15 @@ class NoStdoutRunner(Local):
                 f"Running with redacting streams: {has_out_redaction=}, {has_err_redaction=}"
             )
 
+        # If we're inside a verbose status, capture output for the panel
+        status_helper = self._get_status_helper()
+        if status_helper and status_helper.is_verbose:
+            out_stream = kwargs.get("out_stream") or sys.stdout
+            err_stream = kwargs.get("err_stream") or sys.stderr
+            kwargs["out_stream"] = OutputCapturingStream(status_helper, out_stream)
+            kwargs["err_stream"] = OutputCapturingStream(status_helper, err_stream)
+            # Disable hide so output flows through our capturing stream
+            # (the stream feeds the Live panel instead of printing to terminal)
+            kwargs["hide"] = False
+
         return super().run(command, **kwargs)