modAL 1.2.6.dev4__py3-none-any.whl → 1.2.7.dev2__py3-none-any.whl

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/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

modal/exception.py

@@ -1,7 +1,45 @@
 # Copyright Modal Labs 2022
+"""
+Modal-specific exception types.
+
+## Notes on `grpclib.GRPCError` migration
+
+Historically, the Modal SDK could propagate `grpclib.GRPCError` exceptions out
+to user code.  As of v1.3, we are in the process of gracefully migrating to
+always raising a Modal exception type in these cases. To avoid breaking user
+code that relies on catching `grpclib.GRPCError`, a subset of Modal exception
+types temporarily inherit from `grpclib.GRPCError`.
+
+We encourage users to migrate any code that currently catches `grpclib.GRPCError`
+to instead catch the appropriate Modal exception type. The following mapping
+between GRPCError status codes and Modal exception types is currently in use:
+
+```
+CANCELLED -> ServiceError
+UNKNOWN -> ServiceError
+INVALID_ARGUMENT -> InvalidError
+DEADLINE_EXCEEDED -> ServiceError
+NOT_FOUND -> NotFoundError
+ALREADY_EXISTS -> AlreadyExistsError
+PERMISSION_DENIED -> PermissionDeniedError
+RESOURCE_EXHAUSTED -> ResourceExhaustedError
+FAILED_PRECONDITION -> ConflictError
+ABORTED -> ConflictError
+OUT_OF_RANGE -> InvalidError
+UNIMPLEMENTED -> UnimplementedError
+INTERNAL -> InternalError
+UNAVAILABLE -> ServiceError
+DATA_LOSS -> ServiceError
+UNAUTHENTICATED -> AuthError
+```
+
+"""
+
 import random
 import signal
+from typing import Any, Optional
 
+import grpclib
 import synchronicity.exceptions
 
 UserCodeException = synchronicity.exceptions.UserCodeException  # Deprecated type used for return_exception wrapping
