modal 1.2.2.dev30__py3-none-any.whl → 1.2.2.dev36__py3-none-any.whl

modal/_functions.py

@@ -19,7 +19,8 @@ from synchronicity.combined_types import MethodWithAio
 from modal_proto import api_pb2
 from modal_proto.modal_api_grpc import ModalClientModal
 
-from ._object import _get_environment_name, _Object, live_method, live_method_gen
+from ._load_context import LoadContext
+from ._object import _Object, live_method, live_method_gen
 from ._pty import get_pty_info
 from ._resolver import Resolver
 from ._resources import convert_fn_config_to_resources_config
@@ -656,7 +657,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     @staticmethod
     def from_local(
         info: FunctionInfo,
-        app,
+        app: Optional["modal.app._App"],  # App here should only be None in case of Image.run_function
         image: _Image,
         env: Optional[dict[str, Optional[str]]] = None,
         secrets: Optional[Collection[_Secret]] = None,
@@ -882,12 +883,12 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 is_web_endpoint, is_generator, restrict_output
             )
 
-        async def _preload(self: _Function, resolver: Resolver, existing_object_id: Optional[str]):
-            assert resolver.client and resolver.client.stub
-
-            assert resolver.app_id
+        async def _preload(
+            self: _Function, resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]
+        ):
+            assert load_context.app_id
             req = api_pb2.FunctionPrecreateRequest(
-                app_id=resolver.app_id,
+                app_id=load_context.app_id,
                 function_name=info.function_name,
                 function_type=function_type,
                 existing_function_id=existing_object_id or "",
@@ -903,11 +904,12 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             elif webhook_config:
                 req.webhook_config.CopyFrom(webhook_config)
 
-            response = await resolver.client.stub.FunctionPrecreate(req)
-            self._hydrate(response.function_id, resolver.client, response.handle_metadata)
+            response = await load_context.client.stub.FunctionPrecreate(req)
+            self._hydrate(response.function_id, load_context.client, response.handle_metadata)
 
-        async def _load(self: _Function, resolver: Resolver, existing_object_id: Optional[str]):
-            assert resolver.client and resolver.client.stub
+        async def _load(
+            self: _Function, resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]
+        ):
             with FunctionCreationStatus(resolver, tag) as function_creation_status:
                 timeout_secs = timeout
 
@@ -1103,16 +1105,16 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         ),
                     )
 
-                assert resolver.app_id
+                assert load_context.app_id
                 assert (function_definition is None) != (function_data is None)  # xor
                 request = api_pb2.FunctionCreateRequest(
-                    app_id=resolver.app_id,
+                    app_id=load_context.app_id,
                     function=function_definition,
                     function_data=function_data,
                     existing_function_id=existing_object_id or "",
                 )
                 try:
-                    response: api_pb2.FunctionCreateResponse = await resolver.client.stub.FunctionCreate(request)
+                    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)
@@ -1127,10 +1129,14 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             serve_mounts = {m for m in all_mounts if m.is_local()}
             serve_mounts |= image._serve_mounts
             obj._serve_mounts = frozenset(serve_mounts)
-            self._hydrate(response.function_id, resolver.client, response.handle_metadata)
+            self._hydrate(response.function_id, load_context.client, response.handle_metadata)
 
         rep = f"Function({tag})"
-        obj = _Function._from_loader(_load, rep, preload=_preload, deps=_deps)
+        # Pass a *reference* to the App's LoadContext - this is important since the App is
+        # the only way to infer a LoadContext for an `@app.function`, and the App doesn't
+        # get its client until *after* the Function is created.
+        load_context = app._root_load_context if app else LoadContext.empty()
+        obj = _Function._from_loader(_load, rep, preload=_preload, deps=_deps, load_context_overrides=load_context)
 
         obj._raw_f = info.raw_f
         obj._info = info
@@ -1172,7 +1178,12 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
         parent = self
 
-        async def _load(param_bound_func: _Function, resolver: Resolver, existing_object_id: Optional[str]):
+        async def _load(
+            param_bound_func: _Function,
+            resolver: Resolver,
+            load_context: LoadContext,
+            existing_object_id: Optional[str],
+        ):
             if not parent.is_hydrated:
                 # While the base Object.hydrate() method appears to be idempotent, it's not always safe
                 await parent.hydrate()
