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

modal/mount.pyi

@@ -1,5 +1,6 @@
 import collections.abc
 import google.protobuf.message
+import modal._object
 import modal._resolver
 import modal._utils.blob_utils
 import modal.client
@@ -35,7 +36,7 @@ class _MountFile(_MountEntry):
 class _MountDir(_MountEntry):
     local_dir: pathlib.Path
     remote_path: pathlib.PurePosixPath
-    ignore: typing.Callable[[pathlib.Path], bool]
+    ignore: collections.abc.Callable[[pathlib.Path], bool]
     recursive: bool
 
     def description(self): ...
@@ -46,7 +47,7 @@ class _MountDir(_MountEntry):
         self,
         local_dir: pathlib.Path,
         remote_path: pathlib.PurePosixPath,
-        ignore: typing.Callable[[pathlib.Path], bool],
+        ignore: collections.abc.Callable[[pathlib.Path], bool],
         recursive: bool,
     ) -> None: ...
     def __repr__(self): ...
@@ -58,7 +59,7 @@ def module_mount_ignore_condition(module_base: pathlib.Path): ...
 class _MountedPythonModule(_MountEntry):
     module_name: str
     remote_dir: typing.Union[pathlib.PurePosixPath, str]
-    ignore: typing.Optional[typing.Callable[[pathlib.Path], bool]]
+    ignore: typing.Optional[collections.abc.Callable[[pathlib.Path], bool]]
 
     def description(self) -> str: ...
     def _proxy_entries(self) -> list[_MountEntry]: ...
@@ -69,14 +70,14 @@ class _MountedPythonModule(_MountEntry):
         self,
         module_name: str,
         remote_dir: typing.Union[pathlib.PurePosixPath, str] = "/root",
-        ignore: typing.Optional[typing.Callable[[pathlib.Path], bool]] = None,
+        ignore: typing.Optional[collections.abc.Callable[[pathlib.Path], bool]] = None,
     ) -> None: ...
     def __repr__(self): ...
     def __eq__(self, other): ...
 
 class NonLocalMountError(Exception): ...
 
-class _Mount(modal.object._Object):
+class _Mount(modal._object._Object):
     _entries: typing.Optional[list[_MountEntry]]
     _deployment_name: typing.Optional[str]
     _namespace: typing.Optional[int]
@@ -95,14 +96,14 @@ class _Mount(modal.object._Object):
     def _add_local_dir(
         local_path: pathlib.Path,
         remote_path: pathlib.PurePosixPath,
-        ignore: typing.Callable[[pathlib.Path], bool] = modal.file_pattern_matcher._NOTHING,
+        ignore: collections.abc.Callable[[pathlib.Path], bool] = modal.file_pattern_matcher._NOTHING,
     ): ...
     def add_local_dir(
         self,
         local_path: typing.Union[str, pathlib.Path],
         *,
         remote_path: typing.Union[str, pathlib.PurePosixPath, None] = None,
-        condition: typing.Optional[typing.Callable[[str], bool]] = None,
+        condition: typing.Optional[collections.abc.Callable[[str], bool]] = None,
         recursive: bool = True,
     ) -> _Mount: ...
     @staticmethod
@@ -110,7 +111,7 @@ class _Mount(modal.object._Object):
         local_path: typing.Union[str, pathlib.Path],
         *,
         remote_path: typing.Union[str, pathlib.PurePosixPath, None] = None,
-        condition: typing.Optional[typing.Callable[[str], bool]] = None,
+        condition: typing.Optional[collections.abc.Callable[[str], bool]] = None,
         recursive: bool = True,
     ) -> _Mount: ...
     @staticmethod
@@ -118,7 +119,7 @@ class _Mount(modal.object._Object):
         local_path: typing.Union[str, pathlib.Path],
         *,
         remote_path: typing.Union[str, pathlib.PurePosixPath, None] = None,
-        condition: typing.Optional[typing.Callable[[str], bool]] = None,
+        condition: typing.Optional[collections.abc.Callable[[str], bool]] = None,
         recursive: bool = True,
     ) -> _Mount: ...
     def add_local_file(
@@ -147,15 +148,15 @@ class _Mount(modal.object._Object):
     def from_local_python_packages(
         *module_names: str,
         remote_dir: typing.Union[str, pathlib.PurePosixPath] = "/root",
-        condition: typing.Optional[typing.Callable[[str], bool]] = None,
-        ignore: typing.Union[typing.Sequence[str], typing.Callable[[pathlib.Path], bool], None] = None,
+        condition: typing.Optional[collections.abc.Callable[[str], bool]] = None,
+        ignore: typing.Union[typing.Sequence[str], collections.abc.Callable[[pathlib.Path], bool], None] = None,
     ) -> _Mount: ...
     @staticmethod
     def _from_local_python_packages(
         *module_names: str,
         remote_dir: typing.Union[str, pathlib.PurePosixPath] = "/root",
-        condition: typing.Optional[typing.Callable[[str], bool]] = None,
-        ignore: typing.Union[typing.Sequence[str], typing.Callable[[pathlib.Path], bool], None] = None,
+        condition: typing.Optional[collections.abc.Callable[[str], bool]] = None,
+        ignore: typing.Union[typing.Sequence[str], collections.abc.Callable[[pathlib.Path], bool], None] = None,
     ) -> _Mount: ...
     @staticmethod
     def from_name(name: str, namespace=1, environment_name: typing.Optional[str] = None) -> _Mount: ...
@@ -176,6 +177,8 @@ class _Mount(modal.object._Object):
     ) -> None: ...
     def _get_metadata(self) -> modal_proto.api_pb2.MountHandleMetadata: ...
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 class Mount(modal.object.Object):
     _entries: typing.Optional[list[_MountEntry]]
     _deployment_name: typing.Optional[str]
