modal 0.72.38__py3-none-any.whl → 0.72.40__py3-none-any.whl

modal/_object.py

@@ -8,9 +8,9 @@ from typing import Callable, ClassVar, Optional
 from google.protobuf.message import Message
 from typing_extensions import Self
 
-from modal._utils.async_utils import aclosing
-
 from ._resolver import Resolver
+from ._utils.async_utils import aclosing
+from ._utils.deprecation import deprecation_warning
 from .client import _Client
 from .config import config, logger
 from .exception import ExecutionError, InvalidError
@@ -238,10 +238,29 @@ class _Object:
 
     async def resolve(self, client: Optional[_Client] = None):
         """mdmd:hidden"""
+        obj = self.__class__.__name__.strip("_")
+        deprecation_warning(
+            (2025, 1, 16),
+            f"The `{obj}.resolve` method is deprecated and will be removed in a future release."
+            f" Please use `{obj}.hydrate()` or `await {obj}.hydrate.aio()` instead."
+            "\n\nNote that it is rarely necessary to explicitly hydrate objects, as most methods"
+            " will lazily hydrate when needed.",
+            show_source=False,  # synchronicity interferes with attributing source correctly
+            pending=True,
+        )
+        await self.hydrate(client)
+
+    async def hydrate(self, client: Optional[_Client] = None) -> Self:
+        """Synchronize the local object with its identity on the Modal server.
+
+        It is rarely necessary to call this method explicitly, as most operations
+        will lazily hydrate when needed. The main use case is when you need to
+        access object metadata, such as its ID.
+        """
         if self._is_hydrated:
-            # memory snapshots capture references which must be rehydrated
-            # on restore to handle staleness.
             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()
@@ -249,20 +268,20 @@ class _Object:
                 await resolver.load(typing.cast(_Object, self))
                 self._is_rehydrated = True
                 logger.debug(f"rehydrated {self} with client {id(c)}")
-            return
         elif not self._hydrate_lazily:
+            # TODO(michael) can remove _hydrate lazily? I think all objects support it now?
             self._validate_is_hydrated()
         else:
-            # TODO: this client and/or resolver can't be changed by a caller to X.from_name()
             c = client if client is not None else await _Client.from_env()
             resolver = Resolver(c)
             await resolver.load(self)
+        return self
 
 
 def live_method(method):
     @wraps(method)
     async def wrapped(self, *args, **kwargs):
-        await self.resolve()
+        await self.hydrate()
         return await method(self, *args, **kwargs)
 
     return wrapped
@@ -271,7 +290,7 @@ def live_method(method):
 def live_method_gen(method):
     @wraps(method)
     async def wrapped(self, *args, **kwargs):
-        await self.resolve()
+        await self.hydrate()
         async with aclosing(method(self, *args, **kwargs)) as stream:
             async for item in stream:
                 yield item

modal/app.pyi

@@ -67,10 +67,12 @@ class _FunctionDecoratorType:
     ) -> modal.functions.Function[P, ReturnType, OriginalReturnType]: ...
     @typing.overload
     def __call__(
-        self, func: typing.Callable[P, collections.abc.Coroutine[typing.Any, typing.Any, ReturnType]]
+        self, func: collections.abc.Callable[P, collections.abc.Coroutine[typing.Any, typing.Any, ReturnType]]
     ) -> modal.functions.Function[P, ReturnType, collections.abc.Coroutine[typing.Any, typing.Any, ReturnType]]: ...
     @typing.overload
-    def __call__(self, func: typing.Callable[P, ReturnType]) -> modal.functions.Function[P, ReturnType, ReturnType]: ...
+    def __call__(
+        self, func: collections.abc.Callable[P, ReturnType]
+    ) -> modal.functions.Function[P, ReturnType, ReturnType]: ...
 
 class _App:
     _all_apps: typing.ClassVar[dict[typing.Optional[str], list[_App]]]
