modal 0.72.21__py3-none-any.whl → 0.72.23__py3-none-any.whl

modal/functions.py

@@ -26,6 +26,7 @@ from modal_proto import api_pb2
 from modal_proto.modal_api_grpc import ModalClientModal
 
 from ._location import parse_cloud_provider
+from ._object import _get_environment_name, _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
@@ -71,7 +72,6 @@ from .gpu import GPU_T, parse_gpu_config
 from .image import _Image
 from .mount import _get_client_mount, _Mount, get_auto_mounts
 from .network_file_system import _NetworkFileSystem, network_file_system_mount_protos
-from .object import _get_environment_name, _Object, live_method, live_method_gen
 from .output import _get_output_manager
 from .parallel_map import (
     _for_each_async,
@@ -388,7 +388,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     _is_method: bool
     _spec: Optional[_FunctionSpec] = None
     _tag: str
-    _raw_f: Callable[..., Any]
+    _raw_f: Optional[Callable[..., Any]]  # this is set to None for a "class service [function]"
     _build_args: dict
 
     _is_generator: Optional[bool] = None
@@ -474,7 +474,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         _experimental_buffer_containers: Optional[int] = None,
         _experimental_proxy_ip: Optional[str] = None,
         _experimental_custom_scaling_factor: Optional[float] = None,
-    ) -> None:
+    ) -> "_Function":
         """mdmd:hidden"""
         # Needed to avoid circular imports
         from .partial_function import _find_partial_methods_for_user_cls, _PartialFunctionFlags
@@ -573,7 +573,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 )
                 image = _Image._from_args(
                     base_images={"base": image},
-                    build_function=snapshot_function,
+                    build_function=snapshot_function,  # type: ignore   # TODO: separate functions.py and _functions.py
                     force_build=image.force_build or pf.force_build,
                 )
 
@@ -962,7 +962,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     f"The {identity} has not been hydrated with the metadata it needs to run on Modal{reason}."
                 )
 
-            assert parent._client.stub
+            assert parent._client and parent._client.stub
 
             if can_use_parent:
                 # We can end up here if parent wasn't hydrated when class was instantiated, but has been since.
@@ -983,9 +983,9 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             else:
                 serialized_params = serialize((args, kwargs))
             environment_name = _get_environment_name(None, resolver)