@@ -1205,7 +1216,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 param_bound_func._hydrate_from_other(parent)
                 return
 
-            environment_name = _get_environment_name(None, resolver)
             assert parent is not None and parent.is_hydrated
 
             if options:
@@ -1245,7 +1255,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 function_id=parent.object_id,
                 serialized_params=serialized_params,
                 function_options=options_pb,
-                environment_name=environment_name
+                environment_name=load_context.environment_name
                 or "",  # TODO: investigate shouldn't environment name always be specified here?
             )
 
@@ -1262,7 +1272,13 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 return [dep for dep in all_deps if not dep.is_hydrated]
             return []
 
-        fun: _Function = _Function._from_loader(_load, "Function(parametrized)", hydrate_lazily=True, deps=_deps)
+        fun: _Function = _Function._from_loader(
+            _load,
+            "Function(parametrized)",
+            hydrate_lazily=True,
+            deps=_deps,
+            load_context_overrides=self._load_context_overrides,
+        )
 
         fun._info = self._info
         fun._obj = obj
@@ -1360,34 +1376,43 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         cls,
         app_name: str,
         name: str,
-        namespace=None,  # mdmd:line-hidden
-        environment_name: Optional[str] = None,
+        *,
+        load_context_overrides: LoadContext,
     ):
         # internal function lookup implementation that allows lookup of class "service functions"
         # in addition to non-class functions
-        async def _load_remote(self: _Function, resolver: Resolver, existing_object_id: Optional[str]):
-            assert resolver.client and resolver.client.stub
+        async def _load_remote(
+            self: _Function, resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]
+        ):
             request = api_pb2.FunctionGetRequest(
                 app_name=app_name,
                 object_tag=name,
-                environment_name=_get_environment_name(environment_name, resolver) or "",
+                environment_name=load_context.environment_name,
             )
             try:
-                response = await resolver.client.stub.FunctionGet(request)
+                response = await load_context.client.stub.FunctionGet(request)
             except NotFoundError as exc:
                 # refine the error message
-                env_context = f" (in the '{environment_name}' environment)" if environment_name else ""
+                env_context = (
+                    f" (in the '{load_context.environment_name}' environment)" if load_context.environment_name else ""
+                )
                 raise NotFoundError(
                     f"Lookup failed for Function '{name}' from the '{app_name}' app{env_context}: {exc}."
                 ) from None
 
             print_server_warnings(response.server_warnings)
 
-            self._hydrate(response.function_id, resolver.client, response.handle_metadata)
+            self._hydrate(response.function_id, load_context.client, response.handle_metadata)
 
-        environment_rep = f", environment_name={environment_name!r}" if environment_name else ""
+        environment_rep = (
+            f", environment_name={load_context_overrides.environment_name!r}"
+            if load_context_overrides._environment_name  # slightly ugly - checking if _environment_name is overridden
+            else ""
+        )
         rep = f"modal.Function.from_name('{app_name}', '{name}'{environment_rep})"
