modal 1.2.1.dev19__py3-none-any.whl → 1.2.2.dev21__py3-none-any.whl

modal/_utils/grpc_utils.py

@@ -8,12 +8,8 @@ import typing
 import urllib.parse
 import uuid
 from collections.abc import AsyncIterator
-from dataclasses import dataclass
-from typing import (
-    Any,
-    Optional,
-    TypeVar,
-)
+from dataclasses import dataclass, field
+from typing import Any, Optional, TypeVar
 
 import grpclib.client
 import grpclib.config
@@ -28,6 +24,7 @@ from grpclib.protocol import H2Protocol
 from modal.exception import AuthError, ConnectionError
 from modal_version import __version__
 
+from .._traceback import suppress_tb_frames
 from .async_utils import retry
 from .logger import logger
 
@@ -35,6 +32,7 @@ RequestType = TypeVar("RequestType", bound=Message)
 ResponseType = TypeVar("ResponseType", bound=Message)
 
 if typing.TYPE_CHECKING:
+    import modal._grpc_client
     import modal.client
 
 # Monkey patches grpclib to have a Modal User Agent header.
@@ -165,7 +163,7 @@ if typing.TYPE_CHECKING:
 
 
 async def unary_stream(
-    method: "modal.client.UnaryStreamWrapper[RequestType, ResponseType]",
+    method: "modal._grpc_client.UnaryStreamWrapper[RequestType, ResponseType]",
     request: RequestType,
     metadata: Optional[Any] = None,
 ) -> AsyncIterator[ResponseType]:
@@ -174,37 +172,66 @@ async def unary_stream(
         yield item
 
 
+@dataclass(frozen=True)
+class Retry:
+    base_delay: float = 0.1
+    max_delay: float = 1
+    delay_factor: float = 2
+    max_retries: Optional[int] = 3
+    additional_status_codes: list = field(default_factory=list)
+    attempt_timeout: Optional[float] = None  # timeout for each attempt
+    total_timeout: Optional[float] = None  # timeout for the entire function call
+    attempt_timeout_floor: float = 2.0  # always have at least this much timeout (only for total_timeout)
+    warning_message: Optional[RetryWarningMessage] = None
+
+
 async def retry_transient_errors(
-    fn: "modal.client.UnaryUnaryWrapper[RequestType, ResponseType]",
-    *args,
-    base_delay: float = 0.1,
-    max_delay: float = 1,
-    delay_factor: float = 2,
+    fn: "grpclib.client.UnaryUnaryMethod[RequestType, ResponseType]",
+    req: RequestType,
     max_retries: Optional[int] = 3,
-    additional_status_codes: list = [],
-    attempt_timeout: Optional[float] = None,  # timeout for each attempt
-    total_timeout: Optional[float] = None,  # timeout for the entire function call
-    attempt_timeout_floor=2.0,  # always have at least this much timeout (only for total_timeout)
-    retry_warning_message: Optional[RetryWarningMessage] = None,
-    metadata: list[tuple[str, str]] = [],
+) -> ResponseType:
+    """Minimum API version of _retry_transient_errors that works with grpclib.client.UnaryUnaryMethod.
+
+    Used by modal server.
+    """
+    return await _retry_transient_errors(fn, req, retry=Retry(max_retries=max_retries))
+
+
+async def _retry_transient_errors(
+    fn: typing.Union[
+        "modal._grpc_client.UnaryUnaryWrapper[RequestType, ResponseType]",
+        "grpclib.client.UnaryUnaryMethod[RequestType, ResponseType]",
+    ],
+    req: RequestType,
+    retry: Retry,
+    metadata: Optional[list[tuple[str, str]]] = None,
 ) -> ResponseType:
     """Retry on transient gRPC failures with back-off until max_retries is reached.
     If max_retries is None, retry forever."""
+    import modal._grpc_client
+
+    if isinstance(fn, modal._grpc_client.UnaryUnaryWrapper):
+        fn_callable = fn.direct
+    elif isinstance(fn, grpclib.client.UnaryUnaryMethod):
+        fn_callable = fn  # type: ignore
+    else:
+        raise ValueError("Only modal._grpc_client.UnaryUnaryWrapper and grpclib.client.UnaryUnaryMethod are supported")
 
-    delay = base_delay
+    delay = retry.base_delay
     n_retries = 0
 
-    status_codes = [*RETRYABLE_GRPC_STATUS_CODES, *additional_status_codes]
+    status_codes = [*RETRYABLE_GRPC_STATUS_CODES, *retry.additional_status_codes]
 
     idempotency_key = str(uuid.uuid4())
 
     t0 = time.time()
-    if total_timeout is not None:
-        total_deadline = t0 + total_timeout
+    if retry.total_timeout is not None:
+        total_deadline = t0 + retry.total_timeout
     else:
         total_deadline = None
 
-    metadata = metadata + [("x-modal-timestamp", str(time.time()))]
+    metadata = (metadata or []) + [("x-modal-timestamp", str(time.time()))]
+
     while True:
         attempt_metadata = [
             ("x-idempotency-key", idempotency_key),
@@ -214,16 +241,17 @@ async def retry_transient_errors(
         if n_retries > 0:
             attempt_metadata.append(("x-retry-delay", str(time.time() - t0)))
         timeouts = []
-        if attempt_timeout is not None:
-            timeouts.append(attempt_timeout)
-        if total_timeout is not None:
-            timeouts.append(max(total_deadline - time.time(), attempt_timeout_floor))
+        if retry.attempt_timeout is not None:
+            timeouts.append(retry.attempt_timeout)
+        if retry.total_timeout is not None and total_deadline is not None:
+            timeouts.append(max(total_deadline - time.time(), retry.attempt_timeout_floor))
         if timeouts:
             timeout = min(timeouts)  # In case the function provided both types of timeouts
         else:
             timeout = None
         try:
-            return await fn(*args, metadata=attempt_metadata, timeout=timeout)
+            with suppress_tb_frames(1):
+                return await fn_callable(req, metadata=attempt_metadata, timeout=timeout)
         except (StreamTerminatedError, GRPCError, OSError, asyncio.TimeoutError, AttributeError) as exc:
             if isinstance(exc, GRPCError) and exc.status not in status_codes:
                 if exc.status == Status.UNAUTHENTICATED:
@@ -231,45 +259,46 @@ async def retry_transient_errors(
                 else:
                     raise exc
 
-            if max_retries is not None and n_retries >= max_retries:
+            if retry.max_retries is not None and n_retries >= retry.max_retries:
                 final_attempt = True
-            elif total_deadline is not None and time.time() + delay + attempt_timeout_floor >= total_deadline:
+            elif total_deadline is not None and time.time() + delay + retry.attempt_timeout_floor >= total_deadline:
                 final_attempt = True
             else:
                 final_attempt = False
 
-            if final_attempt:
-                logger.debug(
-                    f"Final attempt failed with {repr(exc)} {n_retries=} {delay=} "
-                    f"{total_deadline=} for {fn.name} ({idempotency_key[:8]})"
-                )
-                if isinstance(exc, OSError):
-                    raise ConnectionError(str(exc))
-                elif isinstance(exc, asyncio.TimeoutError):
-                    raise ConnectionError(str(exc))
-                else:
+            with suppress_tb_frames(1):
+                if final_attempt:
+                    logger.debug(
+                        f"Final attempt failed with {repr(exc)} {n_retries=} {delay=} "
+                        f"{total_deadline=} for {fn.name} ({idempotency_key[:8]})"
+                    )
+                    if isinstance(exc, OSError):
+                        raise ConnectionError(str(exc))
+                    elif isinstance(exc, asyncio.TimeoutError):
+                        raise ConnectionError(str(exc))
+                    else:
+                        raise exc
+
+                if isinstance(exc, AttributeError) and "_write_appdata" not in str(exc):
+                    # StreamTerminatedError are not properly raised in grpclib<=0.4.7
+                    # fixed in https://github.com/vmagamedov/grpclib/issues/185
+                    # TODO: update to newer version (>=0.4.8) once stable
                     raise exc
 
-            if isinstance(exc, AttributeError) and "_write_appdata" not in str(exc):
-                # StreamTerminatedError are not properly raised in grpclib<=0.4.7
-                # fixed in https://github.com/vmagamedov/grpclib/issues/185
-                # TODO: update to newer version (>=0.4.8) once stable
-                raise exc
-
             logger.debug(f"Retryable failure {repr(exc)} {n_retries=} {delay=} for {fn.name} ({idempotency_key[:8]})")
 
             n_retries += 1
 
             if (
-                retry_warning_message
-                and n_retries % retry_warning_message.warning_interval == 0
+                retry.warning_message
+                and n_retries % retry.warning_message.warning_interval == 0
                 and isinstance(exc, GRPCError)
-                and exc.status in retry_warning_message.errors_to_warn_for
+                and exc.status in retry.warning_message.errors_to_warn_for
             ):
-                logger.warning(retry_warning_message.message)
+                logger.warning(retry.warning_message.message)
 
             await asyncio.sleep(delay)
-            delay = min(delay * delay_factor, max_delay)
+            delay = min(delay * retry.delay_factor, retry.max_delay)
 
 
 def find_free_port() -> int:

modal/_utils/mount_utils.py

@@ -3,7 +3,9 @@ import posixpath
 import typing
 from collections.abc import Mapping, Sequence
 from pathlib import PurePath, PurePosixPath
-from typing import Union
+from typing import Optional, Union
+
+from typing_extensions import TypeGuard
 
 from ..cloud_bucket_mount import _CloudBucketMount
 from ..exception import InvalidError
@@ -76,3 +78,26 @@ def validate_volumes(
             )
 
     return validated_volumes
+
+
+def validate_only_modal_volumes(
+    volumes: Optional[Optional[dict[Union[str, PurePosixPath], _Volume]]],
+    caller_name: str,
+) -> Sequence[tuple[str, _Volume]]:
+    """Validate all volumes are `modal.Volume`."""
+    if volumes is None:
+        return []
+
+    validated_volumes = validate_volumes(volumes)
+
+    # Although the typing forbids `_CloudBucketMount` for type checking, one can still pass a `_CloudBucketMount`
+    # during runtime, so we'll check the type here.
+    def all_modal_volumes(
+        vols: Sequence[tuple[str, Union[_Volume, _CloudBucketMount]]],
+    ) -> TypeGuard[Sequence[tuple[str, _Volume]]]:
+        return all(isinstance(v, _Volume) for _, v in vols)
+
+    if not all_modal_volumes(validated_volumes):
+        raise InvalidError(f"{caller_name} only supports volumes that are modal.Volume")
+
+    return validated_volumes

modal/_utils/task_command_router_client.py

@@ -18,7 +18,7 @@ from modal.exception import ExecTimeoutError
 from modal_proto import api_pb2, task_command_router_pb2 as sr_pb2
 from modal_proto.task_command_router_grpc import TaskCommandRouterStub
 
-from .grpc_utils import RETRYABLE_GRPC_STATUS_CODES, connect_channel, retry_transient_errors
+from .grpc_utils import RETRYABLE_GRPC_STATUS_CODES, connect_channel
 
 
 def _b64url_decode(data: str) -> bytes:
@@ -99,8 +99,7 @@ async def call_with_retries_on_transient_errors(
 
 async def fetch_command_router_access(server_client, task_id: str) -> api_pb2.TaskGetCommandRouterAccessResponse:
     """Fetch direct command router access info from Modal server."""
-    return await retry_transient_errors(
-        server_client.stub.TaskGetCommandRouterAccess,
+    return await server_client.stub.TaskGetCommandRouterAccess(
         api_pb2.TaskGetCommandRouterAccessRequest(task_id=task_id),
     )
 
@@ -444,7 +443,7 @@ class TaskCommandRouterClient:
             except Exception as e:
                 # Exceptions here can stem from non-transient errors against the server sending
                 # the TaskGetCommandRouterAccess RPC, for instance, if the task has finished.
-                logger.warning(f"Background JWT refresh failed for exec with task ID {self._task_id}: {e}")
+                logger.debug(f"Background JWT refresh failed for exec with task ID {self._task_id}: {e}")
                 break
 
     async def _stream_stdio(

modal/app.py

@@ -35,7 +35,6 @@ from ._utils.deprecation import (
     warn_on_renamed_autoscaler_settings,
 )
 from ._utils.function_utils import FunctionInfo, is_flash_object, is_global_object, is_method_fn
-from ._utils.grpc_utils import retry_transient_errors
 from ._utils.mount_utils import validate_volumes
 from ._utils.name_utils import check_object_name, check_tag_dict
 from .client import _Client
@@ -303,7 +302,7 @@ class _App:
             object_creation_type=(api_pb2.OBJECT_CREATION_TYPE_CREATE_IF_MISSING if create_if_missing else None),
         )
 
-        response = await retry_transient_errors(client.stub.AppGetOrCreate, request)
+        response = await client.stub.AppGetOrCreate(request)
 
         app = _App(name)  # TODO: this should probably be a distinct constructor, possibly even a distinct type
         app._local_state_attr = None  # this is not a locally defined App, so no local state
@@ -1183,7 +1182,7 @@ class _App:
         req = api_pb2.AppSetTagsRequest(app_id=self._app_id, tags=tags)
 
         client = client or self._client or await _Client.from_env()
-        await retry_transient_errors(client.stub.AppSetTags, req)
+        await client.stub.AppSetTags(req)
 
     async def get_tags(self, *, client: Optional[_Client] = None) -> dict[str, str]:
         """Get the tags that are currently attached to the App."""
@@ -1191,7 +1190,7 @@ class _App:
             raise InvalidError("`App.get_tags` cannot be called before the App is running.")
         req = api_pb2.AppGetTagsRequest(app_id=self._app_id)
         client = client or self._client or await _Client.from_env()
-        resp = await retry_transient_errors(client.stub.AppGetTags, req)
+        resp = await client.stub.AppGetTags(req)
         return dict(resp.tags)
 
     async def _logs(self, client: Optional[_Client] = None) -> AsyncGenerator[str, None]:

modal/cli/config.py

@@ -1,4 +1,6 @@
 # Copyright Modal Labs 2022
+import json
+
 import typer
 
 from modal._output import make_console
@@ -25,7 +27,7 @@ def show(redact: bool = typer.Option(True, help="Redact the `token_secret` value
         config_dict["token_secret"] = "***"
 
     console = make_console()
-    console.print(config_dict)
+    console.print_json(json.dumps(config_dict))
 
 
 SET_DEFAULT_ENV_HELP = """Set the default Modal environment for the active profile

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
@@ -97,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/entry_point.py

@@ -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.
 

modal/cli/launch.py

@@ -23,8 +23,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.
     """,
 )
 

modal/cli/network_file_system.py

@@ -15,7 +15,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 +32,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 = []

modal/cli/queues.py

@@ -8,7 +8,6 @@ from typer import Argument, Option, Typer
 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
@@ -83,7 +82,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/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
 

modal/client.py

@@ -6,32 +6,24 @@ import sys
 import urllib.parse
 import warnings
 from collections.abc import AsyncGenerator, AsyncIterator, Collection, Mapping
-from typing import (
-    Any,
-    ClassVar,
-    Generic,
-    Optional,
-    TypeVar,
-    Union,
-)
+from typing import Any, ClassVar, Optional, TypeVar, Union
 
 import grpclib.client
 from google.protobuf import empty_pb2
 from google.protobuf.message import Message
-from grpclib import GRPCError, Status
 from synchronicity.async_wrap import asynccontextmanager
 
 from modal._utils.async_utils import synchronizer
 from modal_proto import api_grpc, api_pb2, modal_api_grpc
 from modal_version import __version__
 
-from ._traceback import print_server_warnings, suppress_tb_frames
+from ._traceback import print_server_warnings
 from ._utils import async_utils
 from ._utils.async_utils import TaskContext, synchronize_api
 from ._utils.auth_token_manager import _AuthTokenManager
-from ._utils.grpc_utils import ConnectionManager, retry_transient_errors
+from ._utils.grpc_utils import ConnectionManager
 from .config import _check_config, _is_remote, config, logger
-from .exception import AuthError, ClientClosed, NotFoundError
+from .exception import AuthError, ClientClosed
 
 HEARTBEAT_INTERVAL: float = config.get("heartbeat_interval")
 HEARTBEAT_TIMEOUT: float = HEARTBEAT_INTERVAL + 0.1
@@ -159,7 +151,7 @@ class _Client:
     async def hello(self):
         """Connect to server and retrieve version information; raise appropriate error for various failures."""
         logger.debug(f"Client ({id(self)}): Starting")
-        resp = await retry_transient_errors(self.stub.ClientHello, empty_pb2.Empty())
+        resp = await self.stub.ClientHello(empty_pb2.Empty())
         print_server_warnings(resp.server_warnings)
 
     async def __aenter__(self):
@@ -362,105 +354,3 @@ class _Client:
 
 
 Client = synchronize_api(_Client)
-
-
-class grpc_error_converter:
-    def __enter__(self):
-        pass
-
-    def __exit__(self, exc_type, exc, traceback) -> bool:
-        # skip all internal frames from grpclib
-        use_full_traceback = config.get("traceback")
-        with suppress_tb_frames(1):
-            if isinstance(exc, GRPCError):
-                if exc.status == Status.NOT_FOUND:
-                    if use_full_traceback:
-                        raise NotFoundError(exc.message)
-                    else:
-                        raise NotFoundError(exc.message) from None  # from None to skip the grpc-internal cause
-
-                if not use_full_traceback:
-                    # just include the frame in grpclib that actually raises the GRPCError
-                    tb = exc.__traceback__
-                    while tb.tb_next:
-                        tb = tb.tb_next
-                    exc.with_traceback(tb)
-                    raise exc from None  # from None to skip the grpc-internal cause
-                raise exc
-
-        return False
-
-
-class UnaryUnaryWrapper(Generic[RequestType, ResponseType]):
-    # Calls a grpclib.UnaryUnaryMethod using a specific Client instance, respecting
-    # if that client is closed etc. and possibly introducing Modal-specific retry logic
-    wrapped_method: grpclib.client.UnaryUnaryMethod[RequestType, ResponseType]
-    client: _Client
-
-    def __init__(
-        self,
-        wrapped_method: grpclib.client.UnaryUnaryMethod[RequestType, ResponseType],
-        client: _Client,
-        server_url: str,
-    ):
-        self.wrapped_method = wrapped_method
-        self.client = client
-        self.server_url = server_url
-
-    @property
-    def name(self) -> str:
-        return self.wrapped_method.name
-
-    async def __call__(
-        self,
-        req: RequestType,
-        *,
-        timeout: Optional[float] = None,
-        metadata: Optional[_MetadataLike] = None,
-    ) -> ResponseType:
-        if self.client._snapshotted:
-            logger.debug(f"refreshing client after snapshot for {self.name.rsplit('/', 1)[1]}")
-            self.client = await _Client.from_env()
-
-        # Note: We override the grpclib method's channel (see grpclib's code [1]). I think this is fine
-        # since grpclib's code doesn't seem to change very much, but we could also recreate the
-        # grpclib stub if we aren't comfortable with this. The downside is then we need to cache
-        # the grpclib stub so the rest of our code becomes a bit more complicated.
-        #
-        # We need to override the channel because after the process is forked or the client is
-        # snapshotted, the existing channel may be stale / unusable.
-        #
-        # [1]: https://github.com/vmagamedov/grpclib/blob/62f968a4c84e3f64e6966097574ff0a59969ea9b/grpclib/client.py#L844
-        self.wrapped_method.channel = await self.client._get_channel(self.server_url)
-        with suppress_tb_frames(1), grpc_error_converter():
-            return await self.client._call_unary(self.wrapped_method, req, timeout=timeout, metadata=metadata)
-
-
-class UnaryStreamWrapper(Generic[RequestType, ResponseType]):
-    wrapped_method: grpclib.client.UnaryStreamMethod[RequestType, ResponseType]
-
-    def __init__(
-        self,
-        wrapped_method: grpclib.client.UnaryStreamMethod[RequestType, ResponseType],
-        client: _Client,
-        server_url: str,
-    ):
-        self.wrapped_method = wrapped_method
-        self.client = client
-        self.server_url = server_url
-
-    @property
-    def name(self) -> str:
-        return self.wrapped_method.name
-
-    async def unary_stream(
-        self,
-        request,
-        metadata: Optional[Any] = None,
-    ):
-        if self.client._snapshotted:
-            logger.debug(f"refreshing client after snapshot for {self.name.rsplit('/', 1)[1]}")
-            self.client = await _Client.from_env()
-        self.wrapped_method.channel = await self.client._get_channel(self.server_url)
-        async for response in self.client._call_stream(self.wrapped_method, request, metadata=metadata):
-            yield response