modal 0.72.20__py3-none-any.whl → 0.72.22__py3-none-any.whl

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,26 @@ 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): ...
-
 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]]
+        typing.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]]
+        typing.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]]]
+    _deps: typing.Optional[typing.Callable[..., collections.abc.Sequence[Object]]]
     _deduplication_key: typing.Optional[typing.Callable[[], collections.abc.Awaitable[collections.abc.Hashable]]]
-    _object_id: str
-    _client: modal.client.Client
+    _object_id: typing.Optional[str]
+    _client: typing.Optional[modal.client.Client]
     _is_hydrated: bool
     _is_rehydrated: bool
 
@@ -128,14 +37,14 @@ class Object:
             self,
             rep: str,
             load: typing.Optional[
-                typing.Callable[[_BLOCKING_O, modal._resolver.Resolver, typing.Optional[str]], None]
+                typing.Callable[[typing_extensions.Self, 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]
+                typing.Callable[[typing_extensions.Self, modal._resolver.Resolver, typing.Optional[str]], None]
             ] = None,
             hydrate_lazily: bool = False,
-            deps: typing.Optional[typing.Callable[..., list[Object]]] = None,
+            deps: typing.Optional[typing.Callable[..., collections.abc.Sequence[Object]]] = None,
             deduplication_key: typing.Optional[typing.Callable[[], collections.abc.Hashable]] = None,
         ): ...
         def aio(
@@ -143,17 +52,19 @@ class Object:
             rep: str,
             load: typing.Optional[
                 typing.Callable[
-                    [_BLOCKING_O, modal._resolver.Resolver, typing.Optional[str]], collections.abc.Awaitable[None]
+                    [typing_extensions.Self, 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]
+                    [typing_extensions.Self, 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[typing.Callable[..., collections.abc.Sequence[Object]]] = None,
             deduplication_key: typing.Optional[
                 typing.Callable[[], collections.abc.Awaitable[collections.abc.Hashable]]
             ] = None,
@@ -169,51 +80,48 @@ 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: typing.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]
+            typing.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,
     ): ...
+    @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) -> typing.Callable[..., collections.abc.Sequence[Object]]: ...
 
     class __resolve_spec(typing_extensions.Protocol):
         def __call__(self, client: typing.Optional[modal.client.Client] = None): ...
         async def aio(self, client: typing.Optional[modal.client.Client] = None): ...
 
     resolve: __resolve_spec
-
-def live_method(method): ...
-def live_method_gen(method): ...
-
-EPHEMERAL_OBJECT_HEARTBEAT_SLEEP: int

modal/proxy.py

@@ -3,9 +3,9 @@ from typing import Optional
 
 from modal_proto import api_pb2
 
+from ._object import _get_environment_name, _Object
 from ._resolver import Resolver
 from ._utils.async_utils import synchronize_api
-from .object import _get_environment_name, _Object
 
 
 class _Proxy(_Object, type_prefix="pr"):

modal/proxy.pyi

@@ -1,7 +1,8 @@
+import modal._object
 import modal.object
 import typing
 
-class _Proxy(modal.object._Object):
+class _Proxy(modal._object._Object):
     @staticmethod
     def from_name(name: str, environment_name: typing.Optional[str] = None) -> _Proxy: ...
 

modal/queue.py

@@ -10,6 +10,7 @@ from synchronicity.async_wrap import asynccontextmanager
 
 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 ._serialization import deserialize, serialize
 from ._utils.async_utils import TaskContext, synchronize_api, warn_if_generator_is_not_consumed
@@ -18,7 +19,6 @@ from ._utils.grpc_utils import retry_transient_errors
 from ._utils.name_utils import check_object_name
 from .client import _Client
 from .exception import InvalidError, RequestSizeError
-from .object import EPHEMERAL_OBJECT_HEARTBEAT_SLEEP, _get_environment_name, _Object, live_method, live_method_gen
 
 
 class _Queue(_Object, type_prefix="qu"):

modal/queue.pyi

@@ -1,11 +1,12 @@
 import collections.abc
+import modal._object
 import modal.client
 import modal.object
 import synchronicity.combined_types
 import typing
 import typing_extensions
 
-class _Queue(modal.object._Object):
+class _Queue(modal._object._Object):
     def __init__(self): ...
     @staticmethod
     def validate_partition_key(partition: typing.Optional[str]) -> bytes: ...

modal/runner.py

@@ -14,6 +14,7 @@ from synchronicity.async_wrap import asynccontextmanager
 import modal_proto.api_pb2
 from modal_proto import api_pb2
 
+from ._object import _get_environment_name, _Object
 from ._pty import get_pty_info
 from ._resolver import Resolver
 from ._runtime.execution_context import is_local
@@ -28,7 +29,6 @@ from .config import config, logger
 from .environments import _get_environment_cached
 from .exception import InteractiveTimeoutError, InvalidError, RemoteError, _CliUserExecutionError
 from .functions import _Function
-from .object import _get_environment_name, _Object
 from .output import _get_output_manager, enable_output
 from .running_app import RunningApp, running_app_from_layout
 from .sandbox import _Sandbox
@@ -155,7 +155,7 @@ async def _create_all_objects(
             # this is to ensure that directly referenced functions from the global scope has
             # ids associated with them when they are serialized into other functions
             await resolver.preload(obj, existing_object_id)
-            if obj.object_id is not None:
+            if obj.is_hydrated:
                 tag_to_object_id[tag] = obj.object_id
 
         await TaskContext.gather(*(_preload(tag, obj) for tag, obj in indexed_objects.items()))

modal/sandbox.py

@@ -16,6 +16,7 @@ from modal.volume import _Volume
 from modal_proto import api_pb2
 
 from ._location import parse_cloud_provider
+from ._object import _get_environment_name, _Object
 from ._resolver import Resolver
 from ._resources import convert_fn_config_to_resources_config
 from ._utils.async_utils import synchronize_api
@@ -32,7 +33,6 @@ from .image import _Image
 from .io_streams import StreamReader, StreamWriter, _StreamReader, _StreamWriter
 from .mount import _Mount
 from .network_file_system import _NetworkFileSystem, network_file_system_mount_protos
-from .object import _get_environment_name, _Object
 from .proxy import _Proxy
 from .scheduler_placement import SchedulerPlacement
 from .secret import _Secret

modal/sandbox.pyi

@@ -1,6 +1,7 @@
 import _typeshed
 import collections.abc
 import google.protobuf.message
+import modal._object
 import modal._tunnel
 import modal.app
 import modal.client
@@ -23,7 +24,7 @@ import os
 import typing
 import typing_extensions
 
-class _Sandbox(modal.object._Object):
+class _Sandbox(modal._object._Object):
     _result: typing.Optional[modal_proto.api_pb2.GenericResult]
     _stdout: modal.io_streams._StreamReader[str]
     _stderr: modal.io_streams._StreamReader[str]

modal/secret.py

@@ -6,6 +6,7 @@ from grpclib import GRPCError, Status
 
 from modal_proto import api_pb2
 
+from ._object import _get_environment_name, _Object
 from ._resolver import Resolver
 from ._runtime.execution_context import is_local
 from ._utils.async_utils import synchronize_api
@@ -14,7 +15,6 @@ from ._utils.grpc_utils import retry_transient_errors
 from ._utils.name_utils import check_object_name
 from .client import _Client
 from .exception import InvalidError, NotFoundError
-from .object import _get_environment_name, _Object
 
 ENV_DICT_WRONG_TYPE_ERR = "the env_dict argument to Secret has to be a dict[str, Union[str, None]]"
 

modal/secret.pyi

@@ -1,9 +1,10 @@
+import modal._object
 import modal.client
 import modal.object
 import typing
 import typing_extensions
 
-class _Secret(modal.object._Object):
+class _Secret(modal._object._Object):
     @staticmethod
     def from_dict(env_dict: dict[str, typing.Optional[str]] = {}): ...
     @staticmethod

modal/volume.py

@@ -27,6 +27,7 @@ import modal_proto.api_pb2
 from modal.exception import VolumeUploadTimeoutError
 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, asyncnullcontext, synchronize_api
 from ._utils.blob_utils import (
@@ -41,7 +42,6 @@ from ._utils.grpc_utils import retry_transient_errors
 from ._utils.name_utils import check_object_name
 from .client import _Client
 from .config import logger
-from .object import EPHEMERAL_OBJECT_HEARTBEAT_SLEEP, _get_environment_name, _Object, live_method, live_method_gen
 
 # Max duration for uploading to volumes files
 # As a guide, files >40GiB will take >10 minutes to upload.

modal/volume.pyi

@@ -1,6 +1,7 @@
 import asyncio.locks
 import collections.abc
 import enum
+import modal._object
 import modal._utils.blob_utils
 import modal.client
 import modal.object
@@ -33,7 +34,7 @@ class FileEntry:
     def __delattr__(self, name): ...
     def __hash__(self): ...
 
-class _Volume(modal.object._Object):
+class _Volume(modal._object._Object):
     _lock: typing.Optional[asyncio.locks.Lock]
 
     async def _get_lock(self): ...