-        return cls._from_loader(_load_remote, rep, is_another_app=True, hydrate_lazily=True)
+        return cls._from_loader(
+            _load_remote, rep, is_another_app=True, hydrate_lazily=True, load_context_overrides=load_context_overrides
+        )
 
     @classmethod
     def from_name(
@@ -1397,6 +1422,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         *,
         namespace=None,  # mdmd:line-hidden
         environment_name: Optional[str] = None,
+        client: Optional[_Client] = None,
     ) -> "_Function":
         """Reference a Function from a deployed App by its name.
 
@@ -1420,7 +1446,9 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             )
 
         warn_if_passing_namespace(namespace, "modal.Function.from_name")
-        return cls._from_name(app_name, name, environment_name=environment_name)
+        return cls._from_name(
+            app_name, name, load_context_overrides=LoadContext(environment_name=environment_name, client=client)
+        )
 
     @property
     def tag(self) -> str:
@@ -1643,8 +1671,8 @@ Use the `Function.get_web_url()` method instead.
             input_queue,
             self.client,
         )
-        metadata = api_pb2.FunctionCallFromIdResponse(function_call_id=function_call_id, num_inputs=num_inputs)
-        fc: _FunctionCall[ReturnType] = _FunctionCall._new_hydrated(function_call_id, self.client, metadata)
+        fc: _FunctionCall[ReturnType] = _FunctionCall._new_hydrated(function_call_id, self.client, None)
+        fc._num_inputs = num_inputs  # set the cached value of num_inputs
         return fc
 
     async def _call_function(self, args, kwargs) -> ReturnType:
@@ -1913,19 +1941,16 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
     def _invocation(self):
         return _Invocation(self.client.stub, self.object_id, self.client)
 
-    def _hydrate_metadata(self, metadata: Optional[Message]):
-        if not metadata:
-            return
-        assert isinstance(metadata, api_pb2.FunctionCallFromIdResponse)
-        self._num_inputs = metadata.num_inputs
-
     @live_method
     async def num_inputs(self) -> int:
         """Get the number of inputs in the function call."""
-        # Should have been hydrated.
-        assert self._num_inputs is not None
+        if self._num_inputs is None:
+            request = api_pb2.FunctionCallFromIdRequest(function_call_id=self.object_id)
+            resp = await self.client.stub.FunctionCallFromId(request)
+            self._num_inputs = resp.num_inputs  # cached
         return self._num_inputs
 
+    @live_method
     async def get(self, timeout: Optional[float] = None, *, index: int = 0) -> ReturnType:
         """Get the result of the index-th input of the function call.
         `.spawn()` calls have a single output, so only specifying `index=0` is valid.
@@ -1969,6 +1994,7 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         async for _, item in self._invocation().enumerate(start_index=start, end_index=end):
             yield item
 
+    @live_method
     async def get_call_graph(self) -> list[InputInfo]:
         """Returns a structure representing the call graph from a given root
         call ID, along with the status of execution for each node.
@@ -1981,6 +2007,7 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         response = await self._client.stub.FunctionGetCallGraph(request)
         return _reconstruct_call_graph(response)
 
+    @live_method
     async def cancel(
         self,
         # if true, containers running the inputs are forcibly terminated
@@ -2018,20 +2045,18 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         if you no longer have access to the original object returned from `Function.spawn`.
 
         """
-        if client is None:
-            client = await _Client.from_env()
 
-        async def _load(self: _FunctionCall, resolver: Resolver, existing_object_id: Optional[str]):
-            request = api_pb2.FunctionCallFromIdRequest(function_call_id=function_call_id)
-            resp = await resolver.client.stub.FunctionCallFromId(request)
-            self._hydrate(function_call_id, resolver.client, resp)
+        async def _load(
+            self: _FunctionCall, resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]
+        ):
+            # this loader doesn't do anything in practice, but it will get the client from the load_context
+            self._hydrate(function_call_id, load_context.client, None)
 
         rep = f"FunctionCall.from_id({function_call_id!r})"
-        fc: _FunctionCall[Any] = _FunctionCall._from_loader(_load, rep, hydrate_lazily=True)
-        # We already know the object ID, so we can set it directly
-        fc._object_id = function_call_id
-        fc._client = client
-        return fc
+
+        return _FunctionCall._from_loader(
+            _load, rep, hydrate_lazily=True, load_context_overrides=LoadContext(client=client)
+        )
 
     @staticmethod
     async def gather(*function_calls: "_FunctionCall[T]") -> typing.Sequence[T]:

modal/_load_context.py