@@ -152,7 +154,7 @@ class _App:
     def registered_web_endpoints(self) -> list[str]: ...
     def local_entrypoint(
         self, _warn_parentheses_missing: typing.Any = None, *, name: typing.Optional[str] = None
-    ) -> typing.Callable[[typing.Callable[..., typing.Any]], _LocalEntrypoint]: ...
+    ) -> collections.abc.Callable[[collections.abc.Callable[..., typing.Any]], _LocalEntrypoint]: ...
     def function(
         self,
         _warn_parentheses_missing: typing.Any = None,
@@ -238,7 +240,7 @@ class _App:
         _experimental_buffer_containers: typing.Optional[int] = None,
         _experimental_proxy_ip: typing.Optional[str] = None,
         _experimental_custom_scaling_factor: typing.Optional[float] = None,
-    ) -> typing.Callable[[CLS_T], CLS_T]: ...
+    ) -> collections.abc.Callable[[CLS_T], CLS_T]: ...
     async def spawn_sandbox(
         self,
         *entrypoint_args: str,
@@ -272,6 +274,8 @@ class _App:
     @classmethod
     def _reset_container_app(cls): ...
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 class App:
     _all_apps: typing.ClassVar[dict[typing.Optional[str], list[App]]]
     _container_app: typing.ClassVar[typing.Optional[App]]
@@ -337,7 +341,7 @@ class App:
     def image(self, value): ...
     def _uncreate_all_objects(self): ...
 
-    class ___set_local_app_spec(typing_extensions.Protocol):
+    class ___set_local_app_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self, client: modal.client.Client, running_app: modal.running_app.RunningApp
         ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]: ...
@@ -345,9 +349,9 @@ class App:
             self, client: modal.client.Client, running_app: modal.running_app.RunningApp
         ) -> typing.AsyncContextManager[None]: ...
 
-    _set_local_app: ___set_local_app_spec
+    _set_local_app: ___set_local_app_spec[typing_extensions.Self]
 
-    class __run_spec(typing_extensions.Protocol):
+    class __run_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self,
             client: typing.Optional[modal.client.Client] = None,
@@ -365,7 +369,7 @@ class App:
             environment_name: typing.Optional[str] = None,
         ) -> typing.AsyncContextManager[App]: ...
 
-    run: __run_spec
+    run: __run_spec[typing_extensions.Self]
 
     def _get_default_image(self): ...
     def _get_watch_mounts(self): ...
@@ -384,7 +388,7 @@ class App:
     def registered_web_endpoints(self) -> list[str]: ...
     def local_entrypoint(
         self, _warn_parentheses_missing: typing.Any = None, *, name: typing.Optional[str] = None
-    ) -> typing.Callable[[typing.Callable[..., typing.Any]], LocalEntrypoint]: ...
+    ) -> collections.abc.Callable[[collections.abc.Callable[..., typing.Any]], LocalEntrypoint]: ...
     def function(
         self,
         _warn_parentheses_missing: typing.Any = None,
@@ -470,9 +474,9 @@ class App:
         _experimental_buffer_containers: typing.Optional[int] = None,
         _experimental_proxy_ip: typing.Optional[str] = None,
         _experimental_custom_scaling_factor: typing.Optional[float] = None,
-    ) -> typing.Callable[[CLS_T], CLS_T]: ...
+    ) -> collections.abc.Callable[[CLS_T], CLS_T]: ...
 
-    class __spawn_sandbox_spec(typing_extensions.Protocol):
+    class __spawn_sandbox_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self,
             *entrypoint_args: str,
@@ -522,11 +526,11 @@ class App:
             _experimental_scheduler_placement: typing.Optional[modal.scheduler_placement.SchedulerPlacement] = None,
         ) -> None: ...
 
-    spawn_sandbox: __spawn_sandbox_spec
+    spawn_sandbox: __spawn_sandbox_spec[typing_extensions.Self]
 
     def include(self, /, other_app: App): ...
 
-    class ___logs_spec(typing_extensions.Protocol):
+    class ___logs_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self, client: typing.Optional[modal.client.Client] = None
         ) -> typing.Generator[str, None, None]: ...
@@ -534,7 +538,7 @@ class App:
             self, client: typing.Optional[modal.client.Client] = None
         ) -> collections.abc.AsyncGenerator[str, None]: ...
 
-    _logs: ___logs_spec
+    _logs: ___logs_spec[typing_extensions.Self]
 
     @classmethod
     def _get_container_app(cls) -> typing.Optional[App]: ...

modal/client.pyi