@@ -26,10 +64,112 @@ class Error(Exception):
     """
 
 
-class AlreadyExistsError(Error):
+class _GRPCErrorWrapper(grpclib.GRPCError):
+    """This transitional class helps us migrate away from propagating `grpclib.GRPCError` to users.
+
+    It serves two purposes:
+    - It avoids abruptly breaking user code that catches `grpclib.GRPCError`
+    - It actively warns when users access attributes defined by `grpclib.GRPCError`
+
+    This won't catch all cases (users might react indiscriminately to GRPCError without checking the status).
+
+    The mapping between GRPCError status codes and our error types is defined in `modal._grpc_client`.
+
+    """
+
+    # These will be set on the instance in our error handling middleware
+    _grpc_message: str
+    _grpc_status: grpclib.Status
+    _grpc_details: Any
+
+    def __init__(self, message: Optional[str] = None):
+        # Override GRPCError's init and repr to behave more like a regular Exception
+        # (We don't customize these anywhere in our custom error types currently).
+        self._message = message or ""
+
+    def __repr__(self) -> str:
+        return f"{type(self).__name__}({self._message!r})"
+
+    def _warn_on_grpc_error_attribute_access(self) -> None:
+        from ._utils.deprecation import deprecation_warning  # Avoid circular import
+
+        exc_type = type(self).__name__
+        deprecation_warning(
+            (2025, 12, 9),
+            "Modal will stop propagating the `grpclib.GRPCError` type in the future. "
+            f"Update your code so that it catches `modal.exception.{exc_type}` directly "
+            "to avoid changes to error handling behavior in the future.",
+            pending=True,
+        )
+
+    @property
+    def message(self) -> str:
+        self._warn_on_grpc_error_attribute_access()
+        return self._grpc_message
+
+    @message.setter
+    def message(self, value: str) -> None:
+        self._grpc_message = value
+
+    @property
+    def status(self) -> grpclib.Status:
+        self._warn_on_grpc_error_attribute_access()
+        return self._grpc_status
+
+    @status.setter
+    def status(self, value: grpclib.Status) -> None:
+        self._grpc_status = value
+
+    @property
+    def details(self) -> Any:
+        self._warn_on_grpc_error_attribute_access()
+        return self._grpc_details
+
+    @details.setter
+    def details(self, value: Any) -> None:
+        self._grpc_details = value
+
+
+class AlreadyExistsError(Error, _GRPCErrorWrapper):
     """Raised when a resource creation conflicts with an existing resource."""
 
 
+class AuthError(Error, _GRPCErrorWrapper):
+    """Raised when a client has missing or invalid authentication."""
+
+
+class InternalError(Error, _GRPCErrorWrapper):
+    """Raised when an internal error occurs in the Modal system."""
+
+
+class InvalidError(Error, _GRPCErrorWrapper):
+    """Raised when user does something invalid."""
+
+
+class ConflictError(InvalidError, _GRPCErrorWrapper):
+    """Raised when a resource conflict occurs between the request and current system state."""
+
+
+class NotFoundError(Error, _GRPCErrorWrapper):
+    """Raised when a requested resource was not found."""
+
+
+class PermissionDeniedError(Error, _GRPCErrorWrapper):
+    """Raised when a user does not have permission to perform the requested operation."""
+
+
+class ResourceExhaustedError(Error, _GRPCErrorWrapper):
+    """Raised when a server-side resource has been exhausted, e.g. a quota or rate limit."""
+
+
+class ServiceError(Error, _GRPCErrorWrapper):
+    """Raised when an error occurs in basic client<>server communication."""
+
+
+class UnimplementedError(Error, _GRPCErrorWrapper):
+    """Raised when a requested operation is not implemented or not supported."""
+
+
 class RemoteError(Error):
     """Raised when an error occurs on the Modal server."""
 
@@ -70,26 +210,14 @@ class OutputExpiredError(TimeoutError):
     """Raised when the Output exceeds expiration and times out."""
 
 
-class AuthError(Error):
-    """Raised when a client has missing or invalid authentication."""
-
-
 class ConnectionError(Error):
     """Raised when an issue occurs while connecting to the Modal servers."""
 
 
-class InvalidError(Error):
-    """Raised when user does something invalid."""
-
-
 class VersionError(Error):
     """Raised when the current client version of Modal is unsupported."""
 
 
-class NotFoundError(Error):
-    """Raised when a requested resource was not found."""
-
-
 class ExecutionError(Error):
     """Raised when something unexpected happened during runtime."""
 
@@ -121,9 +249,7 @@ class ServerWarning(UserWarning):
 
 
 class InternalFailure(Error):
-    """
-    Retriable internal error.
-    """
+    """Retriable internal error."""
 
 
 class _CliUserExecutionError(Exception):

modal/functions.pyi

@@ -409,7 +409,7 @@ class Function(
 
     _call_generator: ___call_generator_spec[typing_extensions.Self]
 
-    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER:
             """Calls the function remotely, executing it with the given arguments and returning the execution's result."""
             ...
@@ -418,7 +418,7 @@ class Function(
             """Calls the function remotely, executing it with the given arguments and returning the execution's result."""
             ...
 
-    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
+    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
 
     class __remote_gen_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]:
@@ -445,7 +445,7 @@ class Function(
         """
         ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """[Experimental] Calls the function with the given arguments, without waiting for the results.
 
@@ -469,7 +469,7 @@ class Function(
             ...
 
     _experimental_spawn: ___experimental_spawn_spec[
-        modal._functions.ReturnType, modal._functions.P, typing_extensions.Self
+        modal._functions.P, modal._functions.ReturnType, typing_extensions.Self
     ]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER, SUPERSELF]):
@@ -478,7 +478,7 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P, typing_extensions.Self]
 
-    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """Calls the function with the given arguments, without waiting for the results.
 
@@ -499,7 +499,7 @@ class Function(
             """
             ...
 
-    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
+    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]:
         """Return the inner Python object wrapped by this Modal Function."""

modal/image.py

