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

modal/dict.py

@@ -1,16 +1,18 @@
 # Copyright Modal Labs 2022
+import builtins
 from collections.abc import AsyncIterator, Mapping
 from dataclasses import dataclass
 from datetime import datetime
 from typing import Any, Optional, Union
 
 from google.protobuf.message import Message
-from grpclib import GRPCError, Status
 from synchronicity import classproperty
 from synchronicity.async_wrap import asynccontextmanager
 
+from modal._utils.grpc_utils import Retry
 from modal_proto import api_pb2
 
+from ._load_context import LoadContext
 from ._object import (
     EPHEMERAL_OBJECT_HEARTBEAT_SLEEP,
     _get_environment_name,
@@ -22,12 +24,18 @@ from ._resolver import Resolver
 from ._serialization import deserialize, serialize
 from ._utils.async_utils import TaskContext, synchronize_api
 from ._utils.deprecation import deprecation_warning, warn_if_passing_namespace
-from ._utils.grpc_utils import retry_transient_errors
 from ._utils.name_utils import check_object_name
 from ._utils.time_utils import as_timestamp, timestamp_to_localized_dt
 from .client import _Client
 from .config import logger
-from .exception import AlreadyExistsError, InvalidError, NotFoundError, RequestSizeError
+from .exception import (
+    AlreadyExistsError,
+    DeserializationError,
+    Error,
+    InvalidError,
+    NotFoundError,
+    RequestSizeError,
+)
 
 
 class _NoDefaultSentinel:
@@ -42,6 +50,25 @@ def _serialize_dict(data):
     return [api_pb2.DictEntry(key=serialize(k), value=serialize(v)) for k, v in data.items()]
 
 
+def _deserialize_dict_key(dict: "_Dict", data: bytes) -> Any:
+    try:
+        return deserialize(data, dict._client)
+    except DeserializationError as exc:
+        dict_identifier = f"Dict '{dict.name}'" if dict.name else f"ephemeral Dict {dict.object_id}"
+        raise DeserializationError(f"Failed to deserialize a key from {dict_identifier}: {exc}") from exc
+
+
+def _deserialize_dict_value(dict: "_Dict", data: bytes, key: Any = _NO_DEFAULT) -> Any:
+    try:
+        return deserialize(data, dict._client)
+    except DeserializationError as exc:
+        key_identifier = "" if key is _NO_DEFAULT else f" for key {key!r}"
+        dict_identifier = f"Dict '{dict.name}'" if dict.name else f"ephemeral Dict {dict.object_id}"
+        raise DeserializationError(
+            f"Failed to deserialize value{key_identifier} from {dict_identifier}: {exc}"
+        ) from exc
+
+
 @dataclass
 class DictInfo:
     """Information about a Dict object."""
@@ -105,11 +132,9 @@ class _DictManager:
             object_creation_type=object_creation_type,
         )
         try:
-            await retry_transient_errors(client.stub.DictGetOrCreate, req)
-        except GRPCError as exc:
-            if exc.status == Status.ALREADY_EXISTS and not allow_existing:
-                raise AlreadyExistsError(exc.message)
-            else:
+            await client.stub.DictGetOrCreate(req)
+        except AlreadyExistsError:
+            if not allow_existing:
                 raise
 
     @staticmethod
@@ -119,7 +144,7 @@ class _DictManager:
         created_before: Optional[Union[datetime, str]] = None,  # Limit based on creation date
         environment_name: str = "",  # Uses active environment if not specified
         client: Optional[_Client] = None,  # Optional client with Modal credentials
