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

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

modal/client.pyi

@@ -33,7 +33,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.1.dev8",
+        version: str = "1.2.2.dev19",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -164,7 +164,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.1.dev8",
+        version: str = "1.2.2.dev19",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -339,95 +339,6 @@ class Client:
         ],
     ) -> collections.abc.AsyncGenerator[typing.Any, None]: ...
 
-class grpc_error_converter:
-    def __enter__(self): ...
-    def __exit__(self, exc_type, exc, traceback) -> bool: ...
-
-class UnaryUnaryWrapper(typing.Generic[RequestType, ResponseType]):
-    """Abstract base class for generic types.
-
-    A generic type is typically declared by inheriting from
-    this class parameterized with one or more type variables.
-    For example, a generic mapping type might be defined as::
-
-      class Mapping(Generic[KT, VT]):
-          def __getitem__(self, key: KT) -> VT:
-              ...
-          # Etc.
-
-    This class can then be used as follows::
-
-      def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
-          try:
-              return mapping[key]
-          except KeyError:
-              return default
-    """
-
-    wrapped_method: grpclib.client.UnaryUnaryMethod[RequestType, ResponseType]
-    client: _Client
-
-    def __init__(
-        self,
-        wrapped_method: grpclib.client.UnaryUnaryMethod[RequestType, ResponseType],
-        client: _Client,
-        server_url: str,
-    ):
-        """Initialize self.  See help(type(self)) for accurate signature."""
-        ...
-
-    @property
-    def name(self) -> str: ...
-    async def __call__(
-        self,
-        req: RequestType,
-        *,
-        timeout: typing.Optional[float] = None,
-        metadata: typing.Union[
-            collections.abc.Mapping[str, typing.Union[str, bytes]],
-            collections.abc.Collection[tuple[str, typing.Union[str, bytes]]],
-            None,
-        ] = None,
-    ) -> ResponseType:
-        """Call self as a function."""
-        ...
-
-class UnaryStreamWrapper(typing.Generic[RequestType, ResponseType]):
-    """Abstract base class for generic types.
-
-    A generic type is typically declared by inheriting from
-    this class parameterized with one or more type variables.
-    For example, a generic mapping type might be defined as::
-
-      class Mapping(Generic[KT, VT]):
-          def __getitem__(self, key: KT) -> VT:
-              ...
-          # Etc.
-
-    This class can then be used as follows::
-
-      def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
-          try:
-              return mapping[key]
-          except KeyError:
-              return default
-    """
-
-    wrapped_method: grpclib.client.UnaryStreamMethod[RequestType, ResponseType]
-
-    def __init__(
-        self,
-        wrapped_method: grpclib.client.UnaryStreamMethod[RequestType, ResponseType],
-        client: _Client,
-        server_url: str,
-    ):
-        """Initialize self.  See help(type(self)) for accurate signature."""
-        ...
-
-    @property
-    def name(self) -> str: ...
-    def unary_stream(self, request, metadata: typing.Optional[typing.Any] = None): ...
-
 HEARTBEAT_INTERVAL: float
 
 HEARTBEAT_TIMEOUT: float

modal/cls.py

@@ -30,7 +30,6 @@ from ._utils.deprecation import (
     warn_if_passing_namespace,
     warn_on_renamed_autoscaler_settings,
 )
-from ._utils.grpc_utils import retry_transient_errors
 from ._utils.mount_utils import validate_volumes
 from .cloud_bucket_mount import _CloudBucketMount
 from .config import config
@@ -643,7 +642,7 @@ More information on class parameterization can be found here: https://modal.com/
                 only_class_function=True,
             )
             try:
-                response = await retry_transient_errors(resolver.client.stub.ClassGet, request)
+                response = await resolver.client.stub.ClassGet(request)
             except NotFoundError as exc:
                 env_context = f" (in the '{environment_name}' environment)" if environment_name else ""
                 raise NotFoundError(

modal/config.py

@@ -147,7 +147,7 @@ async def _lookup_workspace(server_url: str, token_id: str, token_secret: str) -
 
     credentials = (token_id, token_secret)
     async with _Client(server_url, api_pb2.CLIENT_TYPE_CLIENT, credentials) as client:
-        return await client.stub.WorkspaceNameLookup(Empty(), timeout=3)
+        return await client.stub.WorkspaceNameLookup(Empty(), retry=None, timeout=3)
 
 
 def config_profiles():
@@ -247,6 +247,8 @@ _SETTINGS = {
     "traceback": _Setting(False, transform=_to_boolean),
     "image_builder_version": _Setting(),
     "strict_parameters": _Setting(False, transform=_to_boolean),  # For internal/experimental use
+    # Allow insecure TLS for the task command router when running locally (testing/dev only)
+    "task_command_router_insecure": _Setting(False, transform=_to_boolean),
     "snapshot_debug": _Setting(False, transform=_to_boolean),
     "cuda_checkpoint_path": _Setting("/__modal/.bin/cuda-checkpoint"),  # Used for snapshotting GPU memory.
     "build_validation": _Setting("error", transform=_check_value(["error", "warn", "ignore"])),