modal 1.2.7.dev0__tar.gz → 1.2.7.dev2__tar.gz

{modal-1.2.7.dev0 → modal-1.2.7.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.2.7.dev0
+Version: 1.2.7.dev2
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License: Apache-2.0
@@ -13,7 +13,7 @@ Classifier: Topic :: System :: Distributed Computing
 Classifier: Operating System :: OS Independent
 Classifier: License :: OSI Approved :: Apache Software License
 Classifier: Programming Language :: Python :: 3
-Requires-Python: <3.14,>=3.9
+Requires-Python: <3.14,>=3.10
 Description-Content-Type: text/markdown
 License-File: LICENSE
 Requires-Dist: aiohttp
@@ -51,7 +51,7 @@ a [user guide](https://modal.com/docs/guide), and the detailed
 
 ## Installation
 
-**This library requires Python 3.9 – 3.13.**
+**This library requires Python 3.10 – 3.13.**
 
 Install the package with `uv` or `pip`:
 

{modal-1.2.7.dev0 → modal-1.2.7.dev2}/README.md

@@ -17,7 +17,7 @@ a [user guide](https://modal.com/docs/guide), and the detailed
 
 ## Installation
 
-**This library requires Python 3.9 – 3.13.**
+**This library requires Python 3.10 – 3.13.**
 
 Install the package with `uv` or `pip`:
 

{modal-1.2.7.dev0 → modal-1.2.7.dev2}/modal/__init__.py

@@ -1,8 +1,8 @@
 # Copyright Modal Labs 2022
 import sys
 
-if sys.version_info[:2] < (3, 9):
-    raise RuntimeError("This version of Modal requires at least Python 3.9")
+if sys.version_info[:2] < (3, 10):
+    raise RuntimeError("This version of Modal requires at least Python 3.10")
 if sys.version_info[:2] >= (3, 14):
     raise RuntimeError("This version of Modal does not support Python 3.14+")
 

{modal-1.2.7.dev0 → modal-1.2.7.dev2}/modal/__main__.py

@@ -35,37 +35,12 @@ def main():
         ):
             raise
 
-        from grpclib import GRPCError, Status
         from rich.panel import Panel
 
-        if isinstance(exc, GRPCError):
-            status_map = {
-                Status.ABORTED: "Aborted",
-                Status.ALREADY_EXISTS: "Already exists",
-                Status.CANCELLED: "Cancelled",
-                Status.DATA_LOSS: "Data loss",
-                Status.DEADLINE_EXCEEDED: "Deadline exceeded",
-                Status.FAILED_PRECONDITION: "Failed precondition",
-                Status.INTERNAL: "Internal",
-                Status.INVALID_ARGUMENT: "Invalid",
-                Status.NOT_FOUND: "Not found",
-                Status.OUT_OF_RANGE: "Out of range",
-                Status.PERMISSION_DENIED: "Permission denied",
-                Status.RESOURCE_EXHAUSTED: "Resource exhausted",
-                Status.UNAUTHENTICATED: "Unauthenticaed",
-                Status.UNAVAILABLE: "Unavailable",
-                Status.UNIMPLEMENTED: "Unimplemented",
-                Status.UNKNOWN: "Unknown",
-            }
-            title = f"Error: {status_map.get(exc.status, 'Unknown')}"
-            content = str(exc.message)
-            if exc.details:
-                content += f"\n\nDetails: {exc.details}"
-        else:
-            title = "Error"
-            content = str(exc)
-            if notes := getattr(exc, "__notes__", []):
-                content = f"{content}\n\nNote: {' '.join(notes)}"
+        title = "Error"
+        content = str(exc)
+        if notes := getattr(exc, "__notes__", []):
+            content = f"{content}\n\nNote: {' '.join(notes)}"
 
         console = make_console(stderr=True)
         panel = Panel(content, title=title, title_align="left", border_style="red")

{modal-1.2.7.dev0 → modal-1.2.7.dev2}/modal/_functions.py

@@ -13,7 +13,7 @@ from typing import TYPE_CHECKING, Any, AsyncIterator, Callable, Optional, Union
 
 import typing_extensions
 from google.protobuf.message import Message
-from grpclib import GRPCError, Status
+from grpclib import Status
 from synchronicity.combined_types import MethodWithAio
 
 from modal_proto import api_pb2
@@ -1126,12 +1126,8 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 )
                 try:
                     response: api_pb2.FunctionCreateResponse = await load_context.client.stub.FunctionCreate(request)
-                except GRPCError as exc:
-                    if exc.status == Status.INVALID_ARGUMENT:
-                        raise InvalidError(exc.message)
-                    if exc.status == Status.FAILED_PRECONDITION:
-                        raise InvalidError(exc.message)
-                    if exc.message and "Received :status = '413'" in exc.message:
+                except Exception as exc:
+                    if "Received :status = '413'" in str(exc):
                         raise InvalidError(f"Function {info.function_name} is too large to deploy.")
                     raise
                 function_creation_status.set_response(response)

{modal-1.2.7.dev0 → modal-1.2.7.dev2}/modal/_grpc_client.py

@@ -5,10 +5,10 @@ import grpclib.client
 from google.protobuf.message import Message
 from grpclib import GRPCError, Status
 
+from . import exception
 from ._traceback import suppress_tb_frames
 from ._utils.grpc_utils import Retry, _retry_transient_errors
 from .config import config, logger
-from .exception import InvalidError, NotFoundError
 
 if TYPE_CHECKING:
     from .client import _Client
@@ -20,6 +20,29 @@ RequestType = TypeVar("RequestType", bound=Message)
 ResponseType = TypeVar("ResponseType", bound=Message)
 
 
+class WrappedGRPCError(exception.Error, exception._GRPCErrorWrapper): ...
+
+
+_STATUS_TO_EXCEPTION: dict[Status, type[exception._GRPCErrorWrapper]] = {
+    Status.CANCELLED: exception.ServiceError,
+    Status.UNKNOWN: exception.ServiceError,
+    Status.INVALID_ARGUMENT: exception.InvalidError,
+    Status.DEADLINE_EXCEEDED: exception.ServiceError,
+    Status.NOT_FOUND: exception.NotFoundError,
+    Status.ALREADY_EXISTS: exception.AlreadyExistsError,
+    Status.PERMISSION_DENIED: exception.PermissionDeniedError,
+    Status.RESOURCE_EXHAUSTED: exception.ResourceExhaustedError,
+    Status.FAILED_PRECONDITION: exception.ConflictError,
+    Status.ABORTED: exception.ConflictError,
+    Status.OUT_OF_RANGE: exception.InvalidError,
+    Status.UNIMPLEMENTED: exception.UnimplementedError,
+    Status.INTERNAL: exception.InternalError,
+    Status.UNAVAILABLE: exception.ServiceError,
+    Status.DATA_LOSS: exception.ServiceError,
+    Status.UNAUTHENTICATED: exception.AuthError,
+}
+
+
 class grpc_error_converter:
     def __enter__(self):
         pass
@@ -29,20 +52,14 @@ class grpc_error_converter:
         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
+                modal_exc = _STATUS_TO_EXCEPTION[exc.status](exc.message)
+                modal_exc._grpc_message = exc.message
+                modal_exc._grpc_status = exc.status
+                modal_exc._grpc_details = exc.details
+                if use_full_traceback:
+                    raise modal_exc
+                else:
+                    raise modal_exc from None  # from None to skip the grpc-internal cause
 
         return False
 
@@ -100,17 +117,20 @@ class UnaryUnaryWrapper(Generic[RequestType, ResponseType]):
     ) -> ResponseType:
         with suppress_tb_frames(1):
             if timeout is not None and retry is not None:
-                raise InvalidError("Retry must be None when timeout is set")
+                raise exception.InvalidError("Retry must be None when timeout is set")
 
             if retry is None:
-                return await self.direct(req, timeout=timeout, metadata=metadata)
-
-            return await _retry_transient_errors(
-                self,  # type: ignore
-                req,
-                retry=retry,
-                metadata=metadata,
-            )
+                with grpc_error_converter():
+                    return await self.direct(req, timeout=timeout, metadata=metadata)
+
+            # TODO do we need suppress_error_frames(1) here too?
+            with grpc_error_converter():
+                return await _retry_transient_errors(
+                    self,  # type: ignore
+                    req,
+                    retry=retry,
+                    metadata=metadata,
+                )
 
     async def direct(
         self,
@@ -135,8 +155,7 @@ class UnaryUnaryWrapper(Generic[RequestType, ResponseType]):
         #
         # [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)
+        return await self.client._call_unary(self.wrapped_method, req, timeout=timeout, metadata=metadata)
 
 
 class UnaryStreamWrapper(Generic[RequestType, ResponseType]):
@@ -167,5 +186,6 @@ class UnaryStreamWrapper(Generic[RequestType, ResponseType]):
             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
+        with grpc_error_converter():
+            async for response in self.client._call_stream(self.wrapped_method, request, metadata=metadata):
+                yield response

{modal-1.2.7.dev0 → modal-1.2.7.dev2}/modal/_tunnel.py

@@ -5,14 +5,13 @@ from collections.abc import AsyncIterator
 from dataclasses import dataclass
 from typing import Optional
 
-from grpclib import GRPCError, Status
 from synchronicity.async_wrap import asynccontextmanager
 
 from modal_proto import api_pb2
 
 from ._utils.async_utils import synchronize_api
 from .client import _Client
-from .exception import InvalidError, RemoteError
+from .exception import AlreadyExistsError, InvalidError, RemoteError, ServiceError
 
 
 @dataclass(frozen=True)
@@ -186,13 +185,10 @@ async def _forward(
         response = await client.stub.TunnelStart(
             api_pb2.TunnelStartRequest(port=port, unencrypted=unencrypted, tunnel_type=tunnel_type)
         )
-    except GRPCError as exc:
-        if exc.status == Status.ALREADY_EXISTS:
-            raise InvalidError(f"Port {port} is already forwarded")
-        elif exc.status == Status.UNAVAILABLE:
-            raise RemoteError("Relay server is unavailable") from exc
-        else:
-            raise
+    except AlreadyExistsError as exc:
+        raise InvalidError(f"Port {port} is already forwarded")
+    except ServiceError as exc:
+        raise RemoteError("Relay server is unavailable") from exc
 
     try:
         yield Tunnel(response.host, response.port, response.unencrypted_host, response.unencrypted_port)

{modal-1.2.7.dev0 → modal-1.2.7.dev2}/modal/_utils/grpc_utils.py

@@ -25,7 +25,7 @@ from grpclib.encoding.base import StatusDetailsCodecBase
 from grpclib.exceptions import StreamTerminatedError
 from grpclib.protocol import H2Protocol
 
-from modal.exception import AuthError, ConnectionError
+from modal.exception import ConnectionError
 from modal_proto import api_pb2
 from modal_version import __version__
 
@@ -408,10 +408,7 @@ async def _retry_transient_errors(
 
             # Client handles retry
             if isinstance(exc, GRPCError) and exc.status not in status_codes:
-                if exc.status == Status.UNAUTHENTICATED:
-                    raise AuthError(exc.message)
-                else:
-                    raise exc
+                raise exc
             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 + retry.attempt_timeout_floor >= total_deadline:

{modal-1.2.7.dev0 → modal-1.2.7.dev2}/modal/_utils/task_command_router_client.py

@@ -14,10 +14,11 @@ from grpclib import GRPCError, Status
 from grpclib.exceptions import StreamTerminatedError
 
 from modal.config import config, logger
-from modal.exception import ExecTimeoutError
+from modal.exception import ConflictError, 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_client import grpc_error_converter
 from .async_utils import aclosing
 from .grpc_utils import RETRYABLE_GRPC_STATUS_CODES, connect_channel
 
@@ -124,11 +125,9 @@ class TaskCommandRouterClient:
         """
         try:
             resp = await fetch_command_router_access(server_client, task_id)
-        except GRPCError as exc:
-            if exc.status == Status.FAILED_PRECONDITION:
-                logger.debug(f"Command router access is not enabled for task {task_id}")
-                return None
-            raise
+        except ConflictError:
+            logger.debug(f"Command router access is not enabled for task {task_id}")
+            return None
 
         logger.debug(f"Using command router access for task {task_id}")
 
@@ -249,9 +248,10 @@ class TaskCommandRouterClient:
 
     async def exec_start(self, request: sr_pb2.TaskExecStartRequest) -> sr_pb2.TaskExecStartResponse:
         """Start an exec'd command, properly retrying on transient errors."""
-        return await call_with_retries_on_transient_errors(
-            lambda: self._call_with_auth_retry(self._stub.TaskExecStart, request)
-        )
+        with grpc_error_converter():
+            return await call_with_retries_on_transient_errors(
+                lambda: self._call_with_auth_retry(self._stub.TaskExecStart, request)
+            )
 
     async def exec_stdio_read(
         self,
@@ -286,9 +286,10 @@ class TaskCommandRouterClient:
         else:
             raise ValueError(f"Invalid file descriptor: {file_descriptor}")
 
-        async with aclosing(self._stream_stdio(task_id, exec_id, sr_fd, deadline)) as stream:
-            async for item in stream:
-                yield item
+        with grpc_error_converter():
+            async with aclosing(self._stream_stdio(task_id, exec_id, sr_fd, deadline)) as stream:
+                async for item in stream:
+                    yield item
 
     async def exec_stdin_write(
         self, task_id: str, exec_id: str, offset: int, data: bytes, eof: bool
@@ -306,9 +307,10 @@ class TaskCommandRouterClient:
               from the RPC itself.
         """
         request = sr_pb2.TaskExecStdinWriteRequest(task_id=task_id, exec_id=exec_id, offset=offset, data=data, eof=eof)
-        return await call_with_retries_on_transient_errors(
-            lambda: self._call_with_auth_retry(self._stub.TaskExecStdinWrite, request)
-        )
+        with grpc_error_converter():
+            return await call_with_retries_on_transient_errors(
+                lambda: self._call_with_auth_retry(self._stub.TaskExecStdinWrite, request)
+            )
 
     async def exec_poll(
         self, task_id: str, exec_id: str, deadline: Optional[float] = None
@@ -332,15 +334,17 @@ class TaskCommandRouterClient:
         timeout = deadline - time.monotonic() if deadline is not None else None
         if timeout is not None and timeout <= 0:
             raise ExecTimeoutError(f"Deadline exceeded while polling for exec {exec_id}")
-        try:
-            return await asyncio.wait_for(
-                call_with_retries_on_transient_errors(
-                    lambda: self._call_with_auth_retry(self._stub.TaskExecPoll, request)
-                ),
-                timeout=timeout,
-            )
-        except asyncio.TimeoutError:
-            raise ExecTimeoutError(f"Deadline exceeded while polling for exec {exec_id}")
+
+        with grpc_error_converter():
+            try:
+                return await asyncio.wait_for(
+                    call_with_retries_on_transient_errors(
+                        lambda: self._call_with_auth_retry(self._stub.TaskExecPoll, request)
+                    ),
+                    timeout=timeout,
+                )
+            except asyncio.TimeoutError:
+                raise ExecTimeoutError(f"Deadline exceeded while polling for exec {exec_id}")
 
     async def exec_wait(
         self,
@@ -363,28 +367,30 @@ class TaskCommandRouterClient:
         timeout = deadline - time.monotonic() if deadline is not None else None
         if timeout is not None and timeout <= 0:
             raise ExecTimeoutError(f"Deadline exceeded while waiting for exec {exec_id}")
-        try:
-            return await asyncio.wait_for(
-                call_with_retries_on_transient_errors(
-                    # We set a 60s timeout here to avoid waiting forever if there's an unanticipated hang
-                    # due to a networking issue. call_with_retries_on_transient_errors will retry if the
-                    # timeout is exceeded, so we'll retry every 60s until the command exits.
-                    #
-                    # Safety:
-                    # * If just the task shuts down, the task command router will return a NOT_FOUND error,
-                    #   and we'll stop retrying.
-                    # * If the task shut down AND the worker shut down, this could
-                    #   infinitely retry. For callers without an exec deadline, this
-                    #   could hang indefinitely.
-                    lambda: self._call_with_auth_retry(self._stub.TaskExecWait, request, timeout=60),
-                    base_delay_secs=1,  # Retry after 1s since total time is expected to be long.
-                    delay_factor=1,  # Fixed delay.
-                    max_retries=None,  # Retry forever.
-                ),
-                timeout=timeout,
-            )
-        except asyncio.TimeoutError:
-            raise ExecTimeoutError(f"Deadline exceeded while waiting for exec {exec_id}")
+
+        with grpc_error_converter():
+            try:
+                return await asyncio.wait_for(
+                    call_with_retries_on_transient_errors(
+                        # We set a 60s timeout here to avoid waiting forever if there's an unanticipated hang
+                        # due to a networking issue. call_with_retries_on_transient_errors will retry if the
+                        # timeout is exceeded, so we'll retry every 60s until the command exits.
+                        #
+                        # Safety:
+                        # * If just the task shuts down, the task command router will return a NOT_FOUND error,
+                        #   and we'll stop retrying.
+                        # * If the task shut down AND the worker shut down, this could
+                        #   infinitely retry. For callers without an exec deadline, this
+                        #   could hang indefinitely.
+                        lambda: self._call_with_auth_retry(self._stub.TaskExecWait, request, timeout=60),
+                        base_delay_secs=1,  # Retry after 1s since total time is expected to be long.
+                        delay_factor=1,  # Fixed delay.
+                        max_retries=None,  # Retry forever.
+                    ),
+                    timeout=timeout,
+                )
+            except asyncio.TimeoutError:
+                raise ExecTimeoutError(f"Deadline exceeded while waiting for exec {exec_id}")
 
     async def _refresh_jwt(self) -> None:
         """Refresh JWT from the server and update internal state."""

{modal-1.2.7.dev0 → modal-1.2.7.dev2}/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-1.2.7.dev0 → modal-1.2.7.dev2}/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
@@ -81,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()
@@ -200,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-1.2.7.dev0 → modal-1.2.7.dev2}/modal/cli/utils.py

@@ -5,8 +5,6 @@ from json import dumps
 from typing import Optional, Union
 
 import typer
-from click import UsageError
-from grpclib import GRPCError, Status
 from rich.table import Column, Table
 from rich.text import Text
 
@@ -33,11 +31,6 @@ async def stream_app_logs(
             await get_app_logs_loop(client, output_mgr, app_id=app_id, task_id=task_id, app_logs_url=app_logs_url)
     except asyncio.CancelledError:
         pass
-    except GRPCError as exc:
-        if exc.status in (Status.INVALID_ARGUMENT, Status.NOT_FOUND):
-            raise UsageError(exc.message)
-        else:
-            raise
     except KeyboardInterrupt:
         pass
 
@@ -48,12 +41,7 @@ async def get_app_id_from_name(name: str, env: Optional[str], client: Optional[_
         client = await _Client.from_env()
     env_name = ensure_env(env)
     request = api_pb2.AppGetByDeploymentNameRequest(name=name, environment_name=env_name)
-    try:
-        resp = await client.stub.AppGetByDeploymentName(request)
-    except GRPCError as exc:
-        if exc.status in (Status.INVALID_ARGUMENT, Status.NOT_FOUND):
-            raise UsageError(exc.message or "")
-        raise
+    resp = await client.stub.AppGetByDeploymentName(request)
     if not resp.app_id:
         env_comment = f" in the '{env_name}' environment" if env_name else ""
         raise NotFoundError(f"Could not find a deployed app named '{name}'{env_comment}.")

{modal-1.2.7.dev0 → modal-1.2.7.dev2}/modal/cli/volume.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 typer import Argument, Option, Typer
 
@@ -137,13 +136,7 @@ async def ls(
 ):
     ensure_env(env)
     vol = _Volume.from_name(volume_name, environment_name=env)
-
-    try:
-        entries = await vol.listdir(path)
-    except GRPCError as exc:
-        if exc.status in (Status.INVALID_ARGUMENT, Status.NOT_FOUND):
-            raise UsageError(exc.message)
-        raise
+    entries = await vol.listdir(path)
 
     if not json and not sys.stdout.isatty():
         # Legacy behavior -- I am not sure why exactly we did this originally but I don't want to break it
@@ -247,14 +240,9 @@ async def rm(
 ):
     ensure_env(env)
     volume = _Volume.from_name(volume_name, environment_name=env)
+    await volume.remove_file(remote_path, recursive=recursive)
     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
+    console.print(OutputManager.step_completed(f"{remote_path} was deleted successfully!"))
 
 
 @volume_cli.command(

{modal-1.2.7.dev0 → modal-1.2.7.dev2}/modal/client.pyi

@@ -32,7 +32,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.7.dev0",
+        version: str = "1.2.7.dev2",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -163,7 +163,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.7.dev0",
+        version: str = "1.2.7.dev2",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.2.7.dev0 → modal-1.2.7.dev2}/modal/cls.py

@@ -7,7 +7,6 @@ from pathlib import PurePosixPath
 from typing import Any, Callable, Optional, Sequence, TypeVar, Union
 
 from google.protobuf.message import Message
-from grpclib import GRPCError, Status
 
 from modal_proto import api_pb2
 
@@ -659,11 +658,6 @@ More information on class parameterization can be found here: https://modal.com/
                 raise NotFoundError(
                     f"Lookup failed for Cls '{name}' from the '{app_name}' app{env_context}: {exc}."
                 ) from None
-            except GRPCError as exc:
-                if exc.status == Status.FAILED_PRECONDITION:
-                    raise InvalidError(exc.message) from None
-                else:
-                    raise
 
             print_server_warnings(response.server_warnings)
             await resolver.load(self._class_service_function, load_context)

{modal-1.2.7.dev0 → modal-1.2.7.dev2}/modal/dict.py

@@ -5,7 +5,7 @@ from datetime import datetime
 from typing import Any, Optional, Union
 
 from google.protobuf.message import Message
-from grpclib import GRPCError, Status
+from grpclib import GRPCError
 from synchronicity import classproperty
 from synchronicity.async_wrap import asynccontextmanager
 
@@ -126,10 +126,8 @@ class _DictManager:
         )
         try:
             await client.stub.DictGetOrCreate(req)
-        except GRPCError as exc:
-            if exc.status == Status.ALREADY_EXISTS and not allow_existing:
-                raise AlreadyExistsError(exc.message)
-            else:
+        except AlreadyExistsError:
+            if not allow_existing:
                 raise
 
     @staticmethod