@@ -0,0 +1,105 @@
+# Copyright Modal Labs 2025
+from typing import Optional
+
+from .client import _Client
+from .config import config
+
+
+class LoadContext:
+    """Encapsulates optional metadata values used during object loading.
+
+    This metadata is set during object construction and propagated through
+    parent-child relationships (e.g., App -> Function, Cls -> Obj -> bound methods).
+    """
+
+    _client: Optional[_Client] = None
+    _environment_name: Optional[str] = None
+    _app_id: Optional[str] = None
+
+    def __init__(
+        self,
+        *,
+        client: Optional[_Client] = None,
+        environment_name: Optional[str] = None,
+        app_id: Optional[str] = None,
+    ):
+        self._client = client
+        self._environment_name = environment_name
+        self._app_id = app_id
+
+    @property
+    def client(self) -> _Client:
+        assert self._client is not None
+        return self._client
+
+    @property
+    def environment_name(self) -> str:
+        assert self._environment_name is not None
+        return self._environment_name
+
+    @property
+    def app_id(self) -> Optional[str]:
+        return self._app_id
+
+    @classmethod
+    def empty(cls) -> "LoadContext":
+        """Create an empty LoadContext with all fields set to None.
+
+        Used when loading objects that don't have a parent context.
+        """
+        return cls(client=None, environment_name=None, app_id=None)
+
+    def merged_with(self, parent: "LoadContext") -> "LoadContext":
+        """Create a new LoadContext with parent values filling in None fields.
+
+        Returns a new LoadContext without mutating self or parent.
+        Values from self take precedence over values from parent.
+        """
+        return LoadContext(
+            client=self._client if self._client is not None else parent._client,
+            environment_name=self._environment_name if self._environment_name is not None else parent._environment_name,
+            app_id=self._app_id if self._app_id is not None else parent._app_id,
+        )  # TODO (elias):  apply_defaults?
+
+    async def apply_defaults(self) -> "LoadContext":
+        """Infer default client and environment_name if not present
+
+        Returns a new instance (no in place mutation)"""
+
+        return LoadContext(
+            client=await _Client.from_env() if self._client is None else self.client,
+            environment_name=self._environment_name or config.get("environment") or "",
+            app_id=self._app_id,
+        )
+
+    def reset(self) -> "LoadContext":
+        self._client = None
+        self._environment_name = None
+        self._app_id = None
+        return self
+
+    async def in_place_upgrade(
+        self, client: Optional[_Client] = None, environment_name: Optional[str] = None, app_id: Optional[str] = None
+    ) -> "LoadContext":
+        """In-place set values if they aren't already set, or set default values
+
+        Intended for Function/Cls hydration specifically
+
+        In those cases, it's important to in-place upgrade/apply_defaults since any "sibling" of the function/cls
+        would share the load context with its parent, and the initial load context overrides may not be sufficient
+        since an `app.deploy()` etc could get arguments that set a new client etc.
+
+        E.g.
+        @app.function()
+        def f():
+            ...
+
+        f2 = Function.with_options(...)
+
+        with app.run(client=...): # hydrates f and f2 at this point
+            ...
+        """
+        self._client = self._client or client or await _Client.from_env()
+        self._environment_name = self._environment_name or environment_name or config.get("environment") or ""
+        self._app_id = self._app_id or app_id
+        return self

modal/_object.py

@@ -10,6 +10,7 @@ from typing_extensions import Self
 
 from modal._traceback import suppress_tb_frames
 
+from ._load_context import LoadContext
 from ._resolver import Resolver
 from ._utils.async_utils import aclosing
 from ._utils.deprecation import deprecation_warning
@@ -20,11 +21,19 @@ from .exception import ExecutionError, InvalidError
 EPHEMERAL_OBJECT_HEARTBEAT_SLEEP: int = 300
 
 
-def _get_environment_name(environment_name: Optional[str] = None, resolver: Optional[Resolver] = None) -> Optional[str]:
+def _get_environment_name(
+    environment_name: Optional[str] = None,
+) -> Optional[str]:
+    """Get environment name from various sources.
+
+    Args:
+        environment_name: Explicitly provided environment name (highest priority)
+
+    Returns:
+        Environment name from first available source, or config default
+    """
     if environment_name:
         return environment_name
-    elif resolver and resolver.environment_name:
-        return resolver.environment_name
     else:
         return config.get("environment")
 
@@ -34,13 +43,14 @@ class _Object:
     _prefix_to_type: ClassVar[dict[str, type]] = {}
 
     # For constructors
-    _load: Optional[Callable[[Self, Resolver, Optional[str]], Awaitable[None]]]
-    _preload: Optional[Callable[[Self, Resolver, Optional[str]], Awaitable[None]]]
+    _load: Optional[Callable[[Self, Resolver, LoadContext, Optional[str]], Awaitable[None]]]
+    _preload: Optional[Callable[[Self, Resolver, LoadContext, Optional[str]], Awaitable[None]]]
     _rep: str
     _is_another_app: bool
     _hydrate_lazily: bool
     _deps: Optional[Callable[..., Sequence["_Object"]]]
     _deduplication_key: Optional[Callable[[], Awaitable[Hashable]]] = None
