modal 0.72.5__py3-none-any.whl → 0.72.48__py3-none-any.whl

modal/network_file_system.pyi

@@ -1,4 +1,5 @@
 import collections.abc
+import modal._object
 import modal.client
 import modal.object
 import modal.volume
@@ -12,7 +13,7 @@ def network_file_system_mount_protos(
     validated_network_file_systems: list[tuple[str, _NetworkFileSystem]], allow_cross_region_volumes: bool
 ) -> list[modal_proto.api_pb2.SharedVolumeMount]: ...
 
-class _NetworkFileSystem(modal.object._Object):
+class _NetworkFileSystem(modal._object._Object):
     @staticmethod
     def from_name(
         name: str, namespace=1, environment_name: typing.Optional[str] = None, create_if_missing: bool = False
@@ -47,7 +48,7 @@ class _NetworkFileSystem(modal.object._Object):
         self,
         remote_path: str,
         fp: typing.BinaryIO,
-        progress_cb: typing.Optional[typing.Callable[..., typing.Any]] = None,
+        progress_cb: typing.Optional[collections.abc.Callable[..., typing.Any]] = None,
     ) -> int: ...
     def read_file(self, path: str) -> collections.abc.AsyncIterator[bytes]: ...
     def iterdir(self, path: str) -> collections.abc.AsyncIterator[modal.volume.FileEntry]: ...
@@ -55,17 +56,19 @@ class _NetworkFileSystem(modal.object._Object):
         self,
         local_path: typing.Union[pathlib.Path, str],
         remote_path: typing.Union[str, pathlib.PurePosixPath, None] = None,
-        progress_cb: typing.Optional[typing.Callable[..., typing.Any]] = None,
+        progress_cb: typing.Optional[collections.abc.Callable[..., typing.Any]] = None,
     ): ...
     async def add_local_dir(
         self,
         local_path: typing.Union[pathlib.Path, str],
         remote_path: typing.Union[str, pathlib.PurePosixPath, None] = None,
-        progress_cb: typing.Optional[typing.Callable[..., typing.Any]] = None,
+        progress_cb: typing.Optional[collections.abc.Callable[..., typing.Any]] = None,
     ): ...
     async def listdir(self, path: str) -> list[modal.volume.FileEntry]: ...
     async def remove_file(self, path: str, recursive=False): ...
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 class NetworkFileSystem(modal.object.Object):
     def __init__(self, *args, **kwargs): ...
     @staticmethod
@@ -134,74 +137,74 @@ class NetworkFileSystem(modal.object.Object):
 
     delete: __delete_spec
 
-    class __write_file_spec(typing_extensions.Protocol):
+    class __write_file_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self,
             remote_path: str,
             fp: typing.BinaryIO,
-            progress_cb: typing.Optional[typing.Callable[..., typing.Any]] = None,
+            progress_cb: typing.Optional[collections.abc.Callable[..., typing.Any]] = None,
         ) -> int: ...
         async def aio(
             self,
             remote_path: str,
             fp: typing.BinaryIO,
-            progress_cb: typing.Optional[typing.Callable[..., typing.Any]] = None,
+            progress_cb: typing.Optional[collections.abc.Callable[..., typing.Any]] = None,
         ) -> int: ...
 
-    write_file: __write_file_spec
+    write_file: __write_file_spec[typing_extensions.Self]
 
-    class __read_file_spec(typing_extensions.Protocol):
+    class __read_file_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, path: str) -> typing.Iterator[bytes]: ...
         def aio(self, path: str) -> collections.abc.AsyncIterator[bytes]: ...
 
-    read_file: __read_file_spec
+    read_file: __read_file_spec[typing_extensions.Self]
 
-    class __iterdir_spec(typing_extensions.Protocol):
+    class __iterdir_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, path: str) -> typing.Iterator[modal.volume.FileEntry]: ...
         def aio(self, path: str) -> collections.abc.AsyncIterator[modal.volume.FileEntry]: ...
 
-    iterdir: __iterdir_spec
+    iterdir: __iterdir_spec[typing_extensions.Self]
 
