modal 1.1.5.dev66__py3-none-any.whl → 1.3.1.dev8__py3-none-any.whl

modal/_partial_function.py

@@ -19,7 +19,7 @@ from ._functions import _Function
 from ._utils.async_utils import synchronizer
 from ._utils.deprecation import deprecation_warning
 from ._utils.function_utils import callable_has_non_self_params
-from .config import logger
+from .config import config, logger
 from .exception import InvalidError
 
 MAX_MAX_BATCH_SIZE = 1000
@@ -46,6 +46,7 @@ class _PartialFunctionFlags(enum.IntFlag):
     BATCHED = 64
     CONCURRENT = 128
     CLUSTERED = 256  # Experimental: Clustered functions
+    HTTP_WEB_INTERFACE = 512  # Experimental: HTTP server
 
     @staticmethod
     def all() -> int:
@@ -76,6 +77,7 @@ class _PartialFunctionParams:
     target_concurrent_inputs: Optional[int] = None
     build_timeout: Optional[int] = None
     rdma: Optional[bool] = None
+    http_config: Optional[api_pb2.HTTPConfig] = None
 
     def update(self, other: "_PartialFunctionParams") -> None:
         """Update self with params set in other."""
@@ -93,6 +95,26 @@ NullaryFuncOrMethod = Union[Callable[[], Any], Callable[[Any], Any]]
 NullaryMethod = Callable[[Any], Any]
 
 