@@ -27,7 +27,7 @@ class _Client:
     _snapshotted: bool
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.72.38"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.72.40"
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -74,6 +74,8 @@ class _Client:
         ],
     ) -> collections.abc.AsyncGenerator[typing.Any, None]: ...
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 class Client:
     _client_from_env: typing.ClassVar[typing.Optional[Client]]
     _client_from_env_lock: typing.ClassVar[typing.Optional[asyncio.locks.Lock]]
@@ -83,29 +85,29 @@ class Client:
     _snapshotted: bool
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.72.38"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.72.40"
     ): ...
     def is_closed(self) -> bool: ...
     @property
     def stub(self) -> modal_proto.modal_api_grpc.ModalClientModal: ...
 
-    class ___open_spec(typing_extensions.Protocol):
+    class ___open_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self): ...
         async def aio(self): ...
 
-    _open: ___open_spec
+    _open: ___open_spec[typing_extensions.Self]
 
-    class ___close_spec(typing_extensions.Protocol):
+    class ___close_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, prep_for_restore: bool = False): ...
         async def aio(self, prep_for_restore: bool = False): ...
 
-    _close: ___close_spec
+    _close: ___close_spec[typing_extensions.Self]
 
-    class __hello_spec(typing_extensions.Protocol):
+    class __hello_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self): ...
         async def aio(self): ...
 
-    hello: __hello_spec
+    hello: __hello_spec[typing_extensions.Self]
 
     def __enter__(self): ...
     async def __aenter__(self): ...
@@ -122,23 +124,23 @@ class Client:
     @classmethod
     def set_env_client(cls, client: typing.Optional[Client]): ...
 
-    class ___call_safely_spec(typing_extensions.Protocol):
+    class ___call_safely_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, coro, readable_method: str): ...
         async def aio(self, coro, readable_method: str): ...
 
-    _call_safely: ___call_safely_spec
+    _call_safely: ___call_safely_spec[typing_extensions.Self]
 
-    class ___reset_on_pid_change_spec(typing_extensions.Protocol):
+    class ___reset_on_pid_change_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self): ...
         async def aio(self): ...
 
-    _reset_on_pid_change: ___reset_on_pid_change_spec
+    _reset_on_pid_change: ___reset_on_pid_change_spec[typing_extensions.Self]
 
-    class ___get_grpclib_method_spec(typing_extensions.Protocol):
+    class ___get_grpclib_method_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, method_name: str) -> typing.Any: ...
         async def aio(self, method_name: str) -> typing.Any: ...
 
-    _get_grpclib_method: ___get_grpclib_method_spec
+    _get_grpclib_method: ___get_grpclib_method_spec[typing_extensions.Self]
 
     async def _call_unary(
         self,

modal/cls.pyi

@@ -55,6 +55,8 @@ class _Obj:
     async def _aenter(self): ...
     def __getattr__(self, k): ...
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 class Obj:
     _cls: Cls
     _functions: dict[str, modal.functions.Function]
@@ -77,11 +79,11 @@ class Obj:
     def _get_parameter_values(self) -> dict[str, typing.Any]: ...
     def _new_user_cls_instance(self): ...
 
-    class __keep_warm_spec(typing_extensions.Protocol):
+    class __keep_warm_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, warm_pool_size: int) -> None: ...
         async def aio(self, warm_pool_size: int) -> None: ...
 
-    keep_warm: __keep_warm_spec
+    keep_warm: __keep_warm_spec[typing_extensions.Self]
 
     def _cached_user_cls_instance(self): ...
     def _enter(self): ...
@@ -97,7 +99,7 @@ class _Cls(modal._object._Object):
     _class_service_function: typing.Optional[modal.functions._Function]
     _method_functions: typing.Optional[dict[str, modal.functions._Function]]
     _options: typing.Optional[modal_proto.api_pb2.FunctionOptions]
-    _callables: dict[str, typing.Callable[..., typing.Any]]
+    _callables: dict[str, collections.abc.Callable[..., typing.Any]]
     _app: typing.Optional[modal.app._App]
     _name: typing.Optional[str]
 
@@ -154,7 +156,7 @@ class Cls(modal.object.Object):
     _class_service_function: typing.Optional[modal.functions.Function]
     _method_functions: typing.Optional[dict[str, modal.functions.Function]]
     _options: typing.Optional[modal_proto.api_pb2.FunctionOptions]