-    class __add_local_file_spec(typing_extensions.Protocol):
+    class __add_local_file_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self,
             local_path: typing.Union[pathlib.Path, str],
             remote_path: typing.Union[str, pathlib.PurePosixPath, None] = None,
-            progress_cb: typing.Optional[typing.Callable[..., typing.Any]] = None,
+            progress_cb: typing.Optional[collections.abc.Callable[..., typing.Any]] = None,
         ): ...
         async def aio(
             self,
             local_path: typing.Union[pathlib.Path, str],
             remote_path: typing.Union[str, pathlib.PurePosixPath, None] = None,
-            progress_cb: typing.Optional[typing.Callable[..., typing.Any]] = None,
+            progress_cb: typing.Optional[collections.abc.Callable[..., typing.Any]] = None,
         ): ...
 
-    add_local_file: __add_local_file_spec
+    add_local_file: __add_local_file_spec[typing_extensions.Self]
 
-    class __add_local_dir_spec(typing_extensions.Protocol):
+    class __add_local_dir_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self,
             local_path: typing.Union[pathlib.Path, str],
             remote_path: typing.Union[str, pathlib.PurePosixPath, None] = None,
-            progress_cb: typing.Optional[typing.Callable[..., typing.Any]] = None,
+            progress_cb: typing.Optional[collections.abc.Callable[..., typing.Any]] = None,
         ): ...
         async def aio(
             self,
             local_path: typing.Union[pathlib.Path, str],
             remote_path: typing.Union[str, pathlib.PurePosixPath, None] = None,
-            progress_cb: typing.Optional[typing.Callable[..., typing.Any]] = None,
+            progress_cb: typing.Optional[collections.abc.Callable[..., typing.Any]] = None,
         ): ...
 
-    add_local_dir: __add_local_dir_spec
+    add_local_dir: __add_local_dir_spec[typing_extensions.Self]
 
-    class __listdir_spec(typing_extensions.Protocol):
+    class __listdir_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, path: str) -> list[modal.volume.FileEntry]: ...
         async def aio(self, path: str) -> list[modal.volume.FileEntry]: ...
 
-    listdir: __listdir_spec
+    listdir: __listdir_spec[typing_extensions.Self]
 
-    class __remove_file_spec(typing_extensions.Protocol):
+    class __remove_file_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, path: str, recursive=False): ...
         async def aio(self, path: str, recursive=False): ...
 
-    remove_file: __remove_file_spec
+    remove_file: __remove_file_spec[typing_extensions.Self]

modal/object.py

@@ -1,268 +1,5 @@
-# Copyright Modal Labs 2022
-import uuid
-from collections.abc import Awaitable, Hashable, Sequence
-from functools import wraps
-from typing import Callable, ClassVar, Optional, TypeVar
-
-from google.protobuf.message import Message
-
-from modal._utils.async_utils import aclosing
-
-from ._resolver import Resolver
+# Copyright Modal Labs 2025
+from ._object import _Object
 from ._utils.async_utils import synchronize_api
