modal 1.0.3.dev10__py3-none-any.whl → 1.2.3.dev7__py3-none-any.whl

modal/cli/run.py

@@ -10,6 +10,7 @@ import time
 import typing
 from dataclasses import dataclass
 from functools import partial
+from pathlib import Path, PurePosixPath
 from typing import Any, Callable, Optional
 
 import click
@@ -22,11 +23,13 @@ from ..app import App, LocalEntrypoint
 from ..cls import _get_class_constructor_signature
 from ..config import config
 from ..environments import ensure_env
-from ..exception import ExecutionError, InvalidError, _CliUserExecutionError
+from ..exception import ExecutionError, InvalidError, NotFoundError, _CliUserExecutionError
 from ..functions import Function
 from ..image import Image
+from ..mount import _Mount
 from ..output import enable_output
 from ..runner import deploy_app, interactive_shell, run_app
+from ..secret import Secret
 from ..serving import serve_app
 from ..volume import Volume
 from .import_refs import (
@@ -171,6 +174,14 @@ def _write_local_result(result_path: str, res: Any):
         fid.write(res)
 
 
+def _validate_interactive_quiet_params(ctx):
+    interactive = ctx.obj["interactive"]
+    show_progress = ctx.obj["show_progress"]
+
+    if not show_progress and interactive:
+        raise InvalidError("To use interactive mode, remove the --quiet flag")
+
+
 def _make_click_function(app, signature: CliRunnableSignature, inner: Callable[[tuple[str, ...], dict[str, Any]], Any]):
     @click.pass_context
     def f(ctx, **kwargs):
@@ -180,6 +191,8 @@ def _make_click_function(app, signature: CliRunnableSignature, inner: Callable[[
         else:
             args = ()
 
+        _validate_interactive_quiet_params(ctx)
+
         show_progress: bool = ctx.obj["show_progress"]
         with enable_output(show_progress):
             with run_app(
@@ -196,7 +209,7 @@ def _make_click_function(app, signature: CliRunnableSignature, inner: Callable[[
     return f
 
 
-def _get_click_command_for_function(app: App, function: Function):
+def _get_click_command_for_function(app: App, function: Function, ctx: click.Context):
     if function.is_generator:
         raise InvalidError("`modal run` is not supported for generator functions")
 
@@ -205,7 +218,10 @@ def _get_click_command_for_function(app: App, function: Function):
     signature: CliRunnableSignature = _get_cli_runnable_signature(sig, type_hints)
 
     def _inner(args, click_kwargs):
-        return function.remote(*args, **click_kwargs)
+        if ctx.obj["detach"]:
+            return function.spawn(*args, **click_kwargs).get()
+        else:
+            return function.remote(*args, **click_kwargs)
 
     f = _make_click_function(app, signature, _inner)
 
@@ -219,7 +235,7 @@ def _get_click_command_for_function(app: App, function: Function):
         return click.command(with_click_options)
 
 
-def _get_click_command_for_cls(app: App, method_ref: MethodReference):
+def _get_click_command_for_cls(app: App, method_ref: MethodReference, ctx: click.Context):
     parameters: dict[str, ParameterMetadata]
     cls = method_ref.cls
     method_name = method_ref.method_name
@@ -260,7 +276,10 @@ def _get_click_command_for_cls(app: App, method_ref: MethodReference):
 
         instance = cls(**cls_kwargs)
         method: Function = getattr(instance, method_name)
-        return method.remote(*args, **fun_kwargs)
+        if ctx.obj["detach"]:
+            return method.spawn(*args, **fun_kwargs).get()
+        else:
+            return method.remote(*args, **fun_kwargs)
 
     f = _make_click_function(app, fun_signature, _inner)
     with_click_options = _add_click_options(f, parameters)
@@ -291,6 +310,8 @@ def _get_click_command_for_local_entrypoint(app: App, entrypoint: LocalEntrypoin
             assert len(args) == 0 and len(kwargs) == 0
             args = ctx.args
 
+        _validate_interactive_quiet_params(ctx)
+
         show_progress: bool = ctx.obj["show_progress"]
         with enable_output(show_progress):
             with run_app(
@@ -363,9 +384,9 @@ class RunGroup(click.Group):
         if isinstance(runnable, LocalEntrypoint):
             click_command = _get_click_command_for_local_entrypoint(app, runnable)
         elif isinstance(runnable, Function):
-            click_command = _get_click_command_for_function(app, runnable)
+            click_command = _get_click_command_for_function(app, runnable, ctx)
         elif isinstance(runnable, MethodReference):
-            click_command = _get_click_command_for_cls(app, runnable)
+            click_command = _get_click_command_for_cls(app, runnable, ctx)
         else:
             # This should be unreachable...
             raise ValueError(f"{runnable} is neither function, local entrypoint or class/method")
@@ -448,11 +469,10 @@ def deploy(
     if not name:
         raise ExecutionError(
             "You need to either supply an explicit deployment name on the command line "
-            "or have a name set on the app.\n"
+            "or have a name set on the App.\n"
             "\n"
             "Examples:\n"
-            'app = modal.App("some-name")'
-            "or\n"
+            'app = modal.App("some-name")\n'
             "modal deploy ... --name=some-name"
         )
 
@@ -478,6 +498,12 @@ def serve(
     ```
     modal serve hello_world.py
     ```
+
+    Modal-generated URLs will have a `-dev` suffix appended to them when running with `modal serve`.
+    To customize this suffix (i.e., to avoid collisions with other users in your workspace who are
+    concurrently serving the App), you can set the `dev_suffix` in your `.modal.toml` file or the
+    `MODAL_DEV_SUFFIX` environment variable.
+
     """
     env = ensure_env(env)
     import_ref = parse_import_ref(app_ref, use_module_mode=use_module_mode)
@@ -498,13 +524,12 @@ def serve(
 
 
 def shell(
-    container_or_function: Optional[str] = typer.Argument(
+    ref: Optional[str] = typer.Argument(
         default=None,
         help=(
-            "ID of running container, or path to a Python file containing a Modal App."
-            " Can also include a function specifier, like `module.py::func`, if the file defines multiple functions."
+            "ID of running container or Sandbox, or path to a Python file containing an App."
+            " Can also include a Function specifier, like `module.py::func`, if the file defines multiple Functions."
         ),
-        metavar="REF",
     ),
     cmd: str = typer.Option("/bin/bash", "-c", "--cmd", help="Command to run inside the Modal image."),
     env: str = ENV_OPTION,
@@ -519,6 +544,17 @@ def shell(
             " Can be used multiple times."
         ),
     ),
+    add_local: Optional[list[str]] = typer.Option(
+        default=None,
+        help=(
+            "Local file or directory to mount inside the shell at `/mnt/{basename}` (if not using REF)."
+            " Can be used multiple times."
+        ),
+    ),
+    secret: Optional[list[str]] = typer.Option(
+        default=None,
+        help=("Name of a `modal.Secret` to mount inside the shell (if not using REF). Can be used multiple times."),
+    ),
     cpu: Optional[int] = typer.Option(default=None, help="Number of CPUs to allocate to the shell (if not using REF)."),
     memory: Optional[int] = typer.Option(
         default=None, help="Memory to allocate for the shell, in MiB (if not using REF)."
@@ -562,7 +598,8 @@ def shell(
     modal shell hello_world.py::my_function
     ```
 
-    Or, if you're using a [modal.Cls](/docs/reference/modal.Cls), you can refer to a `@modal.method` directly:
+    Or, if you're using a [modal.Cls](https://modal.com/docs/reference/modal.Cls)
+    you can refer to a `@modal.method` directly:
 
     ```
     modal shell hello_world.py::MyClass.my_method
@@ -579,6 +616,12 @@ def shell(
     ```
     modal shell hello_world.py -c 'uv pip list' > env.txt
     ```
+
+    Connect to a running Sandbox by ID:
+
+    ```
+    modal shell sb-abc123xyz
+    ```
     """
     env = ensure_env(env)
 
@@ -590,19 +633,28 @@ def shell(
 
     app = App("modal shell")
 
-    if container_or_function is not None:
+    if ref is not None:
+        # `modal shell` with a sandbox ID gets the task_id, that's then handled by the `ta-*` flow below.
+        if ref.startswith("sb-") and len(ref[3:]) > 0 and ref[3:].isalnum():
+            from ..sandbox import Sandbox
+
+            try:
+                sandbox = Sandbox.from_id(ref)
+                task_id = sandbox._get_task_id()
+                ref = task_id
+            except NotFoundError as e:
+                raise ClickException(f"Sandbox '{ref}' not found")
+            except Exception as e:
+                raise ClickException(f"Error connecting to sandbox '{ref}': {str(e)}")
+
         # `modal shell` with a container ID is a special case, alias for `modal container exec`.
-        if (
-            container_or_function.startswith("ta-")
-            and len(container_or_function[3:]) > 0
-            and container_or_function[3:].isalnum()
-        ):
+        if ref.startswith("ta-") and len(ref[3:]) > 0 and ref[3:].isalnum():
             from .container import exec
 
-            exec(container_id=container_or_function, command=shlex.split(cmd), pty=pty)
+            exec(container_id=ref, command=shlex.split(cmd), pty=pty)
             return
 
-        import_ref = parse_import_ref(container_or_function, use_module_mode=use_module_mode)
+        import_ref = parse_import_ref(ref, use_module_mode=use_module_mode)
         runnable, all_usable_commands = import_and_filter(
             import_ref, base_cmd="modal shell", accept_local_entrypoint=False, accept_webhook=True
         )
@@ -648,14 +700,30 @@ def shell(
     else:
         modal_image = Image.from_registry(image, add_python=add_python) if image else None
         volumes = {} if volume is None else {f"/mnt/{vol}": Volume.from_name(vol) for vol in volume}
+        secrets = [] if secret is None else [Secret.from_name(s) for s in secret]
+
+        mounts = []
+        if add_local:
+            for local_path_str in add_local:
+                local_path = Path(local_path_str).expanduser().resolve()
+                remote_path = PurePosixPath(f"/mnt/{local_path.name}")
+
+                if local_path.is_dir():
+                    m = _Mount._from_local_dir(local_path, remote_path=remote_path)
+                else:
+                    m = _Mount._from_local_file(local_path, remote_path=remote_path)
+                mounts.append(m)
+
         start_shell = partial(
             interactive_shell,
             image=modal_image,
+            mounts=mounts,
             cpu=cpu,
             memory=memory,
             gpu=gpu,
             cloud=cloud,
             volumes=volumes,
+            secrets=secrets,
             region=region.split(",") if region else [],
             pty=pty,
         )

modal/cli/secret.py

@@ -3,19 +3,19 @@ import json
 import os
 import platform
 import subprocess
+from datetime import datetime
 from pathlib import Path
 from tempfile import NamedTemporaryFile
 from typing import Optional
 
 import click
 import typer
-from rich.console import Console
 from rich.syntax import Syntax
-from typer import Argument
+from typer import Argument, Option
 
+from modal._output import make_console
 from modal._utils.async_utils import synchronizer
-from modal._utils.grpc_utils import retry_transient_errors
-from modal._utils.time_utils import timestamp_to_local
+from modal._utils.time_utils import timestamp_to_localized_str
 from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table
 from modal.client import _Client
 from modal.environments import ensure_env
@@ -30,20 +30,45 @@ secret_cli = typer.Typer(name="secret", help="Manage secrets.", no_args_is_help=
 async def list_(env: Optional[str] = ENV_OPTION, json: bool = False):
     env = ensure_env(env)
     client = await _Client.from_env()
-    response = await retry_transient_errors(client.stub.SecretList, api_pb2.SecretListRequest(environment_name=env))
-    column_names = ["Name", "Created at", "Last used at"]
-    rows = []
 
-    for item in response.items:
+    items: list[api_pb2.SecretListItem] = []
+
+    # Note that we need to continue using the gRPC API directly here rather than using Secret.objects.list.
+    # There is some metadata that historically appears in the CLI output (last_used_at) that
+    # doesn't make sense to transmit as hydration metadata, because the value can change over time and
+    # the metadata retrieved at hydration time could get stale. Alternatively, we could rewrite this using
+    # only public API by sequentially retrieving the secrets and then querying their dynamic metadata, but
+    # that would require multiple round trips and would add lag to the CLI.
+    async def retrieve_page(created_before: float) -> bool:
+        max_page_size = 100
+        pagination = api_pb2.ListPagination(max_objects=max_page_size, created_before=created_before)
+        req = api_pb2.SecretListRequest(environment_name=env, pagination=pagination)
+        resp = await client.stub.SecretList(req)
+        items.extend(resp.items)
+        return len(resp.items) < max_page_size
+
+    finished = await retrieve_page(datetime.now().timestamp())
+    while True:
+        if finished:
+            break
+        finished = await retrieve_page(items[-1].metadata.creation_info.created_at)
+
+    secrets = [_Secret._new_hydrated(item.secret_id, client, item.metadata, is_another_app=True) for item in items]
+
+    rows = []
+    for obj, resp_data in zip(secrets, items):
+        info = await obj.info()
         rows.append(
             [
-                item.label,
-                timestamp_to_local(item.created_at, json),
-                timestamp_to_local(item.last_used_at, json) if item.last_used_at else "-",
+                obj.name,
+                timestamp_to_localized_str(info.created_at.timestamp(), json),
+                info.created_by,
+                timestamp_to_localized_str(resp_data.last_used_at, json) if resp_data.last_used_at else "-",
             ]
         )
 
     env_part = f" in environment '{env}'" if env else ""
+    column_names = ["Name", "Created at", "Created by", "Last used at"]
     display_table(column_names, rows, json, title=f"Secrets{env_part}")
 
 
@@ -114,10 +139,14 @@ modal secret create my-credentials username=john password="$PASSWORD"
             raise click.UsageError(f"Non-string value for secret '{k}'")
 
     # Create secret
-    await _Secret.create_deployed(secret_name, env_dict, overwrite=force)
+    if force:
+        # TODO migrate this path once we support Secret.update()?
+        await _Secret._create_deployed(secret_name, env_dict, overwrite=force)
+    else:
+        await _Secret.objects.create(secret_name, env_dict)
 
     # Print code sample
-    console = Console()
+    console = make_console()
     env_var_code = "\n    ".join(f'os.getenv("{name}")' for name in env_dict.keys()) if env_dict else "..."
     example_code = f"""
 @app.function(secrets=[modal.Secret.from_name("{secret_name}")])
@@ -132,26 +161,23 @@ def some_function():
     console.print(Syntax(example_code, "python"))
 
 
-@secret_cli.command("delete", help="Delete a named secret.")
+@secret_cli.command("delete", help="Delete a named Secret.")
 @synchronizer.create_blocking
 async def delete(
-    secret_name: str = Argument(help="Name of the modal.Secret to be deleted. Case sensitive"),
+    name: str = Argument(help="Name of the modal.Secret to be deleted. Case sensitive"),
+    *,
+    allow_missing: bool = Option(False, "--allow-missing", help="Don't error if the Secret doesn't exist."),
     yes: bool = YES_OPTION,
     env: Optional[str] = ENV_OPTION,
 ):
-    """TODO"""
     env = ensure_env(env)
-    secret = await _Secret.from_name(secret_name, environment_name=env).hydrate()
     if not yes:
         typer.confirm(
-            f"Are you sure you want to irrevocably delete the modal.Secret '{secret_name}'?",
+            f"Are you sure you want to irrevocably delete the modal.Secret '{name}'?",
             default=False,
             abort=True,
         )
-    client = await _Client.from_env()
-
-    # TODO: replace with API on `modal.Secret` when we add it
-    await client.stub.SecretDelete(api_pb2.SecretDeleteRequest(secret_id=secret.object_id))
+    await _Secret.objects.delete(name, environment_name=env, allow_missing=allow_missing)
 
 
 def get_text_from_editor(key) -> str:

modal/cli/token.py

@@ -28,13 +28,7 @@ verify_option = typer.Option(
 )
 
 
-@token_cli.command(
-    name="set",
-    help=(
-        "Set account credentials for connecting to Modal. "
-        "If not provided with the command, you will be prompted to enter your credentials."
-    ),
-)
+@token_cli.command(name="set")
 @synchronizer.create_blocking
 async def set(
     token_id: Optional[str] = typer.Option(None, help="Account token ID."),
@@ -43,6 +37,10 @@ async def set(
     activate: bool = activate_option,
     verify: bool = verify_option,
 ):
+    """Set account credentials for connecting to Modal.
+
+    If the credentials are not provided on the command line, you will be prompted to enter them.
+    """
     if token_id is None:
         token_id = getpass.getpass("Token ID:")
     if token_secret is None:
@@ -50,7 +48,7 @@ async def set(
     await _set_token(token_id, token_secret, profile=profile, activate=activate, verify=verify)
 
 
-@token_cli.command(name="new", help="Create a new token by using an authenticated web session.")
+@token_cli.command(name="new")
 @synchronizer.create_blocking
 async def new(
     profile: Optional[str] = profile_option,
@@ -58,4 +56,5 @@ async def new(
     verify: bool = verify_option,
     source: Optional[str] = None,
 ):
+    """Create a new token by using an authenticated web session."""
     await _new_token(profile=profile, activate=activate, verify=verify, source=source)

modal/cli/utils.py

@@ -7,13 +7,12 @@ from typing import Optional, Union
 import typer
 from click import UsageError
 from grpclib import GRPCError, Status
-from rich.console import Console
 from rich.table import Column, Table
 from rich.text import Text
 
 from modal_proto import api_pb2
 
-from .._output import OutputManager, get_app_logs_loop
+from .._output import OutputManager, get_app_logs_loop, make_console
 from .._utils.async_utils import synchronizer
 from ..client import _Client
 from ..environments import ensure_env
@@ -48,9 +47,7 @@ async def get_app_id_from_name(name: str, env: Optional[str], client: Optional[_
     if client is None:
         client = await _Client.from_env()
     env_name = ensure_env(env)
-    request = api_pb2.AppGetByDeploymentNameRequest(
-        namespace=api_pb2.DEPLOYMENT_NAMESPACE_WORKSPACE, name=name, environment_name=env_name
-    )
+    request = api_pb2.AppGetByDeploymentNameRequest(name=name, environment_name=env_name)
     try:
         resp = await client.stub.AppGetByDeploymentName(request)
     except GRPCError as exc:
@@ -68,7 +65,7 @@ def _plain(text: Union[Text, str]) -> str:
 
 
 def is_tty() -> bool:
-    return Console().is_terminal
+    return make_console().is_terminal
 
 
 def display_table(
@@ -80,7 +77,7 @@ def display_table(
     def col_to_str(col: Union[Column, str]) -> str:
         return str(col.header) if isinstance(col, Column) else col
 
-    console = Console()
+    console = make_console()
     if json:
         json_data = [{col_to_str(col): _plain(row[i]) for i, col in enumerate(columns)} for row in rows]
         console.print_json(dumps(json_data))

modal/cli/volume.py

@@ -7,18 +7,15 @@ from typing import Optional
 import typer
 from click import UsageError
 from grpclib import GRPCError, Status
-from rich.console import Console
 from rich.syntax import Syntax
 from typer import Argument, Option, Typer
 
 import modal
-from modal._output import OutputManager, ProgressHandler
+from modal._output import OutputManager, ProgressHandler, make_console
 from modal._utils.async_utils import synchronizer
-from modal._utils.grpc_utils import retry_transient_errors
-from modal._utils.time_utils import timestamp_to_local
+from modal._utils.time_utils import timestamp_to_localized_str
 from modal.cli._download import _volume_download
 from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table
-from modal.client import _Client
 from modal.environments import ensure_env
 from modal.volume import _AbstractVolumeUploadContextManager, _Volume
 from modal_proto import api_pb2
@@ -57,14 +54,14 @@ def create(
     version: Optional[int] = Option(default=None, help="VolumeFS version. (Experimental)"),
 ):
     env_name = ensure_env(env)
-    modal.Volume.create_deployed(name, environment_name=env, version=version)
+    modal.Volume.objects.create(name, environment_name=env, version=version)
     usage_code = f"""
 @app.function(volumes={{"/my_vol": modal.Volume.from_name("{name}")}})
 def some_func():
     os.listdir("/my_vol")
 """
 
-    console = Console()
+    console = make_console()
     console.print(f"Created Volume '{name}' in environment '{env_name}'. \n\nCode example:\n")
     usage = Syntax(usage_code, "python")
     console.print(usage)
@@ -96,10 +93,16 @@ async def get(
     ensure_env(env)
     destination = Path(local_destination)
     volume = _Volume.from_name(volume_name, environment_name=env)
-    console = Console()
+    console = make_console()
     progress_handler = ProgressHandler(type="download", console=console)
     with progress_handler.live:
-        await _volume_download(volume, remote_path, destination, force, progress_cb=progress_handler.progress)
+        await _volume_download(
+            volume=volume,
+            remote_path=remote_path,
+            local_destination=destination,
+            overwrite=force,
+            progress_cb=progress_handler.progress,
+        )
     console.print(OutputManager.step_completed("Finished downloading files to local!"))
 
 
@@ -111,14 +114,13 @@ async def get(
 @synchronizer.create_blocking
 async def list_(env: Optional[str] = ENV_OPTION, json: Optional[bool] = False):
     env = ensure_env(env)
-    client = await _Client.from_env()
-    response = await retry_transient_errors(client.stub.VolumeList, api_pb2.VolumeListRequest(environment_name=env))
-    env_part = f" in environment '{env}'" if env else ""
-    column_names = ["Name", "Created at"]
+    volumes = await _Volume.objects.list(environment_name=env)
     rows = []
-    for item in response.items:
-        rows.append([item.label, timestamp_to_local(item.created_at, json)])
-    display_table(column_names, rows, json, title=f"Volumes{env_part}")
+    for obj in volumes:
+        info = await obj.info()
+        rows.append((info.name, timestamp_to_localized_str(info.created_at.timestamp(), json), info.created_by))
+
+    display_table(["Name", "Created at", "Created by"], rows, json)
 
 
 @volume_cli.command(
@@ -164,7 +166,7 @@ async def ls(
                 (
                     entry.path.encode("unicode_escape").decode("utf-8"),
                     filetype,
-                    timestamp_to_local(entry.mtime, False),
+                    timestamp_to_localized_str(entry.mtime, False),
                     humanize_filesize(entry.size),
                 )
             )
@@ -197,7 +199,7 @@ async def put(
 
     if remote_path.endswith("/"):
         remote_path = remote_path + os.path.basename(local_path)
-    console = Console()
+    console = make_console()
     progress_handler = ProgressHandler(type="upload", console=console)
 
     if Path(local_path).is_dir():
@@ -245,8 +247,10 @@ async def rm(
 ):
     ensure_env(env)
     volume = _Volume.from_name(volume_name, environment_name=env)
+    console = make_console()
     try:
         await volume.remove_file(remote_path, recursive=recursive)
+        console.print(OutputManager.step_completed(f"{remote_path} was deleted successfully!"))
     except GRPCError as exc:
         if exc.status in (Status.NOT_FOUND, Status.INVALID_ARGUMENT):
             raise UsageError(exc.message)
@@ -265,35 +269,37 @@ async def rm(
 async def cp(
     volume_name: str,
     paths: list[str],  # accepts multiple paths, last path is treated as destination path
+    recursive: bool = Option(False, "-r", "--recursive", help="Copy directories recursively"),
     env: Optional[str] = ENV_OPTION,
 ):
     ensure_env(env)
     volume = _Volume.from_name(volume_name, environment_name=env)
     *src_paths, dst_path = paths
-    await volume.copy_files(src_paths, dst_path)
+    await volume.copy_files(src_paths, dst_path, recursive)
 
 
 @volume_cli.command(
     name="delete",
-    help="Delete a named, persistent modal.Volume.",
+    help="Delete a named Volume and all of its data.",
     rich_help_panel="Management",
 )
 @synchronizer.create_blocking
 async def delete(
-    volume_name: str = Argument(help="Name of the modal.Volume to be deleted. Case sensitive"),
+    name: str = Argument(help="Name of the modal.Volume to be deleted. Case sensitive"),
+    *,
+    allow_missing: bool = Option(False, "--allow-missing", help="Don't error if the Volume doesn't exist."),
     yes: bool = YES_OPTION,
     env: Optional[str] = ENV_OPTION,
 ):
-    # Lookup first to validate the name, even though delete is a staticmethod
-    await _Volume.from_name(volume_name, environment_name=env).hydrate()
+    env = ensure_env(env)
     if not yes:
         typer.confirm(
-            f"Are you sure you want to irrevocably delete the modal.Volume '{volume_name}'?",
+            f"Are you sure you want to irrevocably delete the modal.Volume '{name}'?",
             default=False,
             abort=True,
         )
 
-    await _Volume.delete(volume_name, environment_name=env)
+    await _Volume.objects.delete(name, environment_name=env, allow_missing=allow_missing)
 
 
 @volume_cli.command(