@@ -65,11 +65,11 @@ ImageBuilderVersion = Literal["2023.12", "2024.04", "2024.10", "2025.06", "PREVI
 # Python versions in mount.py where we specify the "standalone Python versions" we create mounts for.
 # Consider consolidating these multiple sources of truth?
 SUPPORTED_PYTHON_SERIES: dict[ImageBuilderVersion, list[str]] = {
-    "PREVIEW": ["3.9", "3.10", "3.11", "3.12", "3.13"],
-    "2025.06": ["3.9", "3.10", "3.11", "3.12", "3.13"],
-    "2024.10": ["3.9", "3.10", "3.11", "3.12", "3.13"],
-    "2024.04": ["3.9", "3.10", "3.11", "3.12"],
-    "2023.12": ["3.9", "3.10", "3.11", "3.12"],
+    "PREVIEW": ["3.10", "3.11", "3.12", "3.13"],
+    "2025.06": ["3.10", "3.11", "3.12", "3.13"],
+    "2024.10": ["3.10", "3.11", "3.12", "3.13"],
+    "2024.04": ["3.10", "3.11", "3.12"],
+    "2023.12": ["3.10", "3.11", "3.12"],
 }
 
 LOCAL_REQUIREMENTS_DIR = Path(__file__).parent / "builder"
@@ -1742,9 +1742,6 @@ class _Image(_Object, type_prefix="im"):
         """A Micromamba base image. Micromamba allows for fast building of small Conda-based containers."""
 
         def build_dockerfile(version: ImageBuilderVersion) -> DockerfileSpec:
-            nonlocal python_version
-            if version == "2023.12" and python_version is None:
-                python_version = "3.9"  # Backcompat for old hardcoded default param
             validated_python_version = _validate_python_version(python_version, version)
             micromamba_version = _base_image_config("micromamba", version)
             tag = f"mambaorg/micromamba:{micromamba_version}"

modal/io_streams.py

@@ -18,7 +18,6 @@ from typing import (
     cast,
 )
 
-from grpclib import Status
 from grpclib.exceptions import GRPCError, StreamTerminatedError
 
 from modal.exception import ClientClosed, ExecTimeoutError, InvalidError
@@ -29,6 +28,7 @@ from ._utils.grpc_utils import RETRYABLE_GRPC_STATUS_CODES
 from ._utils.task_command_router_client import TaskCommandRouterClient
 from .client import _Client
 from .config import logger
+from .exception import ConflictError
 from .stream_type import StreamType
 
 if TYPE_CHECKING:
@@ -697,11 +697,8 @@ class _StreamWriterThroughServer:
                         input=api_pb2.RuntimeInputMessage(message=data, message_index=index, eof=self._is_closed),
                     ),
                 )
-        except GRPCError as exc:
-            if exc.status == Status.FAILED_PRECONDITION:
-                raise ValueError(exc.message)
-            else:
-                raise exc
+        except ConflictError as exc:
+            raise ValueError(str(exc))
 
 
 class _StreamWriterThroughCommandRouter:

modal/mount.py

@@ -41,7 +41,6 @@ MOUNT_PUT_FILE_CLIENT_TIMEOUT = 10 * 60  # 10 min max for transferring files
 # These can be updated safely, but changes will trigger a rebuild for all images
 # that rely on `add_python()` in their constructor.
 PYTHON_STANDALONE_VERSIONS: dict[str, tuple[str, str]] = {
-    "3.9": ("20230826", "3.9.18"),
     "3.10": ("20230826", "3.10.13"),
     "3.11": ("20230826", "3.11.5"),
     "3.12": ("20240107", "3.12.1"),

modal/mount.pyi

@@ -428,7 +428,7 @@ async def _create_single_client_dependency_mount(
 ): ...
 async def _create_client_dependency_mounts(
     client=None,
-    python_versions: list[str] = ["3.9", "3.10", "3.11", "3.12", "3.13"],
+    python_versions: list[str] = ["3.10", "3.11", "3.12", "3.13"],
     builder_versions: list[str] = ["2025.06"],
     check_if_exists=True,
     dry_run=False,
@@ -439,7 +439,7 @@ class __create_client_dependency_mounts_spec(typing_extensions.Protocol):
         self,
         /,
         client=None,
-        python_versions: list[str] = ["3.9", "3.10", "3.11", "3.12", "3.13"],
+        python_versions: list[str] = ["3.10", "3.11", "3.12", "3.13"],
         builder_versions: list[str] = ["2025.06"],
         check_if_exists=True,
         dry_run=False,
@@ -448,7 +448,7 @@ class __create_client_dependency_mounts_spec(typing_extensions.Protocol):
         self,
         /,
         client=None,
-        python_versions: list[str] = ["3.9", "3.10", "3.11", "3.12", "3.13"],
+        python_versions: list[str] = ["3.10", "3.11", "3.12", "3.13"],
         builder_versions: list[str] = ["2025.06"],
         check_if_exists=True,
         dry_run=False,

modal/queue.py

@@ -8,7 +8,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 Status
 from synchronicity import classproperty
 from synchronicity.async_wrap import asynccontextmanager
 
@@ -30,7 +30,7 @@ from ._utils.grpc_utils import Retry
 from ._utils.name_utils import check_object_name
 from ._utils.time_utils import as_timestamp, timestamp_to_localized_dt
 from .client import _Client
-from .exception import AlreadyExistsError, InvalidError, NotFoundError, RequestSizeError
+from .exception import AlreadyExistsError, InvalidError, NotFoundError, RequestSizeError, ResourceExhaustedError
 
 
 @dataclass
@@ -97,10 +97,8 @@ class _QueueManager:
         )
         try:
             await client.stub.QueueGetOrCreate(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
@@ -597,14 +595,11 @@ class _Queue(_Object, type_prefix="qu"):
                     total_timeout=timeout,
                 ),
             )