-from .client import _Client
-from .config import config, logger
-from .exception import ExecutionError, InvalidError
-
-O = TypeVar("O", bound="_Object")
-
-_BLOCKING_O = synchronize_api(O)
-
-EPHEMERAL_OBJECT_HEARTBEAT_SLEEP: int = 300
-
-
-def _get_environment_name(environment_name: Optional[str] = None, resolver: Optional[Resolver] = None) -> Optional[str]:
-    if environment_name:
-        return environment_name
-    elif resolver and resolver.environment_name:
-        return resolver.environment_name
-    else:
-        return config.get("environment")
-
-
-class _Object:
-    _type_prefix: ClassVar[Optional[str]] = None
-    _prefix_to_type: ClassVar[dict[str, type]] = {}
-
-    # For constructors
-    _load: Optional[Callable[[O, Resolver, Optional[str]], Awaitable[None]]]
-    _preload: Optional[Callable[[O, Resolver, Optional[str]], Awaitable[None]]]
-    _rep: str
-    _is_another_app: bool
-    _hydrate_lazily: bool
-    _deps: Optional[Callable[..., list["_Object"]]]
-    _deduplication_key: Optional[Callable[[], Awaitable[Hashable]]] = None
-
-    # For hydrated objects
-    _object_id: str
-    _client: _Client
-    _is_hydrated: bool
-    _is_rehydrated: bool
-
-    @classmethod
-    def __init_subclass__(cls, type_prefix: Optional[str] = None):
-        super().__init_subclass__()
-        if type_prefix is not None:
-            cls._type_prefix = type_prefix
-            cls._prefix_to_type[type_prefix] = cls
-
-    def __init__(self, *args, **kwargs):
-        raise InvalidError(f"Class {type(self).__name__} has no constructor. Use class constructor methods instead.")
-
-    def _init(
-        self,
-        rep: str,
-        load: Optional[Callable[[O, Resolver, Optional[str]], Awaitable[None]]] = None,
-        is_another_app: bool = False,
-        preload: Optional[Callable[[O, Resolver, Optional[str]], Awaitable[None]]] = None,
-        hydrate_lazily: bool = False,
-        deps: Optional[Callable[..., list["_Object"]]] = None,
-        deduplication_key: Optional[Callable[[], Awaitable[Hashable]]] = None,
-    ):
-        self._local_uuid = str(uuid.uuid4())
-        self._load = load
-        self._preload = preload
-        self._rep = rep
-        self._is_another_app = is_another_app
-        self._hydrate_lazily = hydrate_lazily
-        self._deps = deps
-        self._deduplication_key = deduplication_key
-
-        self._object_id = None
-        self._client = None
-        self._is_hydrated = False
-        self._is_rehydrated = False
-
-        self._initialize_from_empty()
-
-    def _unhydrate(self):
-        self._object_id = None
-        self._client = None
-        self._is_hydrated = False
-
-    def _initialize_from_empty(self):
-        # default implementation, can be overriden in subclasses
-        pass
-
-    def _initialize_from_other(self, other):
-        # default implementation, can be overriden in subclasses
-        self._object_id = other._object_id
-        self._is_hydrated = other._is_hydrated
-        self._client = other._client
-
-    def _hydrate(self, object_id: str, client: _Client, metadata: Optional[Message]):
-        assert isinstance(object_id, str)
-        if not object_id.startswith(self._type_prefix):
-            raise ExecutionError(
-                f"Can not hydrate {type(self)}:"
-                f" it has type prefix {self._type_prefix}"
-                f" but the object_id starts with {object_id[:3]}"
-            )
-        self._object_id = object_id
-        self._client = client
-        self._hydrate_metadata(metadata)
-        self._is_hydrated = True
-
-    def _hydrate_metadata(self, metadata: Optional[Message]):
-        # override this is subclasses that need additional data (other than an object_id) for a functioning Handle
-        pass
-
-    def _get_metadata(self) -> Optional[Message]:
-        # return the necessary metadata from this handle to be able to re-hydrate in another context if one is needed
-        # used to provide a handle's handle_metadata for serializing/pickling a live handle
-        # the object_id is already provided by other means
-        return
-
-    def _validate_is_hydrated(self: O):
-        if not self._is_hydrated:
-            object_type = self.__class__.__name__.strip("_")
-            if hasattr(self, "_app") and getattr(self._app, "_running_app", "") is None:
-                # The most common cause of this error: e.g., user called a Function without using App.run()
-                reason = ", because the App it is defined on is not running"
-            else:
-                # Technically possible, but with an ambiguous cause.
-                reason = ""
-            raise ExecutionError(
-                f"{object_type} has not been hydrated with the metadata it needs to run on Modal{reason}."
-            )
-
-    def clone(self: O) -> O:
-        """mdmd:hidden Clone a given hydrated object."""
-
-        # Object to clone must already be hydrated, otherwise from_loader is more suitable.
-        self._validate_is_hydrated()
-        obj = type(self).__new__(type(self))
-        obj._initialize_from_other(self)
-        return obj
-
-    @classmethod
-    def _from_loader(
-        cls,
-        load: Callable[[O, Resolver, Optional[str]], Awaitable[None]],
-        rep: str,
-        is_another_app: bool = False,
-        preload: Optional[Callable[[O, Resolver, Optional[str]], Awaitable[None]]] = None,
-        hydrate_lazily: bool = False,
-        deps: Optional[Callable[..., Sequence["_Object"]]] = None,
-        deduplication_key: Optional[Callable[[], Awaitable[Hashable]]] = None,
-    ):
-        # 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)
-        return obj
-
-    @classmethod
-    def _get_type_from_id(cls: type[O], object_id: str) -> type[O]:
-        parts = object_id.split("-")
-        if len(parts) != 2:
-            raise InvalidError(f"Object id {object_id} has no dash in it")
-        prefix = parts[0]
-        if prefix not in cls._prefix_to_type:
-            raise InvalidError(f"Object prefix {prefix} does not correspond to a type")
-        return cls._prefix_to_type[prefix]
-
-    @classmethod
-    def _is_id_type(cls: type[O], object_id) -> bool:
-        return cls._get_type_from_id(object_id) == cls
-
-    @classmethod
-    def _new_hydrated(
-        cls: type[O], object_id: str, client: _Client, handle_metadata: Optional[Message], is_another_app: bool = False
-    ) -> O:
-        if cls._type_prefix is not None:
-            # This is called directly on a subclass, e.g. Secret.from_id
-            if not object_id.startswith(cls._type_prefix + "-"):
-                raise InvalidError(f"Object {object_id} does not start with {cls._type_prefix}")
-            obj_cls = cls
-        else:
-            # This is called on the base class, e.g. Handle.from_id
-            obj_cls = cls._get_type_from_id(object_id)
-
-        # Instantiate provider
-        obj = _Object.__new__(obj_cls)
-        rep = f"Object({object_id})"  # TODO(erikbern): dumb
-        obj._init(rep, is_another_app=is_another_app)
-        obj._hydrate(object_id, client, handle_metadata)
-
-        return obj
-
-    def _hydrate_from_other(self, other: O):
-        self._hydrate(other._object_id, other._client, other._get_metadata())
-
-    def __repr__(self):
-        return self._rep
-
-    @property
-    def local_uuid(self):
-        """mdmd:hidden"""
-        return self._local_uuid
-
-    @property
-    def object_id(self) -> str:
-        """mdmd:hidden"""
-        return self._object_id
-
-    @property
-    def is_hydrated(self) -> bool:
-        """mdmd:hidden"""
-        return self._is_hydrated
-
-    @property
-    def deps(self) -> Callable[..., list["_Object"]]:
-        """mdmd:hidden"""
-        return self._deps if self._deps is not None else lambda: []
-
-    async def resolve(self, client: Optional[_Client] = None):
-        """mdmd:hidden"""
-        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:
-                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(self)
-                self._is_rehydrated = True
-                logger.debug(f"rehydrated {self} with client {id(c)}")
-            return
-        elif not self._hydrate_lazily:
-            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)
-
 
 Object = synchronize_api(_Object, target_module=__name__)