-    _callables: dict[str, typing.Callable[..., typing.Any]]
+    _callables: dict[str, collections.abc.Callable[..., typing.Any]]
     _app: typing.Optional[modal.app.App]
     _name: typing.Optional[str]
 

modal/container_process.pyi

@@ -36,6 +36,8 @@ class _ContainerProcess(typing.Generic[T]):
     async def wait(self) -> int: ...
     async def attach(self, *, pty: typing.Optional[bool] = None): ...
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 class ContainerProcess(typing.Generic[T]):
     _process_id: typing.Optional[str]
     _stdout: modal.io_streams.StreamReader[T]
@@ -63,20 +65,20 @@ class ContainerProcess(typing.Generic[T]):
     @property
     def returncode(self) -> int: ...
 
-    class __poll_spec(typing_extensions.Protocol):
+    class __poll_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> typing.Optional[int]: ...
         async def aio(self) -> typing.Optional[int]: ...
 
-    poll: __poll_spec
+    poll: __poll_spec[typing_extensions.Self]
 
-    class __wait_spec(typing_extensions.Protocol):
+    class __wait_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> int: ...
         async def aio(self) -> int: ...
 
-    wait: __wait_spec
+    wait: __wait_spec[typing_extensions.Self]
 
-    class __attach_spec(typing_extensions.Protocol):
+    class __attach_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, *, pty: typing.Optional[bool] = None): ...
         async def aio(self, *, pty: typing.Optional[bool] = None): ...
 
-    attach: __attach_spec
+    attach: __attach_spec[typing_extensions.Self]

modal/dict.pyi

@@ -57,6 +57,8 @@ class _Dict(modal._object._Object):
     def values(self) -> collections.abc.AsyncIterator[typing.Any]: ...
     def items(self) -> collections.abc.AsyncIterator[tuple[typing.Any, typing.Any]]: ...
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 class Dict(modal.object.Object):
     def __init__(self, data={}): ...
     @classmethod
@@ -116,86 +118,86 @@ class Dict(modal.object.Object):
 
     delete: __delete_spec
 
-    class __clear_spec(typing_extensions.Protocol):
+    class __clear_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> None: ...
         async def aio(self) -> None: ...
 
-    clear: __clear_spec
+    clear: __clear_spec[typing_extensions.Self]
 
-    class __get_spec(typing_extensions.Protocol):
+    class __get_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any, default: typing.Optional[typing.Any] = None) -> typing.Any: ...
         async def aio(self, key: typing.Any, default: typing.Optional[typing.Any] = None) -> typing.Any: ...
 
-    get: __get_spec
+    get: __get_spec[typing_extensions.Self]
 
-    class __contains_spec(typing_extensions.Protocol):
+    class __contains_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any) -> bool: ...
         async def aio(self, key: typing.Any) -> bool: ...
 
-    contains: __contains_spec
+    contains: __contains_spec[typing_extensions.Self]
 
-    class __len_spec(typing_extensions.Protocol):
+    class __len_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> int: ...
         async def aio(self) -> int: ...
 
-    len: __len_spec
+    len: __len_spec[typing_extensions.Self]
 
-    class ____getitem___spec(typing_extensions.Protocol):
+    class ____getitem___spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any) -> typing.Any: ...
         async def aio(self, key: typing.Any) -> typing.Any: ...
 
-    __getitem__: ____getitem___spec
+    __getitem__: ____getitem___spec[typing_extensions.Self]
 
-    class __update_spec(typing_extensions.Protocol):
+    class __update_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, **kwargs) -> None: ...
         async def aio(self, **kwargs) -> None: ...
 
-    update: __update_spec
+    update: __update_spec[typing_extensions.Self]
 
-    class __put_spec(typing_extensions.Protocol):
+    class __put_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any, value: typing.Any) -> None: ...
         async def aio(self, key: typing.Any, value: typing.Any) -> None: ...
 
-    put: __put_spec
+    put: __put_spec[typing_extensions.Self]
 
-    class ____setitem___spec(typing_extensions.Protocol):
+    class ____setitem___spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any, value: typing.Any) -> None: ...
         async def aio(self, key: typing.Any, value: typing.Any) -> None: ...
 