+def verify_concurrent_params(params: _PartialFunctionParams, is_flash: bool = False) -> None:
+    def _verify_concurrent_params_with_flash_settings(params: _PartialFunctionParams) -> None:
+        if params.max_concurrent_inputs is not None:
+            raise TypeError(
+                "@modal.concurrent(max_inputs=...) is not yet supported for Flash functions. "
+                "Use `@modal.concurrent(target_inputs=...)` instead."
+            )
+        if params.target_concurrent_inputs is None:
+            raise TypeError("`@modal.concurrent()` missing required argument: `target_inputs`.")
+
+    def _verify_concurrent_params(params: _PartialFunctionParams) -> None:
+        if params.max_concurrent_inputs is None:
+            raise TypeError("`@modal.concurrent()` missing required argument: `max_inputs`.")
+
+    if is_flash:
+        _verify_concurrent_params_with_flash_settings(params)
+    else:
+        _verify_concurrent_params(params)
+
+
 class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
     """Object produced by a decorator in the `modal` namespace
 
@@ -199,7 +221,7 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
         # of the type PartialFunction and this descriptor would be triggered when accessing it,
         #
         # However, modal classes are *actually* Cls instances (which isn't reflected in type checkers
-        # due to Python's lack of type chekcing intersection types), so at runtime the Cls instance would
+        # due to Python's lack of type checking intersection types), so at runtime the Cls instance would
         # use its __getattr__ rather than this descriptor.
         assert self.raw_f is not None  # Should only be relevant in a method context
         k = self.raw_f.__name__
@@ -378,6 +400,7 @@ def _fastapi_endpoint(
         method=method,
         web_endpoint_docs=docs,
         requested_suffix=label or "",
+        ephemeral_suffix=config.get("dev_suffix"),
         async_mode=api_pb2.WEBHOOK_ASYNC_MODE_AUTO,
         custom_domains=_parse_custom_domains(custom_domains),
         requires_proxy_auth=requires_proxy_auth,
@@ -446,6 +469,7 @@ def _web_endpoint(
         method=method,
         web_endpoint_docs=docs,
         requested_suffix=label or "",
+        ephemeral_suffix=config.get("dev_suffix"),
         async_mode=api_pb2.WEBHOOK_ASYNC_MODE_AUTO,
         custom_domains=_parse_custom_domains(custom_domains),
         requires_proxy_auth=requires_proxy_auth,
@@ -505,6 +529,7 @@ def _asgi_app(
     webhook_config = api_pb2.WebhookConfig(
         type=api_pb2.WEBHOOK_TYPE_ASGI_APP,
         requested_suffix=label or "",
+        ephemeral_suffix=config.get("dev_suffix"),
         async_mode=api_pb2.WEBHOOK_ASYNC_MODE_AUTO,
         custom_domains=_parse_custom_domains(custom_domains),
         requires_proxy_auth=requires_proxy_auth,
@@ -562,6 +587,7 @@ def _wsgi_app(
     webhook_config = api_pb2.WebhookConfig(
         type=api_pb2.WEBHOOK_TYPE_WSGI_APP,
         requested_suffix=label or "",
+        ephemeral_suffix=config.get("dev_suffix"),
         async_mode=api_pb2.WEBHOOK_ASYNC_MODE_AUTO,
         custom_domains=_parse_custom_domains(custom_domains),
         requires_proxy_auth=requires_proxy_auth,
@@ -623,6 +649,7 @@ def _web_server(
     webhook_config = api_pb2.WebhookConfig(
         type=api_pb2.WEBHOOK_TYPE_WEB_SERVER,
         requested_suffix=label or "",
+        ephemeral_suffix=config.get("dev_suffix"),
         async_mode=api_pb2.WEBHOOK_ASYNC_MODE_AUTO,
         custom_domains=_parse_custom_domains(custom_domains),
         web_server_port=port,
@@ -760,7 +787,7 @@ def _batched(
 def _concurrent(
     _warn_parentheses_missing=None,  # mdmd:line-hidden
     *,
-    max_inputs: int,  # Hard limit on each container's input concurrency
+    max_inputs: Optional[int] = None,  # Hard limit on each container's input concurrency
     target_inputs: Optional[int] = None,  # Input concurrency that Modal's autoscaler should target
 ) -> Callable[
     [Union[Callable[P, ReturnType], _PartialFunction[P, ReturnType, ReturnType]]],
@@ -812,7 +839,7 @@ def _concurrent(
             "Positional arguments are not allowed. Did you forget parentheses? Suggestion: `@modal.concurrent()`."
         )
 
-    if target_inputs and target_inputs > max_inputs:
+    if max_inputs is not None and target_inputs is not None and target_inputs > max_inputs:
         raise InvalidError("`target_inputs` parameter cannot be greater than `max_inputs`.")
 
     flags = _PartialFunctionFlags.CONCURRENT

modal/_resolver.py

@@ -8,17 +8,16 @@ from asyncio import Future
 from collections.abc import Hashable
 from typing import TYPE_CHECKING, Optional
 
-from modal._traceback import suppress_tb_frames
+import modal._object
+from modal._traceback import suppress_tb_frame
 from modal_proto import api_pb2
 
+from ._load_context import LoadContext
 from ._utils.async_utils import TaskContext
-from .client import _Client
 
 if TYPE_CHECKING:
     from rich.tree import Tree
 
-    import modal._object
-
 
 class StatusRow:
     def __init__(self, progress: "typing.Optional[Tree]"):
@@ -48,19 +47,10 @@ class StatusRow:
 
 class Resolver:
     _local_uuid_to_future: dict[str, Future]
-    _environment_name: Optional[str]
-    _app_id: Optional[str]
     _deduplication_cache: dict[Hashable, Future]
-    _client: _Client
     _build_start: float
 
-    def __init__(
-        self,
-        client: _Client,
-        *,
-        environment_name: Optional[str] = None,
-        app_id: Optional[str] = None,
-    ):
+    def __init__(self):
         try:
             # TODO(michael) If we don't clean this up more thoroughly, it would probably
             # be good to have a single source of truth for "rich is installed" rather than
@@ -75,9 +65,6 @@ class Resolver:
 
         self._local_uuid_to_future = {}
         self._tree = tree
-        self._client = client
-        self._app_id = app_id
-        self._environment_name = environment_name
         self._deduplication_cache = {}
 
         with tempfile.TemporaryFile() as temp_file:
@@ -85,27 +72,24 @@ class Resolver:
             # to the mtime on mounted files, and want those measurements to have the same resolution.
             self._build_start = os.fstat(temp_file.fileno()).st_mtime
 
-    @property
-    def app_id(self) -> Optional[str]:
-        return self._app_id
-
-    @property
-    def client(self):
-        return self._client
-
-    @property
-    def environment_name(self):
-        return self._environment_name
-
     @property
     def build_start(self) -> float:
         return self._build_start
 
-    async def preload(self, obj, existing_object_id: Optional[str]):
+    async def preload(
+        self, obj: "modal._object._Object", parent_load_context: "LoadContext", existing_object_id: Optional[str]
+    ):
         if obj._preload is not None:
-            await obj._preload(obj, self, existing_object_id)
+            load_context = obj._load_context_overrides.merged_with(parent_load_context)
+            await obj._preload(obj, self, load_context, existing_object_id)
 
-    async def load(self, obj: "modal._object._Object", existing_object_id: Optional[str] = None):
+    async def load(
+        self,
+        obj: "modal._object._Object",
+        parent_load_context: "LoadContext",
+        *,
+        existing_object_id: Optional[str] = None,
+    ):
         if obj._is_hydrated and obj._is_another_app:
             # No need to reload this, it won't typically change
             if obj.local_uuid not in self._local_uuid_to_future:
@@ -129,42 +113,45 @@ class Resolver:
             cached_future = self._deduplication_cache.get(deduplication_key)
             if cached_future:
                 hydrated_object = await cached_future
-                obj._hydrate(hydrated_object.object_id, self._client, hydrated_object._get_metadata())
+                # Use the client from the already-hydrated object
+                obj._hydrate(hydrated_object.object_id, hydrated_object.client, hydrated_object._get_metadata())
                 return obj
 
         if not cached_future:
             # don't run any awaits within this if-block to prevent race conditions
             async def loader():
-                # Wait for all its dependencies
-                # TODO(erikbern): do we need existing_object_id for those?
-                await TaskContext.gather(*[self.load(dep) for dep in obj.deps()])
-
-                # Load the object itself
-                if not obj._load:
-                    raise Exception(f"Object {obj} has no loader function")
-
-                await obj._load(obj, self, existing_object_id)
-
-                # Check that the id of functions didn't change
-                # Persisted refs are ignored because their life cycle is managed independently.
-                if (
-                    not obj._is_another_app
-                    and existing_object_id is not None
-                    and existing_object_id.startswith("fu-")
-                    and obj.object_id != existing_object_id
-                ):
-                    raise Exception(
-                        f"Tried creating an object using existing id {existing_object_id} but it has id {obj.object_id}"
-                    )
+                with suppress_tb_frame():
+                    load_context = await obj._load_context_overrides.merged_with(parent_load_context).apply_defaults()
 
-                return obj
+                    # TODO(erikbern): do we need existing_object_id for those?
+                    await TaskContext.gather(*[self.load(dep, load_context) for dep in obj.deps()])
+
+                    # Load the object itself
+                    if not obj._load:
+                        raise Exception(f"Object {obj} has no loader function")
+
+                    await obj._load(obj, self, load_context, existing_object_id)
+
+                    # Check that the id of functions didn't change
+                    # Persisted refs are ignored because their life cycle is managed independently.
+                    if (
+                        not obj._is_another_app
+                        and existing_object_id is not None
+                        and existing_object_id.startswith("fu-")
+                        and obj.object_id != existing_object_id
+                    ):
+                        raise Exception(
+                            f"Tried creating an object using existing id {existing_object_id} "
+                            f"but it has id {obj.object_id}"
+                        )
+
+                    return obj
 
             cached_future = asyncio.create_task(loader())
             self._local_uuid_to_future[obj.local_uuid] = cached_future
             if deduplication_key is not None:
                 self._deduplication_cache[deduplication_key] = cached_future
-        with suppress_tb_frames(2):
-            # skip current frame + `loader()` closure frame from above
+        with suppress_tb_frame():
             return await cached_future
 
     def objects(self) -> list["modal._object._Object"]:

modal/_runtime/container_io_manager.py

@@ -36,7 +36,7 @@ from modal._traceback import print_exception
 from modal._utils.async_utils import TaskContext, aclosing, asyncify, synchronize_api, synchronizer
 from modal._utils.blob_utils import MAX_OBJECT_SIZE_BYTES, blob_download, blob_upload, format_blob_data
 from modal._utils.function_utils import _stream_function_call_data
-from modal._utils.grpc_utils import retry_transient_errors
+from modal._utils.grpc_utils import Retry
 from modal._utils.package_utils import parse_major_minor_version
 from modal.client import HEARTBEAT_INTERVAL, HEARTBEAT_TIMEOUT, _Client
 from modal.config import config, logger
@@ -278,11 +278,13 @@ class IOContext:
         logger.debug(f"Finished generator input {self.input_ids}")
 
     async def output_items_cancellation(self, started_at: float):
+        output_created_at = time.time()
         # Create terminated outputs for these inputs to signal that the cancellations have been completed.
         return [
             api_pb2.FunctionPutOutputsItem(
                 input_id=input_id,
                 input_started_at=started_at,
+                output_created_at=output_created_at,
                 result=api_pb2.GenericResult(status=api_pb2.GenericResult.GENERIC_STATUS_TERMINATED),
                 retry_count=retry_count,
             )
@@ -354,10 +356,12 @@ class IOContext:
                 }
 
         # all inputs in the batch get the same failure:
+        output_created_at = time.time()
         return [
             api_pb2.FunctionPutOutputsItem(
                 input_id=input_id,
                 input_started_at=started_at,
+                output_created_at=output_created_at,
                 retry_count=retry_count,
                 **data_format_specific_output(function_input.data_format),
             )
@@ -619,8 +623,8 @@ class _ContainerIOManager:
                 await self.heartbeat_condition.wait()
 
             request = api_pb2.ContainerHeartbeatRequest(canceled_inputs_return_outputs_v2=True)
-            response = await retry_transient_errors(
-                self._client.stub.ContainerHeartbeat, request, attempt_timeout=HEARTBEAT_TIMEOUT
+            response = await self._client.stub.ContainerHeartbeat(
+                request, retry=Retry(attempt_timeout=HEARTBEAT_TIMEOUT)
             )
 
         if response.HasField("cancel_input_event"):
@@ -667,10 +671,9 @@ class _ContainerIOManager:
                     target_concurrency=self._target_concurrency,
                     max_concurrency=self._max_concurrency,
                 )
-                resp = await retry_transient_errors(
-                    self._client.stub.FunctionGetDynamicConcurrency,
+                resp = await self._client.stub.FunctionGetDynamicConcurrency(
                     request,
-                    attempt_timeout=DYNAMIC_CONCURRENCY_TIMEOUT_SECS,
+                    retry=Retry(attempt_timeout=DYNAMIC_CONCURRENCY_TIMEOUT_SECS),
                 )
                 if resp.concurrency != self._input_slots.value and not self._stop_concurrency_loop:
                     logger.debug(f"Dynamic concurrency set from {self._input_slots.value} to {resp.concurrency}")
@@ -721,9 +724,9 @@ class _ContainerIOManager:
 
         if self.input_plane_server_url:
             stub = await self._client.get_stub(self.input_plane_server_url)
-            await retry_transient_errors(stub.FunctionCallPutDataOut, req)
+            await stub.FunctionCallPutDataOut(req)
         else:
-            await retry_transient_errors(self._client.stub.FunctionCallPutDataOut, req)
+            await self._client.stub.FunctionCallPutDataOut(req)
 
     @asynccontextmanager
     async def generator_output_sender(
@@ -811,9 +814,7 @@ class _ContainerIOManager:
             try:
                 # If number of active inputs is at max queue size, this will block.
                 iteration += 1
-                response: api_pb2.FunctionGetInputsResponse = await retry_transient_errors(
-                    self._client.stub.FunctionGetInputs, request
-                )
+                response: api_pb2.FunctionGetInputsResponse = await self._client.stub.FunctionGetInputs(request)
 
                 if response.rate_limit_sleep_duration:
                     logger.info(
@@ -844,8 +845,9 @@ class _ContainerIOManager:
                     yield inputs
                     yielded = True
 
-                    # We only support max_inputs = 1 at the moment
-                    if final_input_received or self.function_def.max_inputs == 1:
+                    # TODO(michael): Remove use of max_inputs after worker rollover
+                    single_use_container = self.function_def.single_use_containers or self.function_def.max_inputs == 1
+                    if final_input_received or single_use_container:
                         return
             finally:
                 if not yielded:
@@ -883,11 +885,12 @@ class _ContainerIOManager:
         # Limit the batch size to 20 to stay within message size limits and buffer size limits.
         output_batch_size = 20
         for i in range(0, len(outputs), output_batch_size):
-            await retry_transient_errors(
-                self._client.stub.FunctionPutOutputs,
+            await self._client.stub.FunctionPutOutputs(
                 api_pb2.FunctionPutOutputsRequest(outputs=outputs[i : i + output_batch_size]),
-                additional_status_codes=[Status.RESOURCE_EXHAUSTED],
-                max_retries=None,  # Retry indefinitely, trying every 1s.
+                retry=Retry(
+                    additional_status_codes=[Status.RESOURCE_EXHAUSTED],
+                    max_retries=None,  # Retry indefinitely, trying every 1s.
+                ),
             )
         input_ids = [output.input_id for output in outputs]
         self.exit_context(started_at, input_ids)
@@ -928,7 +931,7 @@ class _ContainerIOManager:
             )
 
             req = api_pb2.TaskResultRequest(result=result)
-            await retry_transient_errors(self._client.stub.TaskResult, req)
+            await self._client.stub.TaskResult(req)
 
             # Shut down the task gracefully
             raise UserException()
@@ -989,12 +992,10 @@ class _ContainerIOManager:
         # Busy-wait for restore. `/__modal/restore-state.json` is created
         # by the worker process with updates to the container config.
         restored_path = Path(config.get("restore_state_path"))
-        start = time.perf_counter()
+        logger.debug("Waiting for restore")
         while not restored_path.exists():
-            logger.debug(f"Waiting for restore (elapsed={time.perf_counter() - start:.3f}s)")
             await asyncio.sleep(0.01)
             continue
-
         logger.debug("Container: restored")
 
         # Look for state file and create new client with updated credentials.
@@ -1005,7 +1006,7 @@ class _ContainerIOManager:
         # Start a debugger if the worker tells us to
         if int(restored_state.get("snapshot_debug", 0)):
             logger.debug("Entering snapshot debugger")
-            breakpoint()
+            breakpoint()  # noqa: T100
 
         # Local ContainerIOManager state.
         for key in ["task_id", "function_id"]:
@@ -1078,13 +1079,14 @@ class _ContainerIOManager:
         await asyncify(os.sync)()
         results = await asyncio.gather(
             *[
-                retry_transient_errors(
-                    self._client.stub.VolumeCommit,
+                self._client.stub.VolumeCommit(
                     api_pb2.VolumeCommitRequest(volume_id=v_id),
-                    max_retries=9,
-                    base_delay=0.25,
-                    max_delay=256,
-                    delay_factor=2,
+                    retry=Retry(
+                        max_retries=9,
+                        base_delay=0.25,
+                        max_delay=256,
+                        delay_factor=2,
+                    ),
                 )
                 for v_id in volume_ids
             ],

modal/_runtime/container_io_manager.pyi

@@ -252,8 +252,6 @@ class _ContainerIOManager:
     @classmethod
     def stop_fetching_inputs(cls): ...
 
-SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
-
 class ContainerIOManager:
     """Synchronizes all RPC calls and network operations for a running container.
 