-        except GRPCError as exc:
-            if exc.status == Status.RESOURCE_EXHAUSTED:
-                raise queue.Full(str(exc))
-            elif "status = '413'" in exc.message:
+        except ResourceExhaustedError as exc:
+            if "status = '413'" in str(exc):
                 method = "put_many" if len(vs) > 1 else "put"
                 raise RequestSizeError(f"Queue.{method} request is too large") from exc
-            else:
-                raise exc
+            raise queue.Full(str(exc))
 
     async def _put_many_nonblocking(self, partition: Optional[str], partition_ttl: int, vs: list[Any]):
         vs_encoded = [serialize(v) for v in vs]
@@ -616,14 +611,11 @@ class _Queue(_Object, type_prefix="qu"):
         )
         try:
             await self._client.stub.QueuePut(request)
-        except GRPCError as exc:
-            if exc.status == Status.RESOURCE_EXHAUSTED:
-                raise queue.Full(exc.message)
-            elif "status = '413'" in exc.message:
+        except ResourceExhaustedError as exc:
+            if "status = '413'" in str(exc):
                 method = "put_many" if len(vs) > 1 else "put"
                 raise RequestSizeError(f"Queue.{method} request is too large") from exc
-            else:
-                raise exc
+            raise queue.Full(str(exc)) from exc
 
     @live_method
     async def len(self, *, partition: Optional[str] = None, total: bool = False) -> int:

modal/runner.py

@@ -13,7 +13,6 @@ from contextlib import nullcontext
 from multiprocessing.synchronize import Event
 from typing import TYPE_CHECKING, Any, Optional, TypeVar
 
-from grpclib import GRPCError, Status
 from synchronicity.async_wrap import asynccontextmanager
 
 import modal._runtime.execution_context
@@ -200,13 +199,7 @@ async def _publish_app(
         definition_ids=definition_ids,
     )
 
-    try:
-        response = await client.stub.AppPublish(request)
-    except GRPCError as exc:
-        if exc.status == Status.INVALID_ARGUMENT or exc.status == Status.FAILED_PRECONDITION:
-            raise InvalidError(exc.message)
-        raise
-
+    response = await client.stub.AppPublish(request)
     print_server_warnings(response.server_warnings)
     return response.url, response.server_warnings
 

modal/sandbox.py

@@ -15,7 +15,6 @@ if TYPE_CHECKING:
     import _typeshed
 
 from google.protobuf.message import Message
-from grpclib import GRPCError, Status
 
 from modal._tunnel import Tunnel
 from modal.cloud_bucket_mount import _CloudBucketMount, cloud_bucket_mounts_to_proto
@@ -34,7 +33,7 @@ from ._utils.name_utils import check_object_name
 from ._utils.task_command_router_client import TaskCommandRouterClient
 from .client import _Client
 from .container_process import _ContainerProcess
-from .exception import AlreadyExistsError, ExecutionError, InvalidError, SandboxTerminatedError, SandboxTimeoutError
+from .exception import ExecutionError, InvalidError, SandboxTerminatedError, SandboxTimeoutError
 from .file_io import FileWatchEvent, FileWatchEventType, _FileIO
 from .gpu import GPU_T
 from .image import _Image
@@ -261,13 +260,7 @@ class _Sandbox(_Object, type_prefix="sb"):
             )
 
             create_req = api_pb2.SandboxCreateRequest(app_id=load_context.app_id, definition=definition)
-            try:
-                create_resp = await load_context.client.stub.SandboxCreate(create_req)
-            except GRPCError as exc:
-                if exc.status == Status.ALREADY_EXISTS:
-                    raise AlreadyExistsError(exc.message)
-                raise exc
-
+            create_resp = await load_context.client.stub.SandboxCreate(create_req)
             sandbox_id = create_resp.sandbox_id
             self._hydrate(sandbox_id, load_context.client, None)
 