-
-
-def live_method(method):
-    @wraps(method)
-    async def wrapped(self, *args, **kwargs):
-        await self.resolve()
-        return await method(self, *args, **kwargs)
-
-    return wrapped
-
-
-def live_method_gen(method):
-    @wraps(method)
-    async def wrapped(self, *args, **kwargs):
-        await self.resolve()
-        async with aclosing(method(self, *args, **kwargs)) as stream:
-            async for item in stream:
-                yield item
-
-    return wrapped

modal/object.pyi

@@ -5,117 +5,30 @@ import modal.client
 import typing
 import typing_extensions
 
-O = typing.TypeVar("O", bound="_Object")
-
-_BLOCKING_O = typing.TypeVar("_BLOCKING_O", bound="Object")
-
-def _get_environment_name(
-    environment_name: typing.Optional[str] = None, resolver: typing.Optional[modal._resolver.Resolver] = None
-) -> typing.Optional[str]: ...
-
-class _Object:
-    _type_prefix: typing.ClassVar[typing.Optional[str]]
-    _prefix_to_type: typing.ClassVar[dict[str, type]]
-    _load: typing.Optional[
-        typing.Callable[[O, modal._resolver.Resolver, typing.Optional[str]], collections.abc.Awaitable[None]]
-    ]
-    _preload: typing.Optional[
-        typing.Callable[[O, modal._resolver.Resolver, typing.Optional[str]], collections.abc.Awaitable[None]]
-    ]
-    _rep: str
-    _is_another_app: bool
-    _hydrate_lazily: bool
-    _deps: typing.Optional[typing.Callable[..., list[_Object]]]
-    _deduplication_key: typing.Optional[typing.Callable[[], collections.abc.Awaitable[collections.abc.Hashable]]]
-    _object_id: str
-    _client: modal.client._Client
-    _is_hydrated: bool
-    _is_rehydrated: bool
-
-    @classmethod
-    def __init_subclass__(cls, type_prefix: typing.Optional[str] = None): ...
-    def __init__(self, *args, **kwargs): ...
-    def _init(
-        self,
-        rep: str,
-        load: typing.Optional[
-            typing.Callable[[O, modal._resolver.Resolver, typing.Optional[str]], collections.abc.Awaitable[None]]
-        ] = None,
-        is_another_app: bool = False,
-        preload: typing.Optional[
-            typing.Callable[[O, modal._resolver.Resolver, typing.Optional[str]], collections.abc.Awaitable[None]]
-        ] = None,
-        hydrate_lazily: bool = False,
-        deps: typing.Optional[typing.Callable[..., list[_Object]]] = None,
-        deduplication_key: typing.Optional[
-            typing.Callable[[], collections.abc.Awaitable[collections.abc.Hashable]]
-        ] = None,
-    ): ...
-    def _unhydrate(self): ...
-    def _initialize_from_empty(self): ...
-    def _initialize_from_other(self, other): ...
-    def _hydrate(
-        self, object_id: str, client: modal.client._Client, metadata: typing.Optional[google.protobuf.message.Message]
-    ): ...
-    def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...
-    def _get_metadata(self) -> typing.Optional[google.protobuf.message.Message]: ...
-    def _validate_is_hydrated(self: O): ...
-    def clone(self: O) -> O: ...
-    @classmethod
-    def _from_loader(
-        cls,
-        load: typing.Callable[[O, modal._resolver.Resolver, typing.Optional[str]], collections.abc.Awaitable[None]],
-        rep: str,
-        is_another_app: bool = False,
-        preload: typing.Optional[
-            typing.Callable[[O, modal._resolver.Resolver, typing.Optional[str]], collections.abc.Awaitable[None]]
-        ] = None,
-        hydrate_lazily: bool = False,
-        deps: typing.Optional[typing.Callable[..., collections.abc.Sequence[_Object]]] = None,
-        deduplication_key: typing.Optional[
-            typing.Callable[[], collections.abc.Awaitable[collections.abc.Hashable]]
-        ] = None,
-    ): ...
-    @classmethod
-    def _get_type_from_id(cls: type[O], object_id: str) -> type[O]: ...
-    @classmethod
-    def _is_id_type(cls: type[O], object_id) -> bool: ...
-    @classmethod
-    def _new_hydrated(
-        cls: type[O],
-        object_id: str,
-        client: modal.client._Client,
-        handle_metadata: typing.Optional[google.protobuf.message.Message],
-        is_another_app: bool = False,
-    ) -> O: ...
-    def _hydrate_from_other(self, other: O): ...
-    def __repr__(self): ...
-    @property
-    def local_uuid(self): ...
-    @property
-    def object_id(self) -> str: ...
-    @property
-    def is_hydrated(self) -> bool: ...
-    @property
-    def deps(self) -> typing.Callable[..., list[_Object]]: ...
-    async def resolve(self, client: typing.Optional[modal.client._Client] = None): ...
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
 
 class Object:
     _type_prefix: typing.ClassVar[typing.Optional[str]]
     _prefix_to_type: typing.ClassVar[dict[str, type]]
     _load: typing.Optional[
-        typing.Callable[[_BLOCKING_O, modal._resolver.Resolver, typing.Optional[str]], collections.abc.Awaitable[None]]
+        collections.abc.Callable[
+            [typing_extensions.Self, modal._resolver.Resolver, typing.Optional[str]], collections.abc.Awaitable[None]
+        ]
     ]
     _preload: typing.Optional[
-        typing.Callable[[_BLOCKING_O, modal._resolver.Resolver, typing.Optional[str]], collections.abc.Awaitable[None]]
+        collections.abc.Callable[
+            [typing_extensions.Self, modal._resolver.Resolver, typing.Optional[str]], collections.abc.Awaitable[None]
+        ]
     ]
     _rep: str
     _is_another_app: bool
     _hydrate_lazily: bool