@@ -298,47 +296,47 @@ class ContainerIOManager:
         """Only used for tests."""
         ...
 
-    class __hello_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __hello_spec(typing_extensions.Protocol):
         def __call__(self, /): ...
         async def aio(self, /): ...
 
-    hello: __hello_spec[typing_extensions.Self]
+    hello: __hello_spec
 
-    class ___run_heartbeat_loop_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___run_heartbeat_loop_spec(typing_extensions.Protocol):
         def __call__(self, /): ...
         async def aio(self, /): ...
 
-    _run_heartbeat_loop: ___run_heartbeat_loop_spec[typing_extensions.Self]
+    _run_heartbeat_loop: ___run_heartbeat_loop_spec
 
-    class ___heartbeat_handle_cancellations_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___heartbeat_handle_cancellations_spec(typing_extensions.Protocol):
         def __call__(self, /) -> bool: ...
         async def aio(self, /) -> bool: ...
 
-    _heartbeat_handle_cancellations: ___heartbeat_handle_cancellations_spec[typing_extensions.Self]
+    _heartbeat_handle_cancellations: ___heartbeat_handle_cancellations_spec
 
-    class __heartbeats_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __heartbeats_spec(typing_extensions.Protocol):
         def __call__(
             self, /, wait_for_mem_snap: bool
         ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]: ...
         def aio(self, /, wait_for_mem_snap: bool) -> typing.AsyncContextManager[None]: ...
 
