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

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: ...
@@ -84,6 +85,8 @@ class _Queue(modal.object._Object):
         self, *, partition: typing.Optional[str] = None, item_poll_timeout: float = 0.0
     ) -> collections.abc.AsyncGenerator[typing.Any, None]: ...
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 class Queue(modal.object.Object):
     def __init__(self): ...
     @staticmethod
@@ -138,13 +141,13 @@ class Queue(modal.object.Object):
 
     delete: __delete_spec
 
-    class ___get_nonblocking_spec(typing_extensions.Protocol):
+    class ___get_nonblocking_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, partition: typing.Optional[str], n_values: int) -> list[typing.Any]: ...
         async def aio(self, partition: typing.Optional[str], n_values: int) -> list[typing.Any]: ...
 
-    _get_nonblocking: ___get_nonblocking_spec
+    _get_nonblocking: ___get_nonblocking_spec[typing_extensions.Self]
 
-    class ___get_blocking_spec(typing_extensions.Protocol):
+    class ___get_blocking_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self, partition: typing.Optional[str], timeout: typing.Optional[float], n_values: int
         ) -> list[typing.Any]: ...
@@ -152,15 +155,15 @@ class Queue(modal.object.Object):
             self, partition: typing.Optional[str], timeout: typing.Optional[float], n_values: int
         ) -> list[typing.Any]: ...
 
-    _get_blocking: ___get_blocking_spec
+    _get_blocking: ___get_blocking_spec[typing_extensions.Self]
 
-    class __clear_spec(typing_extensions.Protocol):
+    class __clear_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, *, partition: typing.Optional[str] = None, all: bool = False) -> None: ...
         async def aio(self, *, partition: typing.Optional[str] = None, all: bool = False) -> None: ...
 
-    clear: __clear_spec
+    clear: __clear_spec[typing_extensions.Self]
 
-    class __get_spec(typing_extensions.Protocol):
+    class __get_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self, block: bool = True, timeout: typing.Optional[float] = None, *, partition: typing.Optional[str] = None
         ) -> typing.Optional[typing.Any]: ...
@@ -168,9 +171,9 @@ class Queue(modal.object.Object):
             self, block: bool = True, timeout: typing.Optional[float] = None, *, partition: typing.Optional[str] = None
         ) -> typing.Optional[typing.Any]: ...
 
-    get: __get_spec
+    get: __get_spec[typing_extensions.Self]
 
-    class __get_many_spec(typing_extensions.Protocol):
+    class __get_many_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self,
             n_values: int,
@@ -188,9 +191,9 @@ class Queue(modal.object.Object):
             partition: typing.Optional[str] = None,
         ) -> list[typing.Any]: ...
 
-    get_many: __get_many_spec
+    get_many: __get_many_spec[typing_extensions.Self]
 
-    class __put_spec(typing_extensions.Protocol):
+    class __put_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self,
             v: typing.Any,
@@ -210,9 +213,9 @@ class Queue(modal.object.Object):
             partition_ttl: int = 86400,
         ) -> None: ...
 
-    put: __put_spec
+    put: __put_spec[typing_extensions.Self]
 
-    class __put_many_spec(typing_extensions.Protocol):
+    class __put_many_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self,
             vs: list[typing.Any],
@@ -232,9 +235,9 @@ class Queue(modal.object.Object):
             partition_ttl: int = 86400,
         ) -> None: ...
 
-    put_many: __put_many_spec
+    put_many: __put_many_spec[typing_extensions.Self]
 
-    class ___put_many_blocking_spec(typing_extensions.Protocol):
+    class ___put_many_blocking_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self,
             partition: typing.Optional[str],
@@ -250,21 +253,21 @@ class Queue(modal.object.Object):
             timeout: typing.Optional[float] = None,
         ): ...
 
-    _put_many_blocking: ___put_many_blocking_spec
+    _put_many_blocking: ___put_many_blocking_spec[typing_extensions.Self]
 
-    class ___put_many_nonblocking_spec(typing_extensions.Protocol):
+    class ___put_many_nonblocking_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, partition: typing.Optional[str], partition_ttl: int, vs: list[typing.Any]): ...
         async def aio(self, partition: typing.Optional[str], partition_ttl: int, vs: list[typing.Any]): ...
 
-    _put_many_nonblocking: ___put_many_nonblocking_spec
+    _put_many_nonblocking: ___put_many_nonblocking_spec[typing_extensions.Self]
 
-    class __len_spec(typing_extensions.Protocol):
+    class __len_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, *, partition: typing.Optional[str] = None, total: bool = False) -> int: ...
         async def aio(self, *, partition: typing.Optional[str] = None, total: bool = False) -> int: ...
 