-    __setitem__: ____setitem___spec
+    __setitem__: ____setitem___spec[typing_extensions.Self]
 
-    class __pop_spec(typing_extensions.Protocol):
+    class __pop_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any) -> typing.Any: ...
         async def aio(self, key: typing.Any) -> typing.Any: ...
 
-    pop: __pop_spec
+    pop: __pop_spec[typing_extensions.Self]
 
-    class ____delitem___spec(typing_extensions.Protocol):
+    class ____delitem___spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any) -> typing.Any: ...
         async def aio(self, key: typing.Any) -> typing.Any: ...
 
-    __delitem__: ____delitem___spec
+    __delitem__: ____delitem___spec[typing_extensions.Self]
 
-    class ____contains___spec(typing_extensions.Protocol):
+    class ____contains___spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, key: typing.Any) -> bool: ...
         async def aio(self, key: typing.Any) -> bool: ...
 
-    __contains__: ____contains___spec
+    __contains__: ____contains___spec[typing_extensions.Self]
 
-    class __keys_spec(typing_extensions.Protocol):
+    class __keys_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> typing.Iterator[typing.Any]: ...
         def aio(self) -> collections.abc.AsyncIterator[typing.Any]: ...
 
-    keys: __keys_spec
+    keys: __keys_spec[typing_extensions.Self]
 
-    class __values_spec(typing_extensions.Protocol):
+    class __values_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> typing.Iterator[typing.Any]: ...
         def aio(self) -> collections.abc.AsyncIterator[typing.Any]: ...
 
-    values: __values_spec
+    values: __values_spec[typing_extensions.Self]
 
-    class __items_spec(typing_extensions.Protocol):
+    class __items_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> typing.Iterator[tuple[typing.Any, typing.Any]]: ...
         def aio(self) -> collections.abc.AsyncIterator[tuple[typing.Any, typing.Any]]: ...
 
-    items: __items_spec
+    items: __items_spec[typing_extensions.Self]

modal/file_io.pyi

@@ -100,6 +100,8 @@ class __replace_bytes_spec(typing_extensions.Protocol):
 
 replace_bytes: __replace_bytes_spec
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 T_INNER = typing.TypeVar("T_INNER", covariant=True)
 
 class FileIO(typing.Generic[T]):
@@ -112,37 +114,37 @@ class FileIO(typing.Generic[T]):
     def _validate_mode(self, mode: str) -> None: ...
     def _handle_error(self, error: modal_proto.api_pb2.SystemErrorMessage) -> None: ...
 
-    class ___consume_output_spec(typing_extensions.Protocol):
+    class ___consume_output_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, exec_id: str) -> typing.Iterator[typing.Optional[bytes]]: ...
         def aio(self, exec_id: str) -> typing.AsyncIterator[typing.Optional[bytes]]: ...
 
-    _consume_output: ___consume_output_spec
+    _consume_output: ___consume_output_spec[typing_extensions.Self]
 
-    class ___consume_watch_output_spec(typing_extensions.Protocol):
+    class ___consume_watch_output_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, exec_id: str) -> None: ...
         async def aio(self, exec_id: str) -> None: ...
 
-    _consume_watch_output: ___consume_watch_output_spec
+    _consume_watch_output: ___consume_watch_output_spec[typing_extensions.Self]
 
-    class ___parse_watch_output_spec(typing_extensions.Protocol):
+    class ___parse_watch_output_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, event: bytes) -> typing.Optional[FileWatchEvent]: ...
         async def aio(self, event: bytes) -> typing.Optional[FileWatchEvent]: ...
 
-    _parse_watch_output: ___parse_watch_output_spec
+    _parse_watch_output: ___parse_watch_output_spec[typing_extensions.Self]
 
-    class ___wait_spec(typing_extensions.Protocol):
+    class ___wait_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, exec_id: str) -> bytes: ...
         async def aio(self, exec_id: str) -> bytes: ...
 
-    _wait: ___wait_spec
+    _wait: ___wait_spec[typing_extensions.Self]
 
     def _validate_type(self, data: typing.Union[bytes, str]) -> None: ...
 
-    class ___open_file_spec(typing_extensions.Protocol):
+    class ___open_file_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, path: str, mode: str) -> None: ...
         async def aio(self, path: str, mode: str) -> None: ...
 