-    ) -> list["_Dict"]:
+    ) -> builtins.list["_Dict"]:
         """Return a list of hydrated Dict objects.
 
         **Examples:**
@@ -157,7 +182,7 @@ class _DictManager:
             req = api_pb2.DictListRequest(
                 environment_name=_get_environment_name(environment_name), pagination=pagination
             )
-            resp = await retry_transient_errors(client.stub.DictList, req)
+            resp = await client.stub.DictList(req)
             items.extend(resp.dicts)
             finished = (len(resp.dicts) < max_page_size) or (max_objects is not None and len(items) >= max_objects)
             return finished
@@ -215,7 +240,7 @@ class _DictManager:
                 raise
         else:
             req = api_pb2.DictDeleteRequest(dict_id=obj.object_id)
-            await retry_transient_errors(obj._client.stub.DictDelete, req)
+            await obj._client.stub.DictDelete(req)
 
 
 DictManager = synchronize_api(_DictManager)
@@ -327,7 +352,7 @@ class _Dict(_Object, type_prefix="di"):
             environment_name=_get_environment_name(environment_name),
             data=serialized,
         )
-        response = await retry_transient_errors(client.stub.DictGetOrCreate, request, total_timeout=10.0)
+        response = await client.stub.DictGetOrCreate(request, retry=Retry(total_timeout=10.0))
         async with TaskContext() as tc:
             request = api_pb2.DictHeartbeatRequest(dict_id=response.dict_id)
             tc.infinite_loop(lambda: client.stub.DictHeartbeat(request), sleep=_heartbeat_sleep)
@@ -347,6 +372,7 @@ class _Dict(_Object, type_prefix="di"):
         namespace=None,  # mdmd:line-hidden
         environment_name: Optional[str] = None,
         create_if_missing: bool = False,
+        client: Optional[_Client] = None,
     ) -> "_Dict":
         """Reference a named Dict, creating if necessary.
 
@@ -368,20 +394,27 @@ class _Dict(_Object, type_prefix="di"):
                 "Passing data to `modal.Dict.from_name` is deprecated and will stop working in a future release.",
             )
 
-        async def _load(self: _Dict, resolver: Resolver, existing_object_id: Optional[str]):
+        async def _load(self: _Dict, resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]):
             serialized = _serialize_dict(data if data is not None else {})
             req = api_pb2.DictGetOrCreateRequest(
                 deployment_name=name,
-                environment_name=_get_environment_name(environment_name, resolver),
+                environment_name=load_context.environment_name,
                 object_creation_type=(api_pb2.OBJECT_CREATION_TYPE_CREATE_IF_MISSING if create_if_missing else None),
                 data=serialized,
             )
-            response = await resolver.client.stub.DictGetOrCreate(req)
+            response = await load_context.client.stub.DictGetOrCreate(req)
             logger.debug(f"Created dict with id {response.dict_id}")
-            self._hydrate(response.dict_id, resolver.client, response.metadata)
+            self._hydrate(response.dict_id, load_context.client, response.metadata)
 
         rep = _Dict._repr(name, environment_name)