+    _load_context_overrides: LoadContext
 
     # For hydrated objects
     _object_id: Optional[str]
@@ -66,13 +76,15 @@ class _Object:
     def _init(
         self,
         rep: str,
-        load: Optional[Callable[[Self, Resolver, Optional[str]], Awaitable[None]]] = None,
+        load: Optional[Callable[[Self, Resolver, LoadContext, Optional[str]], Awaitable[None]]] = None,
         is_another_app: bool = False,
-        preload: Optional[Callable[[Self, Resolver, Optional[str]], Awaitable[None]]] = None,
+        preload: Optional[Callable[[Self, Resolver, LoadContext, Optional[str]], Awaitable[None]]] = None,
         hydrate_lazily: bool = False,
         deps: Optional[Callable[..., Sequence["_Object"]]] = None,
         deduplication_key: Optional[Callable[[], Awaitable[Hashable]]] = None,
         name: Optional[str] = None,
+        *,
+        load_context_overrides: Optional[LoadContext] = None,
     ):
         self._local_uuid = str(uuid.uuid4())
         self._load = load
@@ -82,6 +94,9 @@ class _Object:
         self._hydrate_lazily = hydrate_lazily
         self._deps = deps
         self._deduplication_key = deduplication_key
+        self._load_context_overrides = (
+            load_context_overrides if load_context_overrides is not None else LoadContext.empty()
+        )
 
         self._object_id = None
         self._client = None
@@ -163,18 +178,30 @@ class _Object:
     @classmethod
     def _from_loader(
         cls,
-        load: Callable[[Self, Resolver, Optional[str]], Awaitable[None]],
+        load: Callable[[Self, Resolver, LoadContext, Optional[str]], Awaitable[None]],
         rep: str,
         is_another_app: bool = False,
-        preload: Optional[Callable[[Self, Resolver, Optional[str]], Awaitable[None]]] = None,
+        preload: Optional[Callable[[Self, Resolver, LoadContext, Optional[str]], Awaitable[None]]] = None,
         hydrate_lazily: bool = False,
         deps: Optional[Callable[..., Sequence["_Object"]]] = None,
         deduplication_key: Optional[Callable[[], Awaitable[Hashable]]] = None,
         name: Optional[str] = None,
+        *,
+        load_context_overrides: LoadContext,
     ):
         # TODO(erikbern): flip the order of the two first arguments
         obj = _Object.__new__(cls)
-        obj._init(rep, load, is_another_app, preload, hydrate_lazily, deps, deduplication_key, name)
+        obj._init(
+            rep,
+            load,
+            is_another_app,
+            preload,
+            hydrate_lazily,
+            deps,
+            deduplication_key,
+            name,
+            load_context_overrides=load_context_overrides,
+        )
         return obj
 
     @staticmethod