@@ -196,14 +199,14 @@ class Mount(modal.object.Object):
     def _add_local_dir(
         local_path: pathlib.Path,
         remote_path: pathlib.PurePosixPath,
-        ignore: typing.Callable[[pathlib.Path], bool] = modal.file_pattern_matcher._NOTHING,
+        ignore: collections.abc.Callable[[pathlib.Path], bool] = modal.file_pattern_matcher._NOTHING,
     ): ...
     def add_local_dir(
         self,
         local_path: typing.Union[str, pathlib.Path],
         *,
         remote_path: typing.Union[str, pathlib.PurePosixPath, None] = None,
-        condition: typing.Optional[typing.Callable[[str], bool]] = None,
+        condition: typing.Optional[collections.abc.Callable[[str], bool]] = None,
         recursive: bool = True,
     ) -> Mount: ...
     @staticmethod
@@ -211,7 +214,7 @@ class Mount(modal.object.Object):
         local_path: typing.Union[str, pathlib.Path],
         *,
         remote_path: typing.Union[str, pathlib.PurePosixPath, None] = None,
-        condition: typing.Optional[typing.Callable[[str], bool]] = None,
+        condition: typing.Optional[collections.abc.Callable[[str], bool]] = None,
         recursive: bool = True,
     ) -> Mount: ...
     @staticmethod
@@ -219,7 +222,7 @@ class Mount(modal.object.Object):
         local_path: typing.Union[str, pathlib.Path],
         *,
         remote_path: typing.Union[str, pathlib.PurePosixPath, None] = None,
-        condition: typing.Optional[typing.Callable[[str], bool]] = None,
+        condition: typing.Optional[collections.abc.Callable[[str], bool]] = None,
         recursive: bool = True,
     ) -> Mount: ...
     def add_local_file(
@@ -248,25 +251,25 @@ class Mount(modal.object.Object):
 
     _get_files: ___get_files_spec
 
-    class ___load_mount_spec(typing_extensions.Protocol):
+    class ___load_mount_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, resolver: modal._resolver.Resolver, existing_object_id: typing.Optional[str]): ...
         async def aio(self, resolver: modal._resolver.Resolver, existing_object_id: typing.Optional[str]): ...
 
-    _load_mount: ___load_mount_spec
+    _load_mount: ___load_mount_spec[typing_extensions.Self]
 
     @staticmethod
     def from_local_python_packages(
         *module_names: str,
         remote_dir: typing.Union[str, pathlib.PurePosixPath] = "/root",
-        condition: typing.Optional[typing.Callable[[str], bool]] = None,
-        ignore: typing.Union[typing.Sequence[str], typing.Callable[[pathlib.Path], bool], None] = None,
+        condition: typing.Optional[collections.abc.Callable[[str], bool]] = None,
+        ignore: typing.Union[typing.Sequence[str], collections.abc.Callable[[pathlib.Path], bool], None] = None,
     ) -> Mount: ...
     @staticmethod
     def _from_local_python_packages(
         *module_names: str,
         remote_dir: typing.Union[str, pathlib.PurePosixPath] = "/root",
-        condition: typing.Optional[typing.Callable[[str], bool]] = None,
-        ignore: typing.Union[typing.Sequence[str], typing.Callable[[pathlib.Path], bool], None] = None,
+        condition: typing.Optional[collections.abc.Callable[[str], bool]] = None,
+        ignore: typing.Union[typing.Sequence[str], collections.abc.Callable[[pathlib.Path], bool], None] = None,
     ) -> Mount: ...
     @staticmethod
     def from_name(name: str, namespace=1, environment_name: typing.Optional[str] = None) -> Mount: ...
@@ -279,7 +282,7 @@ class Mount(modal.object.Object):
         environment_name: typing.Optional[str] = None,
     ) -> Mount: ...
 
-    class ___deploy_spec(typing_extensions.Protocol):
+    class ___deploy_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self,
             deployment_name: typing.Optional[str] = None,
@@ -295,7 +298,7 @@ class Mount(modal.object.Object):
             client: typing.Optional[modal.client.Client] = None,
         ) -> None: ...
 
-    _deploy: ___deploy_spec
+    _deploy: ___deploy_spec[typing_extensions.Self]
 
     def _get_metadata(self) -> modal_proto.api_pb2.MountHandleMetadata: ...
 

modal/network_file_system.py

@@ -12,6 +12,13 @@ from synchronicity.async_wrap import asynccontextmanager
 import modal
 from modal_proto import api_pb2
 
+from ._object import (
+    EPHEMERAL_OBJECT_HEARTBEAT_SLEEP,
+    _get_environment_name,
+    _Object,
+    live_method,
+    live_method_gen,
+)
 from ._resolver import Resolver
 from ._utils.async_utils import TaskContext, aclosing, async_map, sync_or_async_iter, synchronize_api
 from ._utils.blob_utils import LARGE_FILE_LIMIT, blob_iter, blob_upload_file
@@ -21,13 +28,6 @@ from ._utils.hash_utils import get_sha256_hex
 from ._utils.name_utils import check_object_name
 from .client import _Client
 from .exception import InvalidError
-from .object import (
-    EPHEMERAL_OBJECT_HEARTBEAT_SLEEP,
-    _get_environment_name,
-    _Object,
-    live_method,
-    live_method_gen,
-)
 from .volume import FileEntry
 
 NETWORK_FILE_SYSTEM_PUT_FILE_CLIENT_TIMEOUT = (

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