-    heartbeats: __heartbeats_spec[typing_extensions.Self]
+    heartbeats: __heartbeats_spec
 
     def stop_heartbeat(self): ...
 
-    class __dynamic_concurrency_manager_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __dynamic_concurrency_manager_spec(typing_extensions.Protocol):
         def __call__(self, /) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]: ...
         def aio(self, /) -> typing.AsyncContextManager[None]: ...
 
-    dynamic_concurrency_manager: __dynamic_concurrency_manager_spec[typing_extensions.Self]
+    dynamic_concurrency_manager: __dynamic_concurrency_manager_spec
 
-    class ___dynamic_concurrency_loop_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___dynamic_concurrency_loop_spec(typing_extensions.Protocol):
         def __call__(self, /): ...
         async def aio(self, /): ...
 
-    _dynamic_concurrency_loop: ___dynamic_concurrency_loop_spec[typing_extensions.Self]
+    _dynamic_concurrency_loop: ___dynamic_concurrency_loop_spec
 
-    class __get_data_in_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __get_data_in_spec(typing_extensions.Protocol):
         def __call__(
             self, /, function_call_id: str, attempt_token: typing.Optional[str]
         ) -> typing.Iterator[typing.Any]:
@@ -351,9 +349,9 @@ class ContainerIOManager:
             """Read from the `data_in` stream of a function call."""
             ...
 