-    _deps: typing.Optional[typing.Callable[..., list[Object]]]
-    _deduplication_key: typing.Optional[typing.Callable[[], collections.abc.Awaitable[collections.abc.Hashable]]]
-    _object_id: str
-    _client: modal.client.Client
+    _deps: typing.Optional[collections.abc.Callable[..., collections.abc.Sequence[Object]]]
+    _deduplication_key: typing.Optional[
+        collections.abc.Callable[[], collections.abc.Awaitable[collections.abc.Hashable]]
+    ]
+    _object_id: typing.Optional[str]
+    _client: typing.Optional[modal.client.Client]
     _is_hydrated: bool
     _is_rehydrated: bool
 
@@ -123,43 +36,43 @@ class Object:
     @classmethod
     def __init_subclass__(cls, type_prefix: typing.Optional[str] = None): ...
 
-    class ___init_spec(typing_extensions.Protocol):
+    class ___init_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self,
             rep: str,
             load: typing.Optional[
-                typing.Callable[[_BLOCKING_O, modal._resolver.Resolver, typing.Optional[str]], None]
+                collections.abc.Callable[[SUPERSELF, modal._resolver.Resolver, typing.Optional[str]], None]
             ] = None,
             is_another_app: bool = False,
             preload: typing.Optional[
-                typing.Callable[[_BLOCKING_O, modal._resolver.Resolver, typing.Optional[str]], None]
+                collections.abc.Callable[[SUPERSELF, modal._resolver.Resolver, typing.Optional[str]], None]
             ] = None,
             hydrate_lazily: bool = False,