@@ -557,10 +550,7 @@ class _Sandbox(_Object, type_prefix="sb"):
     async def get_tags(self) -> dict[str, str]:
         """Fetches any tags (key-value pairs) currently attached to this Sandbox from the server."""
         req = api_pb2.SandboxTagsGetRequest(sandbox_id=self.object_id)
-        try:
-            resp = await self._client.stub.SandboxTagsGet(req)
-        except GRPCError as exc:
-            raise InvalidError(exc.message) if exc.status == Status.INVALID_ARGUMENT else exc
+        resp = await self._client.stub.SandboxTagsGet(req)
 
         return {tag.tag_name: tag.tag_value for tag in resp.tags}
 
@@ -581,10 +571,7 @@ class _Sandbox(_Object, type_prefix="sb"):
             sandbox_id=self.object_id,
             tags=tags_list,
         )
-        try:
-            await self._client.stub.SandboxTagsSet(req)
-        except GRPCError as exc:
-            raise InvalidError(exc.message) if exc.status == Status.INVALID_ARGUMENT else exc
+        await self._client.stub.SandboxTagsSet(req)
 
     async def snapshot_filesystem(self, timeout: int = 55) -> _Image:
         """Snapshot the filesystem of the Sandbox.
@@ -1025,12 +1012,7 @@ class _Sandbox(_Object, type_prefix="sb"):
                 sandbox_name_override=name,
                 sandbox_name_override_type=api_pb2.SandboxRestoreRequest.SANDBOX_NAME_OVERRIDE_TYPE_STRING,
             )
-        try:
-            restore_resp: api_pb2.SandboxRestoreResponse = await client.stub.SandboxRestore(restore_req)
-        except GRPCError as exc:
-            if exc.status == Status.ALREADY_EXISTS:
-                raise AlreadyExistsError(exc.message)
-            raise exc
+        restore_resp: api_pb2.SandboxRestoreResponse = await client.stub.SandboxRestore(restore_req)
 
         sandbox = await _Sandbox.from_id(restore_resp.sandbox_id, client)
 
@@ -1171,10 +1153,7 @@ class _Sandbox(_Object, type_prefix="sb"):
             )
 
             # Fetches a batch of sandboxes.
-            try:
-                resp = await client.stub.SandboxList(req)
-            except GRPCError as exc:
-                raise InvalidError(exc.message) if exc.status == Status.INVALID_ARGUMENT else exc
+            resp = await client.stub.SandboxList(req)
 
             if not resp.sandboxes:
                 return

modal/secret.py

@@ -5,7 +5,6 @@ from datetime import datetime
 from typing import Optional, Union
 
 from google.protobuf.message import Message
-from grpclib import GRPCError, Status
 from synchronicity import classproperty
 
 from modal_proto import api_pb2
@@ -92,10 +91,8 @@ class _SecretManager:
         )
         try:
             await client.stub.SecretGetOrCreate(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
@@ -222,14 +219,7 @@ async def _load_from_env_dict(instance: "_Secret", load_context: LoadContext, en
             environment_name=load_context.environment_name,
         )
 
-    try:
-        resp = await load_context.client.stub.SecretGetOrCreate(req)
-    except GRPCError as exc:
-        if exc.status == Status.INVALID_ARGUMENT:
-            raise InvalidError(exc.message)
-        if exc.status == Status.FAILED_PRECONDITION:
-            raise InvalidError(exc.message)
-        raise
+    resp = await load_context.client.stub.SecretGetOrCreate(req)
     instance._hydrate(resp.secret_id, load_context.client, resp.metadata)
 
 
@@ -411,13 +401,7 @@ class _Secret(_Object, type_prefix="st"):
                 environment_name=load_context.environment_name,
                 required_keys=required_keys,
             )
-            try:
-                response = await load_context.client.stub.SecretGetOrCreate(req)
-            except GRPCError as exc:
-                if exc.status == Status.NOT_FOUND:
-                    raise NotFoundError(exc.message)
-                else:
-                    raise
+            response = await load_context.client.stub.SecretGetOrCreate(req)
             self._hydrate(response.secret_id, load_context.client, response.metadata)
 
         rep = _Secret._repr(name, environment_name)