-    get_data_in: __get_data_in_spec[typing_extensions.Self]
+    get_data_in: __get_data_in_spec
 
-    class __put_data_out_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __put_data_out_spec(typing_extensions.Protocol):
         def __call__(
             self,
             /,
@@ -388,9 +386,9 @@ class ContainerIOManager:
             """
             ...
 
-    put_data_out: __put_data_out_spec[typing_extensions.Self]
+    put_data_out: __put_data_out_spec
 
-    class __generator_output_sender_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __generator_output_sender_spec(typing_extensions.Protocol):
         def __call__(
             self, /, function_call_id: str, attempt_token: str, data_format: int, message_rx: asyncio.queues.Queue
         ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]:
@@ -403,9 +401,9 @@ class ContainerIOManager:
             """Runs background task that feeds generator outputs into a function call's `data_out` stream."""
             ...
 
-    generator_output_sender: __generator_output_sender_spec[typing_extensions.Self]
+    generator_output_sender: __generator_output_sender_spec
 
-    class ___queue_create_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___queue_create_spec(typing_extensions.Protocol):
         def __call__(self, /, size: int) -> asyncio.queues.Queue:
             """Create a queue, on the synchronicity event loop (needed on Python 3.8 and 3.9)."""
             ...
@@ -414,9 +412,9 @@ class ContainerIOManager:
             """Create a queue, on the synchronicity event loop (needed on Python 3.8 and 3.9)."""
             ...
 
-    _queue_create: ___queue_create_spec[typing_extensions.Self]
+    _queue_create: ___queue_create_spec
 
-    class ___queue_put_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___queue_put_spec(typing_extensions.Protocol):
         def __call__(self, /, queue: asyncio.queues.Queue, value: typing.Any) -> None:
             """Put a value onto a queue, using the synchronicity event loop."""
             ...
@@ -425,12 +423,12 @@ class ContainerIOManager:
             """Put a value onto a queue, using the synchronicity event loop."""
             ...
 
-    _queue_put: ___queue_put_spec[typing_extensions.Self]
+    _queue_put: ___queue_put_spec
 
     def get_average_call_time(self) -> float: ...
     def get_max_inputs_to_fetch(self): ...
 
-    class ___generate_inputs_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___generate_inputs_spec(typing_extensions.Protocol):
         def __call__(
             self, /, batch_max_size: int, batch_wait_ms: int
         ) -> typing.Iterator[list[tuple[str, int, str, str, modal_proto.api_pb2.FunctionInput]]]: ...
@@ -438,9 +436,9 @@ class ContainerIOManager:
             self, /, batch_max_size: int, batch_wait_ms: int
         ) -> collections.abc.AsyncIterator[list[tuple[str, int, str, str, modal_proto.api_pb2.FunctionInput]]]: ...
 