-            deps: typing.Optional[typing.Callable[..., list[Object]]] = None,
-            deduplication_key: typing.Optional[typing.Callable[[], collections.abc.Hashable]] = None,
+            deps: typing.Optional[collections.abc.Callable[..., collections.abc.Sequence[Object]]] = None,
+            deduplication_key: typing.Optional[collections.abc.Callable[[], collections.abc.Hashable]] = None,
         ): ...
         def aio(
             self,
             rep: str,
             load: typing.Optional[
-                typing.Callable[
-                    [_BLOCKING_O, modal._resolver.Resolver, typing.Optional[str]], collections.abc.Awaitable[None]
+                collections.abc.Callable[
+                    [SUPERSELF, modal._resolver.Resolver, typing.Optional[str]], collections.abc.Awaitable[None]
                 ]
             ] = None,
             is_another_app: bool = False,
             preload: typing.Optional[
-                typing.Callable[
-                    [_BLOCKING_O, modal._resolver.Resolver, typing.Optional[str]], collections.abc.Awaitable[None]
+                collections.abc.Callable[
+                    [SUPERSELF, modal._resolver.Resolver, typing.Optional[str]], collections.abc.Awaitable[None]
                 ]
             ] = None,
             hydrate_lazily: bool = False,
-            deps: typing.Optional[typing.Callable[..., list[Object]]] = None,
+            deps: typing.Optional[collections.abc.Callable[..., collections.abc.Sequence[Object]]] = None,
             deduplication_key: typing.Optional[
-                typing.Callable[[], collections.abc.Awaitable[collections.abc.Hashable]]
+                collections.abc.Callable[[], collections.abc.Awaitable[collections.abc.Hashable]]
             ] = None,
         ): ...
 
-    _init: ___init_spec
+    _init: ___init_spec[typing_extensions.Self]
 
     def _unhydrate(self): ...
     def _initialize_from_empty(self): ...
@@ -169,51 +82,54 @@ class Object:
     ): ...
     def _hydrate_metadata(self, metadata: typing.Optional[google.protobuf.message.Message]): ...
     def _get_metadata(self) -> typing.Optional[google.protobuf.message.Message]: ...
-    def _validate_is_hydrated(self: _BLOCKING_O): ...
-    def clone(self: _BLOCKING_O) -> _BLOCKING_O: ...
+    def _validate_is_hydrated(self): ...
+    def clone(self) -> typing_extensions.Self: ...
     @classmethod
     def _from_loader(
         cls,
-        load: typing.Callable[[_BLOCKING_O, modal._resolver.Resolver, typing.Optional[str]], None],
+        load: collections.abc.Callable[[typing_extensions.Self, modal._resolver.Resolver, typing.Optional[str]], None],
         rep: str,
         is_another_app: bool = False,
         preload: typing.Optional[
-            typing.Callable[[_BLOCKING_O, modal._resolver.Resolver, typing.Optional[str]], None]
+            collections.abc.Callable[[typing_extensions.Self, modal._resolver.Resolver, typing.Optional[str]], None]
         ] = None,
         hydrate_lazily: bool = False,
-        deps: typing.Optional[typing.Callable[..., collections.abc.Sequence[Object]]] = None,
-        deduplication_key: typing.Optional[typing.Callable[[], collections.abc.Hashable]] = None,
+        deps: typing.Optional[collections.abc.Callable[..., collections.abc.Sequence[Object]]] = None,
+        deduplication_key: typing.Optional[collections.abc.Callable[[], collections.abc.Hashable]] = None,
     ): ...
+    @staticmethod
+    def _get_type_from_id(object_id: str) -> type[Object]: ...
     @classmethod
-    def _get_type_from_id(cls: type[_BLOCKING_O], object_id: str) -> type[_BLOCKING_O]: ...
-    @classmethod
-    def _is_id_type(cls: type[_BLOCKING_O], object_id) -> bool: ...
+    def _is_id_type(cls, object_id) -> bool: ...
     @classmethod
     def _new_hydrated(
-        cls: type[_BLOCKING_O],
+        cls,
         object_id: str,
         client: modal.client.Client,
         handle_metadata: typing.Optional[google.protobuf.message.Message],
         is_another_app: bool = False,
-    ) -> _BLOCKING_O: ...
-    def _hydrate_from_other(self, other: _BLOCKING_O): ...
+    ) -> typing_extensions.Self: ...
+    def _hydrate_from_other(self, other: typing_extensions.Self): ...
     def __repr__(self): ...
     @property
     def local_uuid(self): ...
     @property
     def object_id(self) -> str: ...
     @property