-        return _Dict._from_loader(_load, rep, is_another_app=True, hydrate_lazily=True, name=name)
+        return _Dict._from_loader(
+            _load,
+            rep,
+            is_another_app=True,
+            hydrate_lazily=True,
+            name=name,
+            load_context_overrides=LoadContext(environment_name=environment_name, client=client),
+        )
 
     @staticmethod
     async def delete(
@@ -418,7 +451,7 @@ class _Dict(_Object, type_prefix="di"):
     async def clear(self) -> None:
         """Remove all items from the Dict."""
         req = api_pb2.DictClearRequest(dict_id=self.object_id)
-        await retry_transient_errors(self._client.stub.DictClear, req)
+        await self._client.stub.DictClear(req)
 
     @live_method
     async def get(self, key: Any, default: Optional[Any] = None) -> Any:
@@ -427,16 +460,16 @@ class _Dict(_Object, type_prefix="di"):
         Returns `default` if key does not exist.
         """
         req = api_pb2.DictGetRequest(dict_id=self.object_id, key=serialize(key))
-        resp = await retry_transient_errors(self._client.stub.DictGet, req)
+        resp = await self._client.stub.DictGet(req)
         if not resp.found:
             return default
-        return deserialize(resp.value, self._client)
+        return _deserialize_dict_value(self, resp.value, key)
 
     @live_method
     async def contains(self, key: Any) -> bool:
         """Return if a key is present."""
         req = api_pb2.DictContainsRequest(dict_id=self.object_id, key=serialize(key))
-        resp = await retry_transient_errors(self._client.stub.DictContains, req)
+        resp = await self._client.stub.DictContains(req)
         return resp.found
 
     @live_method
@@ -446,7 +479,7 @@ class _Dict(_Object, type_prefix="di"):
         Note: This is an expensive operation and will return at most 100,000.
         """
         req = api_pb2.DictLenRequest(dict_id=self.object_id)
-        resp = await retry_transient_errors(self._client.stub.DictLen, req)
+        resp = await self._client.stub.DictLen(req)
         return resp.len
 
     @live_method
@@ -475,9 +508,9 @@ class _Dict(_Object, type_prefix="di"):
         serialized = _serialize_dict(contents)
         req = api_pb2.DictUpdateRequest(dict_id=self.object_id, updates=serialized)
         try:
-            await retry_transient_errors(self._client.stub.DictUpdate, req)
-        except GRPCError as exc:
-            if "status = '413'" in exc.message:
+            await self._client.stub.DictUpdate(req)
+        except Error as exc:
+            if "status = '413'" in str(exc):
                 raise RequestSizeError("Dict.update request is too large") from exc
             else:
                 raise exc
@@ -493,10 +526,10 @@ class _Dict(_Object, type_prefix="di"):
         serialized = _serialize_dict(updates)
         req = api_pb2.DictUpdateRequest(dict_id=self.object_id, updates=serialized, if_not_exists=skip_if_exists)
         try:
-            resp = await retry_transient_errors(self._client.stub.DictUpdate, req)
+            resp = await self._client.stub.DictUpdate(req)
             return resp.created
-        except GRPCError as exc:
-            if "status = '413'" in exc.message:
+        except Error as exc:
+            if "status = '413'" in str(exc):
                 raise RequestSizeError("Dict.put request is too large") from exc
             else:
                 raise exc
@@ -516,12 +549,12 @@ class _Dict(_Object, type_prefix="di"):
         If key is not found, return default if provided, otherwise raise KeyError.
         """
         req = api_pb2.DictPopRequest(dict_id=self.object_id, key=serialize(key))
-        resp = await retry_transient_errors(self._client.stub.DictPop, req)
+        resp = await self._client.stub.DictPop(req)
         if not resp.found:
             if default is not _NO_DEFAULT:
                 return default
             raise KeyError(f"{key} not in dict {self.object_id}")
-        return deserialize(resp.value, self._client)
+        return _deserialize_dict_value(self, resp.value, key)
 
     @live_method
     async def __delitem__(self, key: Any) -> Any:
@@ -548,7 +581,7 @@ class _Dict(_Object, type_prefix="di"):
         """
         req = api_pb2.DictContentsRequest(dict_id=self.object_id, keys=True)
         async for resp in self._client.stub.DictContents.unary_stream(req):
-            yield deserialize(resp.key, self._client)
+            yield _deserialize_dict_key(self, resp.key)
 
     @live_method_gen
     async def values(self) -> AsyncIterator[Any]:
@@ -559,7 +592,11 @@ class _Dict(_Object, type_prefix="di"):
         """
         req = api_pb2.DictContentsRequest(dict_id=self.object_id, values=True)
         async for resp in self._client.stub.DictContents.unary_stream(req):
-            yield deserialize(resp.value, self._client)
+            try:
+                key_deser = _deserialize_dict_key(self, resp.key)
+            except DeserializationError:
+                key_deser = _NO_DEFAULT
+            yield _deserialize_dict_value(self, resp.value, key_deser)
 
     @live_method_gen
     async def items(self) -> AsyncIterator[tuple[Any, Any]]:
@@ -570,7 +607,9 @@ class _Dict(_Object, type_prefix="di"):
         """
         req = api_pb2.DictContentsRequest(dict_id=self.object_id, keys=True, values=True)
         async for resp in self._client.stub.DictContents.unary_stream(req):
-            yield (deserialize(resp.key, self._client), deserialize(resp.value, self._client))
+            key_deser = _deserialize_dict_key(self, resp.key)
+            value_deser = _deserialize_dict_value(self, resp.value, key_deser)
+            yield (key_deser, value_deser)
 
 
 Dict = synchronize_api(_Dict)

modal/dict.pyi

@@ -18,6 +18,8 @@ class _NoDefaultSentinel:
 _NO_DEFAULT: _NoDefaultSentinel
 
 def _serialize_dict(data): ...
+def _deserialize_dict_key(dict: _Dict, data: bytes) -> typing.Any: ...
+def _deserialize_dict_value(dict: _Dict, data: bytes, key: typing.Any = ...) -> typing.Any: ...
 
 class DictInfo:
     """Information about a Dict object."""
@@ -222,7 +224,7 @@ class DictManager:
             """
             ...
 
-    create: __create_spec
+    create: typing.ClassVar[__create_spec]
 
     class __list_spec(typing_extensions.Protocol):
         def __call__(
@@ -295,7 +297,7 @@ class DictManager:
             """
             ...
 
-    list: __list_spec
+    list: typing.ClassVar[__list_spec]
 
     class __delete_spec(typing_extensions.Protocol):
         def __call__(
@@ -358,7 +360,7 @@ class DictManager:
             """
             ...
 
-    delete: __delete_spec
+    delete: typing.ClassVar[__delete_spec]
 
 class _Dict(modal._object._Object):
     """Distributed dictionary for storage in Modal apps.
@@ -448,6 +450,7 @@ class _Dict(modal._object._Object):
         namespace=None,
         environment_name: typing.Optional[str] = None,
         create_if_missing: bool = False,
+        client: typing.Optional[modal.client._Client] = None,
     ) -> _Dict:
         """Reference a named Dict, creating if necessary.
 
@@ -576,8 +579,6 @@ class _Dict(modal._object._Object):
         """
         ...
 
-SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
-
 class Dict(modal.object.Object):
     """Distributed dictionary for storage in Modal apps.
 
@@ -633,30 +634,59 @@ class Dict(modal.object.Object):
     def name(self) -> typing.Optional[str]: ...
     def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...
     def _get_metadata(self) -> modal_proto.api_pb2.DictMetadata: ...
-    @classmethod
-    def ephemeral(
-        cls: type[Dict],
-        data: typing.Optional[dict] = None,
-        client: typing.Optional[modal.client.Client] = None,
-        environment_name: typing.Optional[str] = None,
-        _heartbeat_sleep: float = 300,
-    ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[Dict]:
-        """Creates a new ephemeral Dict within a context manager:
 
-        Usage:
-        ```python
-        from modal import Dict
+    class __ephemeral_spec(typing_extensions.Protocol):
+        def __call__(
+            self,
+            /,
+            data: typing.Optional[dict] = None,
+            client: typing.Optional[modal.client.Client] = None,
+            environment_name: typing.Optional[str] = None,
+            _heartbeat_sleep: float = 300,
+        ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[Dict]:
+            """Creates a new ephemeral Dict within a context manager:
 
-        with Dict.ephemeral() as d:
-            d["foo"] = "bar"
-        ```
+            Usage:
+            ```python
+            from modal import Dict
 
-        ```python notest
-        async with Dict.ephemeral() as d:
-            await d.put.aio("foo", "bar")
-        ```
-        """
-        ...
+            with Dict.ephemeral() as d:
+                d["foo"] = "bar"
+            ```
+
+            ```python notest
+            async with Dict.ephemeral() as d:
+                await d.put.aio("foo", "bar")
+            ```
+            """
+            ...
+
+        def aio(
+            self,
+            /,
+            data: typing.Optional[dict] = None,
+            client: typing.Optional[modal.client.Client] = None,
+            environment_name: typing.Optional[str] = None,
+            _heartbeat_sleep: float = 300,
+        ) -> typing.AsyncContextManager[Dict]:
+            """Creates a new ephemeral Dict within a context manager:
+
+            Usage:
+            ```python
+            from modal import Dict
+
+            with Dict.ephemeral() as d:
+                d["foo"] = "bar"
+            ```
+
+            ```python notest
+            async with Dict.ephemeral() as d:
+                await d.put.aio("foo", "bar")
+            ```
+            """
+            ...
+
+    ephemeral: typing.ClassVar[__ephemeral_spec]
 
     @staticmethod
     def from_name(
@@ -666,6 +696,7 @@ class Dict(modal.object.Object):
         namespace=None,
         environment_name: typing.Optional[str] = None,
         create_if_missing: bool = False,
+        client: typing.Optional[modal.client.Client] = None,
     ) -> Dict:
         """Reference a named Dict, creating if necessary.
 
@@ -717,9 +748,9 @@ class Dict(modal.object.Object):
             """
             ...
 
-    delete: __delete_spec
+    delete: typing.ClassVar[__delete_spec]
 
-    class __info_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __info_spec(typing_extensions.Protocol):
         def __call__(self, /) -> DictInfo:
             """Return information about the Dict object."""
             ...
@@ -728,9 +759,9 @@ class Dict(modal.object.Object):
             """Return information about the Dict object."""
             ...
 
-    info: __info_spec[typing_extensions.Self]
+    info: __info_spec
 
-    class __clear_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __clear_spec(typing_extensions.Protocol):
         def __call__(self, /) -> None:
             """Remove all items from the Dict."""
             ...
@@ -739,9 +770,9 @@ class Dict(modal.object.Object):
             """Remove all items from the Dict."""
             ...
 
-    clear: __clear_spec[typing_extensions.Self]
+    clear: __clear_spec
 
-    class __get_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __get_spec(typing_extensions.Protocol):
         def __call__(self, /, key: typing.Any, default: typing.Optional[typing.Any] = None) -> typing.Any:
             """Get the value associated with a key.
 
@@ -756,9 +787,9 @@ class Dict(modal.object.Object):
             """
             ...
 
-    get: __get_spec[typing_extensions.Self]
+    get: __get_spec
 
-    class __contains_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __contains_spec(typing_extensions.Protocol):
         def __call__(self, /, key: typing.Any) -> bool:
             """Return if a key is present."""
             ...
@@ -767,9 +798,9 @@ class Dict(modal.object.Object):
             """Return if a key is present."""
             ...
 
-    contains: __contains_spec[typing_extensions.Self]
+    contains: __contains_spec
 
-    class __len_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __len_spec(typing_extensions.Protocol):
         def __call__(self, /) -> int:
             """Return the length of the Dict.
 
@@ -784,9 +815,9 @@ class Dict(modal.object.Object):
             """
             ...
 
-    len: __len_spec[typing_extensions.Self]
+    len: __len_spec
 
-    class ____getitem___spec(typing_extensions.Protocol[SUPERSELF]):
+    class ____getitem___spec(typing_extensions.Protocol):
         def __call__(self, /, key: typing.Any) -> typing.Any:
             """Get the value associated with a key.
 
@@ -801,9 +832,9 @@ class Dict(modal.object.Object):
             """
             ...
 
-    __getitem__: ____getitem___spec[typing_extensions.Self]
+    __getitem__: ____getitem___spec
 
-    class __update_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __update_spec(typing_extensions.Protocol):
         def __call__(self, other: typing.Optional[collections.abc.Mapping] = None, /, **kwargs) -> None:
             """Update the Dict with additional items."""
             ...
@@ -812,9 +843,9 @@ class Dict(modal.object.Object):
             """Update the Dict with additional items."""
             ...
 
-    update: __update_spec[typing_extensions.Self]
+    update: __update_spec
 
-    class __put_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __put_spec(typing_extensions.Protocol):
         def __call__(self, /, key: typing.Any, value: typing.Any, *, skip_if_exists: bool = False) -> bool:
             """Add a specific key-value pair to the Dict.
 
@@ -831,9 +862,9 @@ class Dict(modal.object.Object):
             """
             ...
 
-    put: __put_spec[typing_extensions.Self]
+    put: __put_spec
 
-    class ____setitem___spec(typing_extensions.Protocol[SUPERSELF]):
+    class ____setitem___spec(typing_extensions.Protocol):
         def __call__(self, /, key: typing.Any, value: typing.Any) -> None:
             """Set a specific key-value pair to the Dict.
 
@@ -848,9 +879,9 @@ class Dict(modal.object.Object):
             """
             ...
 
-    __setitem__: ____setitem___spec[typing_extensions.Self]
+    __setitem__: ____setitem___spec
 
-    class __pop_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __pop_spec(typing_extensions.Protocol):
         def __call__(self, /, key: typing.Any, default: typing.Any = ...) -> typing.Any:
             """Remove a key from the Dict, returning the value if it exists.
 
@@ -865,9 +896,9 @@ class Dict(modal.object.Object):
             """
             ...
 
-    pop: __pop_spec[typing_extensions.Self]
+    pop: __pop_spec
 
-    class ____delitem___spec(typing_extensions.Protocol[SUPERSELF]):
+    class ____delitem___spec(typing_extensions.Protocol):
         def __call__(self, /, key: typing.Any) -> typing.Any:
             """Delete a key from the Dict.
 
@@ -882,9 +913,9 @@ class Dict(modal.object.Object):
             """
             ...
 
-    __delitem__: ____delitem___spec[typing_extensions.Self]
+    __delitem__: ____delitem___spec
 
-    class ____contains___spec(typing_extensions.Protocol[SUPERSELF]):
+    class ____contains___spec(typing_extensions.Protocol):
         def __call__(self, /, key: typing.Any) -> bool:
             """Return if a key is present.
 
@@ -899,9 +930,9 @@ class Dict(modal.object.Object):
             """
             ...
 
-    __contains__: ____contains___spec[typing_extensions.Self]
+    __contains__: ____contains___spec
 
-    class __keys_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __keys_spec(typing_extensions.Protocol):
         def __call__(self, /) -> typing.Iterator[typing.Any]:
             """Return an iterator over the keys in this Dict.
 
@@ -918,9 +949,9 @@ class Dict(modal.object.Object):
             """
             ...
 
-    keys: __keys_spec[typing_extensions.Self]
+    keys: __keys_spec
 
-    class __values_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __values_spec(typing_extensions.Protocol):
         def __call__(self, /) -> typing.Iterator[typing.Any]:
             """Return an iterator over the values in this Dict.
 
@@ -937,9 +968,9 @@ class Dict(modal.object.Object):
             """
             ...
 
-    values: __values_spec[typing_extensions.Self]
+    values: __values_spec
 
-    class __items_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __items_spec(typing_extensions.Protocol):
         def __call__(self, /) -> typing.Iterator[tuple[typing.Any, typing.Any]]:
             """Return an iterator over the (key, value) tuples in this Dict.
 
@@ -956,4 +987,4 @@ class Dict(modal.object.Object):
             """
             ...
 
-    items: __items_spec[typing_extensions.Self]
+    items: __items_spec

modal/environments.py

@@ -8,10 +8,10 @@ from google.protobuf.wrappers_pb2 import StringValue
 
 from modal_proto import api_pb2
 
+from ._load_context import LoadContext
 from ._object import _Object
 from ._resolver import Resolver
 from ._utils.async_utils import synchronize_api, synchronizer
-from ._utils.grpc_utils import retry_transient_errors
 from ._utils.name_utils import check_object_name
 from .client import _Client
 from .config import config, logger
@@ -53,6 +53,7 @@ class _Environment(_Object, type_prefix="en"):
         name: str,
         *,
         create_if_missing: bool = False,
+        client: Optional[_Client] = None,
     ):
         if name:
             # Allow null names for the case where we want to look up the "default" environment,
@@ -62,7 +63,9 @@ class _Environment(_Object, type_prefix="en"):
             # environments as part of public API when we make this class more useful.
             check_object_name(name, "Environment")
 
-        async def _load(self: _Environment, resolver: Resolver, existing_object_id: Optional[str]):
+        async def _load(
+            self: _Environment, resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]
+        ):
             request = api_pb2.EnvironmentGetOrCreateRequest(
                 deployment_name=name,
                 object_creation_type=(
@@ -71,12 +74,17 @@ class _Environment(_Object, type_prefix="en"):
                     else api_pb2.OBJECT_CREATION_TYPE_UNSPECIFIED
                 ),
             )
-            response = await retry_transient_errors(resolver.client.stub.EnvironmentGetOrCreate, request)
+            response = await load_context.client.stub.EnvironmentGetOrCreate(request)
             logger.debug(f"Created environment with id {response.environment_id}")
-            self._hydrate(response.environment_id, resolver.client, response.metadata)
-
-        # TODO environment name (and id?) in the repr? (We should make reprs consistently more useful)
-        return _Environment._from_loader(_load, "Environment()", is_another_app=True, hydrate_lazily=True)
+            self._hydrate(response.environment_id, load_context.client, response.metadata)
+
+        return _Environment._from_loader(
+            _load,
+            f"Environment.from_name({name!r})",
+            is_another_app=True,
+            hydrate_lazily=True,
+            load_context_overrides=LoadContext(client=client),
+        )
 
 
 Environment = synchronize_api(_Environment)
@@ -89,7 +97,7 @@ ENVIRONMENT_CACHE: dict[str, _Environment] = {}
 async def _get_environment_cached(name: str, client: _Client) -> _Environment:
     if name in ENVIRONMENT_CACHE:
         return ENVIRONMENT_CACHE[name]
-    environment = await _Environment.from_name(name).hydrate(client)
+    environment = await _Environment.from_name(name, client=client).hydrate()
     ENVIRONMENT_CACHE[name] = environment
     return environment
 

modal/environments.pyi

@@ -45,7 +45,9 @@ class _Environment(modal._object._Object):
 
     def _hydrate_metadata(self, metadata: google.protobuf.message.Message): ...
     @staticmethod
-    def from_name(name: str, *, create_if_missing: bool = False): ...
+    def from_name(
+        name: str, *, create_if_missing: bool = False, client: typing.Optional[modal.client._Client] = None
+    ): ...
 
 class Environment(modal.object.Object):
     _settings: EnvironmentSettings
@@ -56,7 +58,9 @@ class Environment(modal.object.Object):
 
     def _hydrate_metadata(self, metadata: google.protobuf.message.Message): ...
     @staticmethod
-    def from_name(name: str, *, create_if_missing: bool = False): ...
+    def from_name(
+        name: str, *, create_if_missing: bool = False, client: typing.Optional[modal.client.Client] = None
+    ): ...
 
 async def _get_environment_cached(name: str, client: modal.client._Client) -> _Environment: ...