-    _generate_inputs: ___generate_inputs_spec[typing_extensions.Self]
+    _generate_inputs: ___generate_inputs_spec
 
-    class __run_inputs_outputs_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __run_inputs_outputs_spec(typing_extensions.Protocol):
         def __call__(
             self,
             /,
@@ -456,9 +454,9 @@ class ContainerIOManager:
             batch_wait_ms: int = 0,
         ) -> collections.abc.AsyncIterator[IOContext]: ...
 
-    run_inputs_outputs: __run_inputs_outputs_spec[typing_extensions.Self]
+    run_inputs_outputs: __run_inputs_outputs_spec
 
-    class ___send_outputs_spec(typing_extensions.Protocol[SUPERSELF]):
+    class ___send_outputs_spec(typing_extensions.Protocol):
         def __call__(self, /, started_at: float, outputs: list[modal_proto.api_pb2.FunctionPutOutputsItem]) -> None:
             """Send pre-built output items with retry and chunking."""
             ...
@@ -467,9 +465,9 @@ class ContainerIOManager:
             """Send pre-built output items with retry and chunking."""
             ...
 
-    _send_outputs: ___send_outputs_spec[typing_extensions.Self]
+    _send_outputs: ___send_outputs_spec
 
-    class __handle_user_exception_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __handle_user_exception_spec(typing_extensions.Protocol):
         def __call__(self, /) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]:
             """Sets the task as failed in a way where it's not retried.
 
@@ -486,9 +484,9 @@ class ContainerIOManager:
             """
             ...
 