+    def client(self) -> modal.client.Client: ...
+    @property
     def is_hydrated(self) -> bool: ...
     @property
-    def deps(self) -> typing.Callable[..., list[Object]]: ...
+    def deps(self) -> collections.abc.Callable[..., collections.abc.Sequence[Object]]: ...
 
-    class __resolve_spec(typing_extensions.Protocol):
+    class __resolve_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, client: typing.Optional[modal.client.Client] = None): ...
         async def aio(self, client: typing.Optional[modal.client.Client] = None): ...
 
-    resolve: __resolve_spec
+    resolve: __resolve_spec[typing_extensions.Self]
 
-def live_method(method): ...
-def live_method_gen(method): ...
+    class __hydrate_spec(typing_extensions.Protocol[SUPERSELF]):
+        def __call__(self, client: typing.Optional[modal.client.Client] = None) -> SUPERSELF: ...
+        async def aio(self, client: typing.Optional[modal.client.Client] = None) -> SUPERSELF: ...
 
-EPHEMERAL_OBJECT_HEARTBEAT_SLEEP: int
+    hydrate: __hydrate_spec[typing_extensions.Self]

modal/parallel_map.py

@@ -151,8 +151,8 @@ async def _map_invocation(
                     if err.status != Status.RESOURCE_EXHAUSTED:
                         raise err
                     logger.warning(
-                        "Warning: map progress is limited. Common bottlenecks "
-                        "include slow iteration over results, or function backlogs."
+                        f"Warning: map progress for function {function._function_name} is limited."
+                        " Common bottlenecks include slow iteration over results, or function backlogs."
                     )
 
             count_update()