modal 1.1.5.dev66__py3-none-any.whl → 1.3.1.dev8__py3-none-any.whl

modal/cli/container.py

@@ -7,7 +7,6 @@ from rich.text import Text
 from modal._object import _get_environment_name
 from modal._pty import get_pty_info
 from modal._utils.async_utils import synchronizer
-from modal._utils.grpc_utils import retry_transient_errors
 from modal._utils.time_utils import timestamp_to_localized_str
 from modal.cli.utils import ENV_OPTION, display_table, is_tty, stream_app_logs
 from modal.client import _Client
@@ -80,10 +79,12 @@ async def exec(
     res: api_pb2.ContainerExecResponse = await client.stub.ContainerExec(req)
 
     if pty:
-        await _ContainerProcess(res.exec_id, client).attach()
+        await _ContainerProcess(res.exec_id, container_id, client).attach()
     else:
         # TODO: redirect stderr to its own stream?
-        await _ContainerProcess(res.exec_id, client, stdout=StreamType.STDOUT, stderr=StreamType.STDOUT).wait()
+        await _ContainerProcess(
+            res.exec_id, container_id, client, stdout=StreamType.STDOUT, stderr=StreamType.STDOUT
+        ).wait()
 
 
 @container_cli.command("stop")
@@ -95,4 +96,4 @@ async def stop(container_id: str = typer.Argument(help="Container ID")):
     """
     client = await _Client.from_env()
     request = api_pb2.ContainerStopRequest(task_id=container_id)
-    await retry_transient_errors(client.stub.ContainerStop, request)
+    await client.stub.ContainerStop(request)

modal/cli/dict.py

@@ -4,6 +4,7 @@ from typing import Optional
 import typer
 from typer import Argument, Option, Typer
 
+from modal._load_context import LoadContext
 from modal._output import make_console
 from modal._resolver import Resolver
 from modal._utils.async_utils import synchronizer
@@ -29,8 +30,10 @@ async def create(name: str, *, env: Optional[str] = ENV_OPTION):
     """
     d = _Dict.from_name(name, environment_name=env, create_if_missing=True)
     client = await _Client.from_env()
-    resolver = Resolver(client=client)
-    await resolver.load(d)
+    resolver = Resolver()
+
+    load_context = LoadContext(client=client, environment_name=env)
+    await resolver.load(d, load_context)
 
 
 @dict_cli.command(name="list", rich_help_panel="Management")

modal/cli/entry_point.py

@@ -8,7 +8,7 @@ from rich.rule import Rule
 from modal._output import make_console
 from modal._utils.async_utils import synchronizer
 
-from . import run
+from . import run, shell as shell_module
 from .app import app_cli
 from .cluster import cluster_cli
 from .config import config_cli
@@ -36,6 +36,7 @@ entrypoint_cli_typer = typer.Typer(
     no_args_is_help=False,
     add_completion=False,
     rich_markup_mode="markdown",
+    context_settings={"help_option_names": ["-h", "--help"]},
     help="""
     Modal is the fastest way to run code in the cloud.
 
@@ -86,6 +87,29 @@ def check_path():
 async def setup(profile: Optional[str] = None):
     check_path()
 
+    art = """
+           #############        #############
+          ####         ##      ####         ##
+         ##  ##         ##    ##  ##         ##
+        ##    ##         ##  ##    ##         ##
+       ##      ##         ####      ##         ##
+      ##        #############        ##         ##
+     ##        ##         ####        ##         ##
+    ##        ##         ##  ##        ##         ##
+   ##        ##         ##    ##        ##         ##
+  ##        ##         ##      ##        ##         ##
+ ##        ##         ##        ##        ##         ##
+##        ##         ##          ##        #############
+ ##      ##         ##            ##      ##         ##
+  ##    ##         ##              ##    ##         ##
+   ##  ##         ##                ##  ##         ##
+    ####         ##                  ####         ##
+     #############                    #############
+"""
+
+    console = make_console()
+    console.print(art, style="green")
+
     # Fetch a new token (same as `modal token new` but redirect to /home once finishes)
     await _new_token(profile=profile, next_url="/home")
 
@@ -93,7 +117,7 @@ async def setup(profile: Optional[str] = None):
 # Commands
 entrypoint_cli_typer.command("deploy", no_args_is_help=True)(run.deploy)
 entrypoint_cli_typer.command("serve", no_args_is_help=True)(run.serve)
-entrypoint_cli_typer.command("shell")(run.shell)
+entrypoint_cli_typer.command("shell")(shell_module.shell)
 entrypoint_cli_typer.add_typer(launch_cli)
 
 # Deployments

modal/cli/environment.py

@@ -3,14 +3,12 @@ from typing import Annotated, Optional, Union
 
 import typer
 from click import UsageError
-from grpclib import GRPCError, Status
 from rich.text import Text
 
 from modal import environments
 from modal._utils.name_utils import check_environment_name
 from modal.cli.utils import YES_OPTION, display_table
 from modal.config import config
-from modal.exception import InvalidError
 
 ENVIRONMENT_HELP_TEXT = """Create and interact with Environments
 
@@ -61,13 +59,7 @@ ENVIRONMENT_CREATE_HELP = """Create a new environment in the current workspace""
 @environment_cli.command(name="create", help=ENVIRONMENT_CREATE_HELP)
 def create(name: Annotated[str, typer.Argument(help="Name of the new environment. Must be unique. Case sensitive")]):
     check_environment_name(name)
-
-    try:
-        environments.create_environment(name)
-    except GRPCError as exc:
-        if exc.status == Status.INVALID_ARGUMENT:
-            raise InvalidError(exc.message)
-        raise
+    environments.create_environment(name)
     typer.echo(f"Environment created: {name}")
 
 
@@ -114,11 +106,5 @@ def update(
     if set_name:
         check_environment_name(set_name)
 
-    try:
-        environments.update_environment(current_name, new_name=set_name, new_web_suffix=set_web_suffix)
-    except GRPCError as exc:
-        if exc.status == Status.INVALID_ARGUMENT:
-            raise InvalidError(exc.message)
-        raise
-
+    environments.update_environment(current_name, new_name=set_name, new_web_suffix=set_web_suffix)
     typer.echo("Environment updated")

modal/cli/launch.py

@@ -3,8 +3,6 @@ import asyncio
 import inspect
 import json
 import os
-import subprocess
-import tempfile
 from pathlib import Path
 from typing import Any, Optional
 
@@ -23,8 +21,7 @@ launch_cli = Typer(
     no_args_is_help=True,
     rich_markup_mode="markdown",
     help="""
-    Open a serverless app instance on Modal.
-    >⚠️  `modal launch` is **experimental** and may change in the future.
+    [Experimental] Open a serverless app instance on Modal.
     """,
 )
 
@@ -121,75 +118,3 @@ def vscode(
         "volume": volume,
     }
     _launch_program("vscode", "vscode.py", detach, args)
-
-
-@launch_cli.command(name="machine", help="Start an instance on Modal, with direct SSH access.", hidden=True)
-def machine(
-    name: str,  # Name of the machine App.
-    cpu: int = 8,  # Reservation of CPU cores (can burst above this value).
-    memory: int = 32768,  # Reservation of memory in MiB (can burst above this value).
-    gpu: Optional[str] = None,  # GPU type and count, e.g. "t4" or "h100:2".
-    image: Optional[str] = None,  # Image tag to use from registry. Defaults to the notebook base image.
-    timeout: int = 3600 * 24,  # Timeout in seconds for the instance.
-    volume: str = "machine-vol",  # Attach a persisted `modal.Volume` at /workspace (created if missing).
-):
-    tempdir = Path(tempfile.gettempdir())
-    key_path = tempdir / "modal-machine-keyfile.pem"
-    # Generate a new SSH key pair for this machine instance.
-    if not key_path.exists():
-        subprocess.run(
-            ["ssh-keygen", "-t", "ed25519", "-f", str(key_path), "-N", ""],
-            check=True,
-            stdout=subprocess.DEVNULL,
-        )
-    # Add the key with expiry 1d to ssh agent.
-    subprocess.run(
-        ["ssh-add", "-t", "1d", str(key_path)],
-        check=True,
-        stdout=subprocess.DEVNULL,
-        stderr=subprocess.DEVNULL,
-    )
-
-    os.environ["SSH_PUBLIC_KEY"] = Path(str(key_path) + ".pub").read_text()
-    os.environ["MODAL_LOGS_TIMEOUT"] = "0"  # hack to work with --detach
-
-    args = {
-        "cpu": cpu,
-        "memory": memory,
-        "gpu": gpu,
-        "image": image,
-        "timeout": timeout,
-        "volume": volume,
-    }
-    _launch_program(
-        "machine",
-        "launch_instance_ssh.py",
-        True,
-        args,
-        description=name,
-    )
-
-
-@launch_cli.command(name="marimo", help="Start a remote Marimo notebook on Modal.", hidden=True)
-def marimo(
-    cpu: int = 8,
-    memory: int = 32768,
-    gpu: Optional[str] = None,
-    image: str = "debian:12",
-    timeout: int = 3600,
-    add_python: Optional[str] = "3.12",
-    mount: Optional[str] = None,  # Create a `modal.Mount` from a local directory.
-    volume: Optional[str] = None,  # Attach a persisted `modal.Volume` by name (creating if missing).
-    detach: bool = False,  # Run the app in "detached" mode to persist after local client disconnects
-):
-    args = {
-        "cpu": cpu,
-        "memory": memory,
-        "gpu": gpu,
-        "timeout": timeout,
-        "image": image,
-        "add_python": add_python,
-        "mount": mount,
-        "volume": volume,
-    }
-    _launch_program("marimo", "run_marimo.py", detach, args)

modal/cli/network_file_system.py

@@ -6,7 +6,6 @@ from typing import Optional
 
 import typer
 from click import UsageError
-from grpclib import GRPCError, Status
 from rich.syntax import Syntax
 from rich.table import Table
 from typer import Argument, Typer
@@ -15,7 +14,6 @@ import modal
 from modal._location import display_location
 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_localized_str
 from modal.cli._download import _volume_download
 from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table
@@ -33,9 +31,7 @@ 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.SharedVolumeList, api_pb2.SharedVolumeListRequest(environment_name=env)
-    )
+    response = await client.stub.SharedVolumeList(api_pb2.SharedVolumeListRequest(environment_name=env))
     env_part = f" in environment '{env}'" if env else ""
     column_names = ["Name", "Location", "Created at"]
     rows = []
@@ -84,12 +80,7 @@ async def ls(
 ):
     ensure_env(env)
     volume = _NetworkFileSystem.from_name(volume_name)
-    try:
-        entries = await volume.listdir(path)
-    except GRPCError as exc:
-        if exc.status in (Status.INVALID_ARGUMENT, Status.NOT_FOUND):
-            raise UsageError(exc.message)
-        raise
+    entries = await volume.listdir(path)
 
     if sys.stdout.isatty():
         console = make_console()
@@ -105,7 +96,7 @@ async def ls(
         console.print(table)
     else:
         for entry in entries:
-            print(entry.path)
+            print(entry.path)  # noqa: T201
 
 
 @nfs_cli.command(
@@ -203,14 +194,8 @@ async def rm(
     ensure_env(env)
     volume = _NetworkFileSystem.from_name(volume_name)
     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)
-        raise
+    await volume.remove_file(remote_path, recursive=recursive)
+    console.print(OutputManager.step_completed(f"{remote_path} was deleted successfully!"))
 
 
 @nfs_cli.command(

modal/cli/programs/run_jupyter.py

@@ -54,7 +54,7 @@ def wait_for_port(url: str, q: Queue):
     cpu=args.get("cpu"),
     memory=args.get("memory"),
     gpu=args.get("gpu"),
-    timeout=args.get("timeout"),
+    timeout=args.get("timeout", 3600),
     secrets=[Secret.from_dict({"MODAL_LAUNCH_ARGS": json.dumps(args)})],
     volumes=volumes,
     max_containers=1 if volume else None,

modal/cli/programs/vscode.py

@@ -79,7 +79,7 @@ def wait_for_port(data: tuple[str, str], q: Queue):
     cpu=args.get("cpu"),
     memory=args.get("memory"),
     gpu=args.get("gpu"),
-    timeout=args.get("timeout"),
+    timeout=args.get("timeout", 3600),
     secrets=[Secret.from_dict({"MODAL_LAUNCH_ARGS": json.dumps(args)})],
     volumes=volumes,
     max_containers=1 if volume else None,

modal/cli/queues.py

@@ -5,10 +5,10 @@ from typing import Optional
 import typer
 from typer import Argument, Option, Typer
 
+from modal._load_context import LoadContext
 from modal._output import make_console
 from modal._resolver import Resolver
 from modal._utils.async_utils import synchronizer
-from modal._utils.grpc_utils import retry_transient_errors
 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
@@ -39,8 +39,9 @@ async def create(name: str, *, env: Optional[str] = ENV_OPTION):
     """
     q = _Queue.from_name(name, environment_name=env, create_if_missing=True)
     client = await _Client.from_env()
-    resolver = Resolver(client=client)
-    await resolver.load(q)
+    resolver = Resolver()
+    load_context = LoadContext(client=client, environment_name=env)
+    await resolver.load(q, load_context)
 
 
 @queue_cli.command(name="delete", rich_help_panel="Management")
@@ -83,7 +84,7 @@ async def list_(*, json: bool = False, env: Optional[str] = ENV_OPTION):
         max_page_size = 100
         pagination = api_pb2.ListPagination(max_objects=max_page_size, created_before=created_before)
         req = api_pb2.QueueListRequest(environment_name=env, pagination=pagination, total_size_limit=max_total_size)
-        resp = await retry_transient_errors(client.stub.QueueList, req)
+        resp = await client.stub.QueueList(req)
         items.extend(resp.queues)
         return len(resp.queues) < max_page_size
 

modal/cli/run.py

@@ -2,14 +2,11 @@
 import asyncio
 import functools
 import inspect
-import platform
 import re
-import shlex
 import sys
 import time
 import typing
 from dataclasses import dataclass
-from functools import partial
 from typing import Any, Callable, Optional
 
 import click
@@ -17,19 +14,15 @@ import typer
 from click import ClickException
 from typing_extensions import TypedDict
 
-from .._functions import _FunctionSpec
 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, NotFoundError, _CliUserExecutionError
+from ..exception import ExecutionError, InvalidError, _CliUserExecutionError
 from ..functions import Function
-from ..image import Image
 from ..output import enable_output
-from ..runner import deploy_app, interactive_shell, run_app
-from ..secret import Secret
+from ..runner import deploy_app, run_app
 from ..serving import serve_app
-from ..volume import Volume
 from .import_refs import (
     CLICommand,
     MethodReference,
@@ -38,7 +31,7 @@ from .import_refs import (
     import_app_from_ref,
     parse_import_ref,
 )
-from .utils import ENV_OPTION, ENV_OPTION_HELP, is_tty, stream_app_logs
+from .utils import ENV_OPTION, ENV_OPTION_HELP, stream_app_logs
 
 
 class ParameterMetadata(TypedDict):
@@ -136,7 +129,7 @@ def _add_click_options(func, parameters: dict[str, ParameterMetadata]):
 
         parser = option_parsers.get(param_type_str)
         if parser is None:
-            msg = f"Parameter `{param_name}` has unparseable annotation: {param['annotation']!r}"
+            msg = f"Parameter `{param_name}` has unparseable annotation: {param['annotation']}"
             raise NoParserAvailable(msg)
         kwargs: Any = {
             "type": parser,
@@ -207,11 +200,21 @@ def _make_click_function(app, signature: CliRunnableSignature, inner: Callable[[
     return f
 
 
+def _get_signature(func: typing.Any) -> inspect.Signature:
+    """Returns signature with the original source annotations."""
+    kwargs: dict[str, typing.Any] = {}
+    if sys.version_info[:2] >= (3, 14):
+        import annotationlib
+
+        kwargs["annotation_format"] = annotationlib.Format.STRING
+    return inspect.signature(func, **kwargs)
+
+
 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")
 
-    sig: inspect.Signature = inspect.signature(function.info.raw_f)
+    sig: inspect.Signature = _get_signature(function.info.raw_f)
     type_hints = safe_get_type_hints(function.info.raw_f)
     signature: CliRunnableSignature = _get_cli_runnable_signature(sig, type_hints)
 
@@ -260,7 +263,7 @@ def _get_click_command_for_cls(app: App, method_ref: MethodReference, ctx: click
 
     partial_function = partial_functions[method_name]
     raw_f = partial_function._get_raw_f()
-    sig_without_self = inspect.signature(functools.partial(raw_f, None))
+    sig_without_self = _get_signature(functools.partial(raw_f, None))
     fun_signature = _get_cli_runnable_signature(sig_without_self, safe_get_type_hints(raw_f))
 
     # TODO(erikbern): assert there's no overlap?
@@ -294,12 +297,12 @@ def _get_click_command_for_local_entrypoint(app: App, entrypoint: LocalEntrypoin
     func = entrypoint.info.raw_f
     isasync = inspect.iscoroutinefunction(func)
 
-    signature = _get_cli_runnable_signature(inspect.signature(func), safe_get_type_hints(func))
+    signature = _get_cli_runnable_signature(_get_signature(func), safe_get_type_hints(func))
 
     @click.pass_context
     def f(ctx, *args, **kwargs):
         if ctx.obj["detach"]:
-            print(
+            print(  # noqa: T201
                 "Note that running a local entrypoint in detached mode only keeps the last "
                 "triggered Modal function alive after the parent process has been killed or disconnected."
             )
@@ -496,6 +499,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)
@@ -513,192 +522,3 @@ def serve(
                 t = min(timeout, 3600)
                 time.sleep(t)
                 timeout -= t
-
-
-def shell(
-    ref: Optional[str] = typer.Argument(
-        default=None,
-        help=(
-            "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."
-        ),
-    ),
-    cmd: str = typer.Option("/bin/bash", "-c", "--cmd", help="Command to run inside the Modal image."),
-    env: str = ENV_OPTION,
-    image: Optional[str] = typer.Option(
-        default=None, help="Container image tag for inside the shell (if not using REF)."
-    ),
-    add_python: Optional[str] = typer.Option(default=None, help="Add Python to the image (if not using REF)."),
-    volume: Optional[list[str]] = typer.Option(
-        default=None,
-        help=(
-            "Name of a `modal.Volume` to mount inside the shell at `/mnt/{name}` (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)."
-    ),
-    gpu: Optional[str] = typer.Option(
-        default=None,
-        help="GPUs to request for the shell, if any. Examples are `any`, `a10g`, `a100:4` (if not using REF).",
-    ),
-    cloud: Optional[str] = typer.Option(
-        default=None,
-        help=(
-            "Cloud provider to run the shell on. Possible values are `aws`, `gcp`, `oci`, `auto` (if not using REF)."
-        ),
-    ),
-    region: Optional[str] = typer.Option(
-        default=None,
-        help=(
-            "Region(s) to run the container on. "
-            "Can be a single region or a comma-separated list to choose from (if not using REF)."
-        ),
-    ),
-    pty: Optional[bool] = typer.Option(default=None, help="Run the command using a PTY."),
-    use_module_mode: bool = typer.Option(
-        False, "-m", help="Interpret argument as a Python module path instead of a file/script path"
-    ),
-):
-    """Run a command or interactive shell inside a Modal container.
-
-    **Examples:**
-
-    Start an interactive shell inside the default Debian-based image:
-
-    ```
-    modal shell
-    ```
-
-    Start an interactive shell with the spec for `my_function` in your App
-    (uses the same image, volumes, mounts, etc.):
-
-    ```
-    modal shell hello_world.py::my_function
-    ```
-
-    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
-    ```
-
-    Start a `python` shell:
-
-    ```
-    modal shell hello_world.py --cmd=python
-    ```
-
-    Run a command with your function's spec and pipe the output to a file:
-
-    ```
-    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)
-
-    if pty is None:
-        pty = is_tty()
-
-    if platform.system() == "Windows":
-        raise InvalidError("`modal shell` is currently not supported on Windows")
-
-    app = App("modal shell")
-
-    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 ref.startswith("ta-") and len(ref[3:]) > 0 and ref[3:].isalnum():
-            from .container import exec
-
-            exec(container_id=ref, command=shlex.split(cmd), pty=pty)
-            return
-
-        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
-        )
-        if not runnable:
-            help_header = (
-                "Specify a Modal function to start a shell session for. E.g.\n"
-                f"> modal shell {import_ref.file_or_module}::my_function"
-            )
-
-            if all_usable_commands:
-                help_footer = f"The selected module '{import_ref.file_or_module}' has the following choices:\n\n"
-                help_footer += _get_runnable_list(all_usable_commands)
-            else:
-                help_footer = f"The selected module '{import_ref.file_or_module}' has no Modal functions or classes."
-
-            raise ClickException(f"{help_header}\n\n{help_footer}")
-
-        function_spec: _FunctionSpec
-        if isinstance(runnable, MethodReference):
-            # TODO: let users specify a class instead of a method, since they use the same environment
-            class_service_function = runnable.cls._get_class_service_function()
-            function_spec = class_service_function.spec
-        elif isinstance(runnable, Function):
-            function_spec = runnable.spec
-        else:
-            raise ValueError("Referenced entity is not a Modal function or class")
-
-        start_shell = partial(
-            interactive_shell,
-            image=function_spec.image,
-            mounts=function_spec.mounts,
-            secrets=function_spec.secrets,
-            network_file_systems=function_spec.network_file_systems,
-            gpu=function_spec.gpus,
-            cloud=function_spec.cloud,
-            cpu=function_spec.cpu,
-            memory=function_spec.memory,
-            volumes=function_spec.volumes,
-            region=function_spec.scheduler_placement.proto.regions if function_spec.scheduler_placement else None,
-            pty=pty,
-            proxy=function_spec.proxy,
-        )
-    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]
-        start_shell = partial(
-            interactive_shell,
-            image=modal_image,
-            cpu=cpu,
-            memory=memory,
-            gpu=gpu,
-            cloud=cloud,
-            volumes=volumes,
-            secrets=secrets,
-            region=region.split(",") if region else [],
-            pty=pty,
-        )
-
-    # NB: invoking under bash makes --cmd a lot more flexible.
-    cmds = shlex.split(f'/bin/bash -c "{cmd}"')
-    start_shell(app, cmds=cmds, environment_name=env, timeout=3600)

modal/cli/secret.py

@@ -15,7 +15,6 @@ 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_localized_str
 from modal.cli.utils import ENV_OPTION, YES_OPTION, display_table
 from modal.client import _Client
@@ -44,7 +43,7 @@ async def list_(env: Optional[str] = ENV_OPTION, json: bool = False):
         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 retry_transient_errors(client.stub.SecretList, req)
+        resp = await client.stub.SecretList(req)
         items.extend(resp.items)
         return len(resp.items) < max_page_size