-            assert parent is not None
+            assert parent is not None and parent.is_hydrated
             req = api_pb2.FunctionBindParamsRequest(
-                function_id=parent._object_id,
+                function_id=parent.object_id,
                 serialized_params=serialized_params,
                 function_options=options,
                 environment_name=environment_name
@@ -1032,11 +1032,10 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             """
                 )
             )
-        assert self._client and self._client.stub
         request = api_pb2.FunctionUpdateSchedulingParamsRequest(
-            function_id=self._object_id, warm_pool_size_override=warm_pool_size
+            function_id=self.object_id, warm_pool_size_override=warm_pool_size
         )
-        await retry_transient_errors(self._client.stub.FunctionUpdateSchedulingParams, request)
+        await retry_transient_errors(self.client.stub.FunctionUpdateSchedulingParams, request)
 
     @classmethod
     @renamed_parameter((2024, 12, 18), "tag", "name")
@@ -1142,7 +1141,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         """mdmd:hidden"""
         # Plaintext source and arg definition for the function, so it's part of the image
         # hash. We can't use the cloudpickle hash because it's not very stable.
-        assert hasattr(self, "_raw_f") and hasattr(self, "_build_args")
+        assert hasattr(self, "_raw_f") and hasattr(self, "_build_args") and self._raw_f is not None
         return f"{inspect.getsource(self._raw_f)}\n{repr(self._build_args)}"
 
     # Live handle methods
@@ -1248,7 +1247,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             _map_invocation(
                 self,  # type: ignore
                 input_queue,
-                self._client,
+                self.client,
                 order_outputs,
                 return_exceptions,
                 count_update_callback,
@@ -1266,7 +1265,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             self,
             args,
             kwargs,
-            client=self._client,
+            client=self.client,
             function_call_invocation_type=function_call_invocation_type,
         )
 
@@ -1276,7 +1275,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         self, args, kwargs, function_call_invocation_type: "api_pb2.FunctionCallInvocationType.ValueType"
     ) -> _Invocation:
         return await _Invocation.create(
-            self, args, kwargs, client=self._client, function_call_invocation_type=function_call_invocation_type
+            self, args, kwargs, client=self.client, function_call_invocation_type=function_call_invocation_type
         )
 
     @warn_if_generator_is_not_consumed()
@@ -1287,7 +1286,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             self,
             args,
             kwargs,
-            client=self._client,
+            client=self.client,
             function_call_invocation_type=api_pb2.FUNCTION_CALL_INVOCATION_TYPE_SYNC_LEGACY,
         )
         async for res in invocation.run_generator():
@@ -1303,7 +1302,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             self,
             args,
             kwargs,
-            client=self._client,
+            client=self.client,
             function_call_invocation_type=api_pb2.FUNCTION_CALL_INVOCATION_TYPE_ASYNC_LEGACY,
         )
 
@@ -1452,14 +1451,14 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
     def get_raw_f(self) -> Callable[..., Any]:
         """Return the inner Python object wrapped by this Modal Function."""
+        assert self._raw_f is not None
         return self._raw_f
 
     @live_method
     async def get_current_stats(self) -> FunctionStats:
         """Return a `FunctionStats` object describing the current function's queue and runner counts."""
-        assert self._client.stub
         resp = await retry_transient_errors(
-            self._client.stub.FunctionGetCurrentStats,
+            self.client.stub.FunctionGetCurrentStats,
             api_pb2.FunctionGetCurrentStatsRequest(function_id=self.object_id),
             total_timeout=10.0,
         )
@@ -1491,8 +1490,7 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
     _is_generator: bool = False
 
     def _invocation(self):
-        assert self._client.stub
-        return _Invocation(self._client.stub, self.object_id, self._client)
+        return _Invocation(self.client.stub, self.object_id, self.client)
 
     async def get(self, timeout: Optional[float] = None) -> ReturnType:
         """Get the result of the function call.

modal/functions.pyi

@@ -1,5 +1,6 @@
 import collections.abc
 import google.protobuf.message
+import modal._object
 import modal._utils.async_utils
 import modal._utils.function_utils
 import modal.app
@@ -133,7 +134,7 @@ ReturnType = typing.TypeVar("ReturnType", covariant=True)
 
 OriginalReturnType = typing.TypeVar("OriginalReturnType", covariant=True)
 
-class _Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object._Object):
+class _Function(typing.Generic[P, ReturnType, OriginalReturnType], modal._object._Object):
     _info: typing.Optional[modal._utils.function_utils.FunctionInfo]
     _serve_mounts: frozenset[modal.mount._Mount]
     _app: typing.Optional[modal.app._App]
@@ -143,7 +144,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.
     _is_method: bool
     _spec: typing.Optional[_FunctionSpec]
     _tag: str
-    _raw_f: typing.Callable[..., typing.Any]
+    _raw_f: typing.Optional[typing.Callable[..., typing.Any]]
     _build_args: dict
     _is_generator: typing.Optional[bool]
     _cluster_size: typing.Optional[int]
@@ -197,7 +198,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.
         _experimental_buffer_containers: typing.Optional[int] = None,
         _experimental_proxy_ip: typing.Optional[str] = None,
         _experimental_custom_scaling_factor: typing.Optional[float] = None,
-    ) -> None: ...
+    ) -> _Function: ...
     def _bind_parameters(
         self,
         obj: modal.cls._Obj,
@@ -311,7 +312,7 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
     _is_method: bool
     _spec: typing.Optional[_FunctionSpec]
     _tag: str
-    _raw_f: typing.Callable[..., typing.Any]
+    _raw_f: typing.Optional[typing.Callable[..., typing.Any]]
     _build_args: dict
     _is_generator: typing.Optional[bool]
     _cluster_size: typing.Optional[int]
@@ -366,7 +367,7 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
         _experimental_buffer_containers: typing.Optional[int] = None,
         _experimental_proxy_ip: typing.Optional[str] = None,
         _experimental_custom_scaling_factor: typing.Optional[float] = None,
-    ) -> None: ...
+    ) -> Function: ...
     def _bind_parameters(
         self,
         obj: modal.cls.Obj,
@@ -462,11 +463,11 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
 
     _call_generator_nowait: ___call_generator_nowait_spec
 
-    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER: ...
         async def aio(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER: ...
 
-    remote: __remote_spec[P, ReturnType]
+    remote: __remote_spec[ReturnType, P]
 
     class __remote_gen_spec(typing_extensions.Protocol):
         def __call__(self, *args, **kwargs) -> typing.Generator[typing.Any, None, None]: ...
@@ -479,17 +480,17 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
     def _get_obj(self) -> typing.Optional[modal.cls.Obj]: ...
     def local(self, *args: P.args, **kwargs: P.kwargs) -> OriginalReturnType: ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
         async def aio(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
 
-    _experimental_spawn: ___experimental_spawn_spec[P, ReturnType]
+    _experimental_spawn: ___experimental_spawn_spec[ReturnType, P]
 
-    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
         def __call__(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
         async def aio(self, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
 
-    spawn: __spawn_spec[P, ReturnType]
+    spawn: __spawn_spec[ReturnType, P]
 
     def get_raw_f(self) -> typing.Callable[..., typing.Any]: ...
 
@@ -539,7 +540,7 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
 
     for_each: __for_each_spec
 
-class _FunctionCall(typing.Generic[ReturnType], modal.object._Object):
+class _FunctionCall(typing.Generic[ReturnType], modal._object._Object):
     _is_generator: bool
 
     def _invocation(self): ...

modal/image.py

@@ -26,6 +26,7 @@ from grpclib.exceptions import GRPCError, StreamTerminatedError
 
 from modal_proto import api_pb2
 
+from ._object import _Object, live_method_gen
 from ._resolver import Resolver
 from ._serialization import serialize
 from ._utils.async_utils import synchronize_api
@@ -46,7 +47,6 @@ from .file_pattern_matcher import NON_PYTHON_FILES, FilePatternMatcher, _ignore_
 from .gpu import GPU_T, parse_gpu_config
 from .mount import _Mount, python_standalone_mount_name
 from .network_file_system import _NetworkFileSystem
-from .object import _Object, live_method_gen
 from .output import _get_output_manager
 from .scheduler_placement import SchedulerPlacement
 from .secret import _Secret
@@ -2053,11 +2053,11 @@ class _Image(_Object, type_prefix="im"):
         try:
             yield
         except Exception as exc:
-            if self.object_id is None:
-                # Might be initialized later
+            if not self.is_hydrated:
+                # Might be hydrated later
                 self.inside_exceptions.append(exc)
             elif env_image_id == self.object_id:
-                # Image is already initialized (we can remove this case later
+                # Image is already hydrated (we can remove this case later
                 # when we don't hydrate objects so early)
                 raise
             if not isinstance(exc, ImportError):
@@ -2072,9 +2072,9 @@ class _Image(_Object, type_prefix="im"):
         last_entry_id: str = ""
 
         request = api_pb2.ImageJoinStreamingRequest(
-            image_id=self._object_id, timeout=55, last_entry_id=last_entry_id, include_logs_for_finished=True
+            image_id=self.object_id, timeout=55, last_entry_id=last_entry_id, include_logs_for_finished=True
         )
-        async for response in self._client.stub.ImageJoinStreaming.unary_stream(request):
+        async for response in self.client.stub.ImageJoinStreaming.unary_stream(request):
             if response.result.status:
                 return
             if response.entry_id:

modal/image.pyi

@@ -1,5 +1,6 @@
 import collections.abc
 import google.protobuf.message
+import modal._object
 import modal.client
 import modal.cloud_bucket_mount
 import modal.functions
@@ -78,7 +79,7 @@ async def _image_await_build_result(
     image_id: str, client: modal.client._Client
 ) -> modal_proto.api_pb2.ImageJoinStreamingResponse: ...
 
-class _Image(modal.object._Object):
+class _Image(modal._object._Object):
     force_build: bool
     inside_exceptions: list[Exception]
     _serve_mounts: frozenset[modal.mount._Mount]

modal/mount.py

@@ -20,6 +20,7 @@ import modal.file_pattern_matcher
 from modal_proto import api_pb2
 from modal_version import __version__
 
+from ._object import _get_environment_name, _Object
 from ._resolver import Resolver
 from ._utils.async_utils import aclosing, async_map, synchronize_api
 from ._utils.blob_utils import FileUploadSpec, blob_upload_file, get_file_upload_spec_from_path
@@ -31,7 +32,6 @@ from .client import _Client
 from .config import config, logger
 from .exception import InvalidError, ModuleNotMountable
 from .file_pattern_matcher import FilePatternMatcher
-from .object import _get_environment_name, _Object
 
 ROOT_DIR: PurePosixPath = PurePosixPath("/root")
 MOUNT_PUT_FILE_CLIENT_TIMEOUT = 10 * 60  # 10 min max for transferring files

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
@@ -76,7 +77,7 @@ class _MountedPythonModule(_MountEntry):
 
 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]

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

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