-    handle_user_exception: __handle_user_exception_spec[typing_extensions.Self]
+    handle_user_exception: __handle_user_exception_spec
 
-    class __handle_input_exception_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __handle_input_exception_spec(typing_extensions.Protocol):
         def __call__(
             self, /, io_context: IOContext, started_at: float
         ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]:
@@ -499,23 +497,23 @@ class ContainerIOManager:
             """Handle an exception while processing a function input."""
             ...
 
-    handle_input_exception: __handle_input_exception_spec[typing_extensions.Self]
+    handle_input_exception: __handle_input_exception_spec
 
     def exit_context(self, started_at, input_ids: list[str]): ...
 
-    class __push_outputs_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __push_outputs_spec(typing_extensions.Protocol):
         def __call__(self, /, io_context: IOContext, started_at: float, output_data: list[typing.Any]) -> None: ...
         async def aio(self, /, io_context: IOContext, started_at: float, output_data: list[typing.Any]) -> None: ...
 
-    push_outputs: __push_outputs_spec[typing_extensions.Self]
+    push_outputs: __push_outputs_spec
 
-    class __memory_restore_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __memory_restore_spec(typing_extensions.Protocol):
         def __call__(self, /) -> None: ...
         async def aio(self, /) -> None: ...
 
-    memory_restore: __memory_restore_spec[typing_extensions.Self]
+    memory_restore: __memory_restore_spec
 
-    class __memory_snapshot_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __memory_snapshot_spec(typing_extensions.Protocol):
         def __call__(self, /) -> None:
             """Message server indicating that function is ready to be checkpointed."""
             ...
@@ -524,9 +522,9 @@ class ContainerIOManager:
             """Message server indicating that function is ready to be checkpointed."""
             ...
 
-    memory_snapshot: __memory_snapshot_spec[typing_extensions.Self]
+    memory_snapshot: __memory_snapshot_spec
 
-    class __volume_commit_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __volume_commit_spec(typing_extensions.Protocol):
         def __call__(self, /, volume_ids: list[str]) -> None:
             """Perform volume commit for given `volume_ids`.
             Only used on container exit to persist uncommitted changes on behalf of user.
@@ -539,13 +537,13 @@ class ContainerIOManager:
             """
             ...
 
-    volume_commit: __volume_commit_spec[typing_extensions.Self]
+    volume_commit: __volume_commit_spec
 
-    class __interact_spec(typing_extensions.Protocol[SUPERSELF]):
+    class __interact_spec(typing_extensions.Protocol):
         def __call__(self, /, from_breakpoint: bool = False): ...
         async def aio(self, /, from_breakpoint: bool = False): ...
 
-    interact: __interact_spec[typing_extensions.Self]
+    interact: __interact_spec
 
     @property
     def target_concurrency(self) -> int: ...