-    _open_file: ___open_file_spec
+    _open_file: ___open_file_spec[typing_extensions.Self]
 
     @classmethod
     def create(
@@ -153,49 +155,49 @@ class FileIO(typing.Generic[T]):
         task_id: str,
     ) -> FileIO: ...
 
-    class ___make_read_request_spec(typing_extensions.Protocol):
+    class ___make_read_request_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, n: typing.Optional[int]) -> bytes: ...
         async def aio(self, n: typing.Optional[int]) -> bytes: ...
 
-    _make_read_request: ___make_read_request_spec
+    _make_read_request: ___make_read_request_spec[typing_extensions.Self]
 
-    class __read_spec(typing_extensions.Protocol[T_INNER]):
+    class __read_spec(typing_extensions.Protocol[T_INNER, SUPERSELF]):
         def __call__(self, n: typing.Optional[int] = None) -> T_INNER: ...
         async def aio(self, n: typing.Optional[int] = None) -> T_INNER: ...
 
-    read: __read_spec[T]
+    read: __read_spec[T, typing_extensions.Self]
 
-    class __readline_spec(typing_extensions.Protocol[T_INNER]):
+    class __readline_spec(typing_extensions.Protocol[T_INNER, SUPERSELF]):
         def __call__(self) -> T_INNER: ...
         async def aio(self) -> T_INNER: ...
 
-    readline: __readline_spec[T]
+    readline: __readline_spec[T, typing_extensions.Self]
 
-    class __readlines_spec(typing_extensions.Protocol[T_INNER]):
+    class __readlines_spec(typing_extensions.Protocol[T_INNER, SUPERSELF]):
         def __call__(self) -> typing.Sequence[T_INNER]: ...
         async def aio(self) -> typing.Sequence[T_INNER]: ...
 
-    readlines: __readlines_spec[T]
+    readlines: __readlines_spec[T, typing_extensions.Self]
 
-    class __write_spec(typing_extensions.Protocol):
+    class __write_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, data: typing.Union[bytes, str]) -> None: ...
         async def aio(self, data: typing.Union[bytes, str]) -> None: ...
 
-    write: __write_spec
+    write: __write_spec[typing_extensions.Self]
 
-    class __flush_spec(typing_extensions.Protocol):
+    class __flush_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> None: ...
         async def aio(self) -> None: ...
 
-    flush: __flush_spec
+    flush: __flush_spec[typing_extensions.Self]
 
     def _get_whence(self, whence: int): ...
 
-    class __seek_spec(typing_extensions.Protocol):
+    class __seek_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, offset: int, whence: int = 0) -> None: ...
         async def aio(self, offset: int, whence: int = 0) -> None: ...
 
-    seek: __seek_spec
+    seek: __seek_spec[typing_extensions.Self]
 
     @classmethod
     def ls(cls, path: str, client: modal.client.Client, task_id: str) -> list[str]: ...
@@ -214,17 +216,17 @@ class FileIO(typing.Generic[T]):
         timeout: typing.Optional[int] = None,
     ) -> typing.Iterator[FileWatchEvent]: ...
 
-    class ___close_spec(typing_extensions.Protocol):
+    class ___close_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> None: ...
         async def aio(self) -> None: ...
 
-    _close: ___close_spec
+    _close: ___close_spec[typing_extensions.Self]
 
-    class __close_spec(typing_extensions.Protocol):
+    class __close_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> None: ...
         async def aio(self) -> None: ...
 
-    close: __close_spec
+    close: __close_spec[typing_extensions.Self]
 
     def _check_writable(self) -> None: ...
     def _check_readable(self) -> None: ...

modal/functions.py

@@ -1207,12 +1207,13 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     async def is_generator(self) -> bool:
         """mdmd:hidden"""
         # hacky: kind of like @live_method, but not hydrating if we have the value already from local source
+        # TODO(michael) use a common / lightweight method for handling unhydrated metadata properties
         if self._is_generator is not None:
             # this is set if the function or class is local
             return self._is_generator
 
         # not set - this is a from_name lookup - hydrate
-        await self.resolve()
+        await self.hydrate()
         assert self._is_generator is not None  # should be set now
         return self._is_generator