-    len: __len_spec
+    len: __len_spec[typing_extensions.Self]
 
-    class __iterate_spec(typing_extensions.Protocol):
+    class __iterate_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self, *, partition: typing.Optional[str] = None, item_poll_timeout: float = 0.0
         ) -> typing.Generator[typing.Any, None, None]: ...
@@ -272,4 +275,4 @@ class Queue(modal.object.Object):
             self, *, partition: typing.Optional[str] = None, item_poll_timeout: float = 0.0
         ) -> collections.abc.AsyncGenerator[typing.Any, None]: ...
 
-    iterate: __iterate_spec
+    iterate: __iterate_spec[typing_extensions.Self]

modal/runner.py

@@ -4,6 +4,7 @@ import dataclasses
 import os
 import time
 import typing
+import warnings
 from collections.abc import AsyncGenerator
 from multiprocessing.synchronize import Event
 from typing import TYPE_CHECKING, Any, Optional, TypeVar
@@ -14,6 +15,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 +30,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 +156,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()))
@@ -287,6 +288,16 @@ async def _run_app(
         client = await _Client.from_env()
 
     app_state = api_pb2.APP_STATE_DETACHED if detach else api_pb2.APP_STATE_EPHEMERAL
+
+    output_mgr = _get_output_manager()
+    if interactive and output_mgr is None:
+        warnings.warn(
+            "Interactive mode is disabled because no output manager is active. "
+            "Use 'with modal.enable_output():' to enable interactive mode and see logs.",
+            stacklevel=2,
+        )
+        interactive = False
+
     running_app: RunningApp = await _init_local_app_new(
         client,
         app.description or "",
@@ -306,7 +317,7 @@ async def _run_app(
         tc.infinite_loop(heartbeat, sleep=HEARTBEAT_INTERVAL, log_exception=not detach)
         logs_loop: Optional[asyncio.Task] = None
 
-        if output_mgr := _get_output_manager():
+        if output_mgr is not None:
             # Defer import so this module is rich-safe
             # TODO(michael): The get_app_logs_loop function is itself rich-safe aside from accepting an OutputManager
             # as an argument, so with some refactoring we could avoid the need for this deferred import.

modal/sandbox.py

@@ -16,9 +16,10 @@ 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
+from ._utils.async_utils import TaskContext, synchronize_api
 from ._utils.deprecation import deprecation_error
 from ._utils.grpc_utils import retry_transient_errors
 from ._utils.mount_utils import validate_network_file_systems, validate_volumes
@@ -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
@@ -165,7 +165,8 @@ class _Sandbox(_Object, type_prefix="sb"):
                 resources=convert_fn_config_to_resources_config(
                     cpu=cpu, memory=memory, gpu=gpu, ephemeral_disk=ephemeral_disk
                 ),
-                cloud_provider=parse_cloud_provider(cloud) if cloud else None,
+                cloud_provider=parse_cloud_provider(cloud) if cloud else None,  # Deprecated at some point
+                cloud_provider_str=cloud.upper() if cloud else None,  # Supersedes cloud_provider
                 nfs_mounts=network_file_system_mount_protos(validated_network_file_systems, False),
                 runtime_debug=config.get("function_runtime_debug"),
                 cloud_bucket_mounts=cloud_bucket_mounts_to_proto(cloud_bucket_mounts),
@@ -350,6 +351,7 @@ class _Sandbox(_Object, type_prefix="sb"):
         Returns an [`Image`](https://modal.com/docs/reference/modal.Image) object which
         can be used to spawn a new Sandbox with the same filesystem.
         """
+        await self._get_task_id()  # Ensure the sandbox has started
         req = api_pb2.SandboxSnapshotFsRequest(sandbox_id=self.object_id, timeout=timeout)
         resp = await retry_transient_errors(self._client.stub.SandboxSnapshotFs, req)
 
@@ -360,10 +362,12 @@ class _Sandbox(_Object, type_prefix="sb"):
         metadata = resp.image_metadata
 
         async def _load(self: _Image, resolver: Resolver, existing_object_id: Optional[str]):
-            self._hydrate(image_id, resolver.client, metadata)
+            # no need to hydrate again since we do it eagerly below
+            pass
 
         rep = "Image()"
-        image = _Image._from_loader(_load, rep)
+        image = _Image._from_loader(_load, rep, hydrate_lazily=True)
+        image._hydrate(image_id, self._client, metadata)  # hydrating eagerly since we have all of the data
 
         return image
 
@@ -513,8 +517,8 @@ class _Sandbox(_Object, type_prefix="sb"):
             raise InvalidError(f"workdir must be an absolute path, got: {workdir}")
 
         # Force secret resolution so we can pass the secret IDs to the backend.
-        for secret in secrets:
-            await secret.resolve(client=self._client)
+        secret_coros = [secret.hydrate(client=self._client) for secret in secrets]
+        await TaskContext.gather(*secret_coros)
 
         task_id = await self._get_task_id()
         req = api_pb2.ContainerExecRequest(

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]
@@ -154,6 +155,8 @@ class _Sandbox(modal.object._Object):
         client: typing.Optional[modal.client._Client] = None,
     ) -> collections.abc.AsyncGenerator[_Sandbox, None]: ...
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 class Sandbox(modal.object.Object):
     _result: typing.Optional[modal_proto.api_pb2.GenericResult]
     _stdout: modal.io_streams.StreamReader[str]
@@ -263,49 +266,49 @@ class Sandbox(modal.object.Object):
 
     from_id: __from_id_spec
 
-    class __set_tags_spec(typing_extensions.Protocol):
+    class __set_tags_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, tags: dict[str, str], *, client: typing.Optional[modal.client.Client] = None): ...
         async def aio(self, tags: dict[str, str], *, client: typing.Optional[modal.client.Client] = None): ...
 
-    set_tags: __set_tags_spec
+    set_tags: __set_tags_spec[typing_extensions.Self]
 
-    class __snapshot_filesystem_spec(typing_extensions.Protocol):
+    class __snapshot_filesystem_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, timeout: int = 55) -> modal.image.Image: ...
         async def aio(self, timeout: int = 55) -> modal.image.Image: ...
 
-    snapshot_filesystem: __snapshot_filesystem_spec
+    snapshot_filesystem: __snapshot_filesystem_spec[typing_extensions.Self]
 
-    class __wait_spec(typing_extensions.Protocol):
+    class __wait_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, raise_on_termination: bool = True): ...
         async def aio(self, raise_on_termination: bool = True): ...
 
-    wait: __wait_spec
+    wait: __wait_spec[typing_extensions.Self]
 
-    class __tunnels_spec(typing_extensions.Protocol):
+    class __tunnels_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, timeout: int = 50) -> dict[int, modal._tunnel.Tunnel]: ...
         async def aio(self, timeout: int = 50) -> dict[int, modal._tunnel.Tunnel]: ...
 
-    tunnels: __tunnels_spec
+    tunnels: __tunnels_spec[typing_extensions.Self]
 
-    class __terminate_spec(typing_extensions.Protocol):
+    class __terminate_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self): ...
         async def aio(self): ...
 
-    terminate: __terminate_spec
+    terminate: __terminate_spec[typing_extensions.Self]
 
-    class __poll_spec(typing_extensions.Protocol):
+    class __poll_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> typing.Optional[int]: ...
         async def aio(self) -> typing.Optional[int]: ...
 
-    poll: __poll_spec
+    poll: __poll_spec[typing_extensions.Self]
 
-    class ___get_task_id_spec(typing_extensions.Protocol):
+    class ___get_task_id_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self): ...
         async def aio(self): ...
 
-    _get_task_id: ___get_task_id_spec
+    _get_task_id: ___get_task_id_spec[typing_extensions.Self]
 
-    class __exec_spec(typing_extensions.Protocol):
+    class __exec_spec(typing_extensions.Protocol[SUPERSELF]):
         @typing.overload
         def __call__(
             self,
@@ -363,9 +366,9 @@ class Sandbox(modal.object.Object):
             _pty_info: typing.Optional[modal_proto.api_pb2.PTYInfo] = None,
         ) -> modal.container_process.ContainerProcess[bytes]: ...
 
-    exec: __exec_spec
+    exec: __exec_spec[typing_extensions.Self]
 
-    class __open_spec(typing_extensions.Protocol):
+    class __open_spec(typing_extensions.Protocol[SUPERSELF]):
         @typing.overload
         def __call__(self, path: str, mode: _typeshed.OpenTextMode) -> modal.file_io.FileIO[str]: ...
         @typing.overload
@@ -375,27 +378,27 @@ class Sandbox(modal.object.Object):
         @typing.overload
         async def aio(self, path: str, mode: _typeshed.OpenBinaryMode) -> modal.file_io.FileIO[bytes]: ...
 
-    open: __open_spec
+    open: __open_spec[typing_extensions.Self]
 
-    class __ls_spec(typing_extensions.Protocol):
+    class __ls_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, path: str) -> list[str]: ...
         async def aio(self, path: str) -> list[str]: ...
 
-    ls: __ls_spec
+    ls: __ls_spec[typing_extensions.Self]
 
-    class __mkdir_spec(typing_extensions.Protocol):
+    class __mkdir_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, path: str, parents: bool = False) -> None: ...
         async def aio(self, path: str, parents: bool = False) -> None: ...
 
-    mkdir: __mkdir_spec
+    mkdir: __mkdir_spec[typing_extensions.Self]
 
-    class __rm_spec(typing_extensions.Protocol):
+    class __rm_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, path: str, recursive: bool = False) -> None: ...
         async def aio(self, path: str, recursive: bool = False) -> None: ...
 
-    rm: __rm_spec
+    rm: __rm_spec[typing_extensions.Self]
 
-    class __watch_spec(typing_extensions.Protocol):
+    class __watch_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self,
             path: str,
@@ -411,7 +414,7 @@ class Sandbox(modal.object.Object):
             timeout: typing.Optional[int] = None,
         ) -> typing.AsyncIterator[modal.file_io.FileWatchEvent]: ...
 
-    watch: __watch_spec
+    watch: __watch_spec[typing_extensions.Self]
 
     @property
     def stdout(self) -> 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/token_flow.pyi

@@ -13,10 +13,12 @@ class _TokenFlow:
         self, timeout: float = 40.0, grpc_extra_timeout: float = 5.0
     ) -> typing.Optional[modal_proto.api_pb2.TokenFlowWaitResponse]: ...
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 class TokenFlow:
     def __init__(self, client: modal.client.Client): ...
 
-    class __start_spec(typing_extensions.Protocol):
+    class __start_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self, utm_source: typing.Optional[str] = None, next_url: typing.Optional[str] = None
         ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[tuple[str, str, str]]: ...
@@ -24,9 +26,9 @@ class TokenFlow:
             self, utm_source: typing.Optional[str] = None, next_url: typing.Optional[str] = None
         ) -> typing.AsyncContextManager[tuple[str, str, str]]: ...
 
-    start: __start_spec
+    start: __start_spec[typing_extensions.Self]
 
-    class __finish_spec(typing_extensions.Protocol):
+    class __finish_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self, timeout: float = 40.0, grpc_extra_timeout: float = 5.0
         ) -> typing.Optional[modal_proto.api_pb2.TokenFlowWaitResponse]: ...
@@ -34,7 +36,7 @@ class TokenFlow:
             self, timeout: float = 40.0, grpc_extra_timeout: float = 5.0
         ) -> typing.Optional[modal_proto.api_pb2.TokenFlowWaitResponse]: ...
 
-    finish: __finish_spec
+    finish: __finish_spec[typing_extensions.Self]
 
 async def _new_token(
     *,

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): ...
@@ -98,16 +99,16 @@ class _VolumeUploadContextManager:
     _volume_id: str
     _client: modal.client._Client
     _force: bool
-    progress_cb: typing.Callable[..., typing.Any]
+    progress_cb: collections.abc.Callable[..., typing.Any]
     _upload_generators: list[
-        collections.abc.Generator[typing.Callable[[], modal._utils.blob_utils.FileUploadSpec], None, None]
+        collections.abc.Generator[collections.abc.Callable[[], modal._utils.blob_utils.FileUploadSpec], None, None]
     ]
 
     def __init__(
         self,
         volume_id: str,
         client: modal.client._Client,
-        progress_cb: typing.Optional[typing.Callable[..., typing.Any]] = None,
+        progress_cb: typing.Optional[collections.abc.Callable[..., typing.Any]] = None,
         force: bool = False,
     ): ...
     async def __aenter__(self): ...
@@ -128,16 +129,18 @@ class _VolumeUploadContextManager:
         self, file_spec: modal._utils.blob_utils.FileUploadSpec
     ) -> modal_proto.api_pb2.MountFile: ...
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 class Volume(modal.object.Object):
     _lock: typing.Optional[asyncio.locks.Lock]
 
     def __init__(self, *args, **kwargs): ...
 
-    class ___get_lock_spec(typing_extensions.Protocol):
+    class ___get_lock_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self): ...
         async def aio(self): ...
 
-    _get_lock: ___get_lock_spec
+    _get_lock: ___get_lock_spec[typing_extensions.Self]
 
     @staticmethod
     def from_name(
@@ -198,71 +201,71 @@ class Volume(modal.object.Object):
 
     create_deployed: __create_deployed_spec
 
-    class ___do_reload_spec(typing_extensions.Protocol):
+    class ___do_reload_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, lock=True): ...
         async def aio(self, lock=True): ...
 
-    _do_reload: ___do_reload_spec
+    _do_reload: ___do_reload_spec[typing_extensions.Self]
 
-    class __commit_spec(typing_extensions.Protocol):
+    class __commit_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self): ...
         async def aio(self): ...
 
-    commit: __commit_spec
+    commit: __commit_spec[typing_extensions.Self]
 
-    class __reload_spec(typing_extensions.Protocol):
+    class __reload_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self): ...
         async def aio(self): ...
 
-    reload: __reload_spec
+    reload: __reload_spec[typing_extensions.Self]
 
-    class __iterdir_spec(typing_extensions.Protocol):
+    class __iterdir_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, path: str, *, recursive: bool = True) -> typing.Iterator[FileEntry]: ...
         def aio(self, path: str, *, recursive: bool = True) -> collections.abc.AsyncIterator[FileEntry]: ...
 
-    iterdir: __iterdir_spec
+    iterdir: __iterdir_spec[typing_extensions.Self]
 
-    class __listdir_spec(typing_extensions.Protocol):
+    class __listdir_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, path: str, *, recursive: bool = False) -> list[FileEntry]: ...
         async def aio(self, path: str, *, recursive: bool = False) -> list[FileEntry]: ...
 
-    listdir: __listdir_spec
+    listdir: __listdir_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 __read_file_into_fileobj_spec(typing_extensions.Protocol):
+    class __read_file_into_fileobj_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, path: str, fileobj: typing.IO[bytes]) -> int: ...
         async def aio(self, path: str, fileobj: typing.IO[bytes]) -> int: ...
 
-    read_file_into_fileobj: __read_file_into_fileobj_spec
+    read_file_into_fileobj: __read_file_into_fileobj_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: bool = False) -> None: ...
         async def aio(self, path: str, recursive: bool = False) -> None: ...
 
-    remove_file: __remove_file_spec
+    remove_file: __remove_file_spec[typing_extensions.Self]
 
-    class __copy_files_spec(typing_extensions.Protocol):
+    class __copy_files_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, src_paths: collections.abc.Sequence[str], dst_path: str) -> None: ...
         async def aio(self, src_paths: collections.abc.Sequence[str], dst_path: str) -> None: ...
 
-    copy_files: __copy_files_spec
+    copy_files: __copy_files_spec[typing_extensions.Self]
 
-    class __batch_upload_spec(typing_extensions.Protocol):
+    class __batch_upload_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, force: bool = False) -> VolumeUploadContextManager: ...
         async def aio(self, force: bool = False) -> VolumeUploadContextManager: ...
 
-    batch_upload: __batch_upload_spec
+    batch_upload: __batch_upload_spec[typing_extensions.Self]
 
-    class ___instance_delete_spec(typing_extensions.Protocol):
+    class ___instance_delete_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self): ...
         async def aio(self): ...
 
-    _instance_delete: ___instance_delete_spec
+    _instance_delete: ___instance_delete_spec[typing_extensions.Self]
 
     class __delete_spec(typing_extensions.Protocol):
         def __call__(
@@ -304,16 +307,16 @@ class VolumeUploadContextManager:
     _volume_id: str
     _client: modal.client.Client
     _force: bool
-    progress_cb: typing.Callable[..., typing.Any]
+    progress_cb: collections.abc.Callable[..., typing.Any]
     _upload_generators: list[
-        collections.abc.Generator[typing.Callable[[], modal._utils.blob_utils.FileUploadSpec], None, None]
+        collections.abc.Generator[collections.abc.Callable[[], modal._utils.blob_utils.FileUploadSpec], None, None]
     ]
 
     def __init__(
         self,
         volume_id: str,
         client: modal.client.Client,
-        progress_cb: typing.Optional[typing.Callable[..., typing.Any]] = None,
+        progress_cb: typing.Optional[collections.abc.Callable[..., typing.Any]] = None,
         force: bool = False,
     ): ...
     def __enter__(self): ...
@@ -333,10 +336,10 @@ class VolumeUploadContextManager:
         recursive: bool = True,
     ): ...
 
-    class ___upload_file_spec(typing_extensions.Protocol):
+    class ___upload_file_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, file_spec: modal._utils.blob_utils.FileUploadSpec) -> modal_proto.api_pb2.MountFile: ...
         async def aio(self, file_spec: modal._utils.blob_utils.FileUploadSpec) -> modal_proto.api_pb2.MountFile: ...
 
-    _upload_file: ___upload_file_spec
+    _upload_file: ___upload_file_spec[typing_extensions.Self]
 
 def _open_files_error_annotation(mount_path: str) -> typing.Optional[str]: ...