@@ -275,25 +302,27 @@ class _Object:
 
         *Added in v0.72.39*: This method replaces the deprecated `.resolve()` method.
         """
+        # TODO: add deprecation for the client argument here - should be added in constructors instead
         if self._is_hydrated:
             if self.client._snapshotted and not self._is_rehydrated:
                 # memory snapshots capture references which must be rehydrated
                 # on restore to handle staleness.
                 logger.debug(f"rehydrating {self} after snapshot")
                 self._is_hydrated = False  # un-hydrate and re-resolve
-                c = client if client is not None else await _Client.from_env()
-                resolver = Resolver(c)
-                await resolver.load(typing.cast(_Object, self))
+                # Set the client on LoadContext before loading
+                root_load_context = LoadContext(client=client)
+                resolver = Resolver()
+                await resolver.load(typing.cast(_Object, self), root_load_context)
                 self._is_rehydrated = True
-                logger.debug(f"rehydrated {self} with client {id(c)}")
+                logger.debug(f"rehydrated {self} with client {id(self.client)}")
         elif not self._hydrate_lazily:
-            # TODO(michael) can remove _hydrate lazily? I think all objects support it now?
             self._validate_is_hydrated()
         else:
-            c = client if client is not None else await _Client.from_env()
-            resolver = Resolver(c)
+            # Set the client on LoadContext before loading
+            root_load_context = LoadContext(client=client)
+            resolver = Resolver()
             with suppress_tb_frames(1):  # skip this frame by default
-                await resolver.load(self)
+                await resolver.load(self, root_load_context)
         return self
 
 

modal/_resolver.py

@@ -8,17 +8,16 @@ from asyncio import Future
 from collections.abc import Hashable
 from typing import TYPE_CHECKING, Optional
 
+import modal._object
 from modal._traceback import suppress_tb_frames
 from modal_proto import api_pb2
 
+from ._load_context import LoadContext
 from ._utils.async_utils import TaskContext
-from .client import _Client
 
 if TYPE_CHECKING:
     from rich.tree import Tree
 
-    import modal._object
-
 
 class StatusRow:
     def __init__(self, progress: "typing.Optional[Tree]"):
@@ -48,19 +47,10 @@ class StatusRow:
 
 class Resolver:
     _local_uuid_to_future: dict[str, Future]
-    _environment_name: Optional[str]
-    _app_id: Optional[str]
     _deduplication_cache: dict[Hashable, Future]
-    _client: _Client
     _build_start: float
 
-    def __init__(
-        self,
-        client: _Client,
-        *,
-        environment_name: Optional[str] = None,
-        app_id: Optional[str] = None,
-    ):
+    def __init__(self):
         try:
             # TODO(michael) If we don't clean this up more thoroughly, it would probably
             # be good to have a single source of truth for "rich is installed" rather than
@@ -75,9 +65,6 @@ class Resolver:
 
         self._local_uuid_to_future = {}
         self._tree = tree
-        self._client = client
-        self._app_id = app_id
-        self._environment_name = environment_name
         self._deduplication_cache = {}
 
         with tempfile.TemporaryFile() as temp_file:
@@ -85,27 +72,24 @@ class Resolver:
             # to the mtime on mounted files, and want those measurements to have the same resolution.
             self._build_start = os.fstat(temp_file.fileno()).st_mtime
 
-    @property
-    def app_id(self) -> Optional[str]:
-        return self._app_id
-
-    @property
-    def client(self):
-        return self._client
-
-    @property
-    def environment_name(self):
-        return self._environment_name
-
     @property
     def build_start(self) -> float:
         return self._build_start
 
-    async def preload(self, obj, existing_object_id: Optional[str]):
+    async def preload(
+        self, obj: "modal._object._Object", parent_load_context: "LoadContext", existing_object_id: Optional[str]
+    ):
         if obj._preload is not None:
-            await obj._preload(obj, self, existing_object_id)
+            load_context = obj._load_context_overrides.merged_with(parent_load_context)
+            await obj._preload(obj, self, load_context, existing_object_id)
 
-    async def load(self, obj: "modal._object._Object", existing_object_id: Optional[str] = None):
+    async def load(
+        self,
+        obj: "modal._object._Object",
+        parent_load_context: "LoadContext",
+        *,
+        existing_object_id: Optional[str] = None,
+    ):
         if obj._is_hydrated and obj._is_another_app:
             # No need to reload this, it won't typically change
             if obj.local_uuid not in self._local_uuid_to_future:
@@ -129,21 +113,23 @@ class Resolver:
             cached_future = self._deduplication_cache.get(deduplication_key)
             if cached_future:
                 hydrated_object = await cached_future
-                obj._hydrate(hydrated_object.object_id, self._client, hydrated_object._get_metadata())
+                # Use the client from the already-hydrated object
+                obj._hydrate(hydrated_object.object_id, hydrated_object.client, hydrated_object._get_metadata())
                 return obj
 
         if not cached_future:
             # don't run any awaits within this if-block to prevent race conditions
             async def loader():
-                # Wait for all its dependencies
+                load_context = await obj._load_context_overrides.merged_with(parent_load_context).apply_defaults()
+
                 # TODO(erikbern): do we need existing_object_id for those?
-                await TaskContext.gather(*[self.load(dep) for dep in obj.deps()])
+                await TaskContext.gather(*[self.load(dep, load_context) for dep in obj.deps()])
 
                 # Load the object itself
                 if not obj._load:
                     raise Exception(f"Object {obj} has no loader function")
 
-                await obj._load(obj, self, existing_object_id)
+                await obj._load(obj, self, load_context, existing_object_id)
 
                 # Check that the id of functions didn't change
                 # Persisted refs are ignored because their life cycle is managed independently.