modAL 1.0.5__tar.gz → 1.0.5.dev2__tar.gz

{modal-1.0.5 → modal-1.0.5.dev2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.0.5
+Version: 1.0.5.dev2
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License: Apache-2.0
@@ -19,7 +19,7 @@ License-File: LICENSE
 Requires-Dist: aiohttp
 Requires-Dist: certifi
 Requires-Dist: click~=8.1.0
-Requires-Dist: grpclib<0.4.9,>=0.4.7
+Requires-Dist: grpclib==0.4.7
 Requires-Dist: protobuf!=4.24.0,<7.0,>=3.19
 Requires-Dist: rich>=12.0.0
 Requires-Dist: synchronicity~=0.9.15

{modal-1.0.5 → modal-1.0.5.dev2}/modal/_clustered_functions.pyi

@@ -3,22 +3,12 @@ import typing
 import typing_extensions
 
 class ClusterInfo:
-    """ClusterInfo(rank: int, container_ips: list[str])"""
-
     rank: int
     container_ips: list[str]
 
-    def __init__(self, rank: int, container_ips: list[str]) -> None:
-        """Initialize self.  See help(type(self)) for accurate signature."""
-        ...
-
-    def __repr__(self):
-        """Return repr(self)."""
-        ...
-
-    def __eq__(self, other):
-        """Return self==value."""
-        ...
+    def __init__(self, rank: int, container_ips: list[str]) -> None: ...
+    def __repr__(self): ...
+    def __eq__(self, other): ...
 
 def get_cluster_info() -> ClusterInfo: ...
 async def _initialize_clustered_function(client: modal.client._Client, task_id: str, world_size: int): ...

{modal-1.0.5 → modal-1.0.5.dev2}/modal/_functions.py

@@ -141,13 +141,7 @@ class _Invocation:
         stub = client.stub
 
         function_id = function.object_id
-        item = await _create_input(
-            args,
-            kwargs,
-            stub,
-            method_name=function._use_method_name,
-            function_call_invocation_type=function_call_invocation_type,
-        )
+        item = await _create_input(args, kwargs, stub, method_name=function._use_method_name)
 
         request = api_pb2.FunctionMapRequest(
             function_id=function_id,
@@ -362,14 +356,12 @@ class _InputPlaneInvocation:
         client: _Client,
         input_item: api_pb2.FunctionPutInputsItem,
         function_id: str,
-        input_plane_region: str,
     ):
         self.stub = stub
         self.client = client  # Used by the deserializer.
         self.attempt_token = attempt_token
         self.input_item = input_item
         self.function_id = function_id
-        self.input_plane_region = input_plane_region
 
     @staticmethod
     async def create(
@@ -379,27 +371,21 @@ class _InputPlaneInvocation:
         *,
         client: _Client,
         input_plane_url: str,
-        input_plane_region: str,
     ) -> "_InputPlaneInvocation":
         stub = await client.get_stub(input_plane_url)
 
         function_id = function.object_id
-        control_plane_stub = client.stub
-        # Note: Blob upload is done on the control plane stub, not the input plane stub!
-        input_item = await _create_input(args, kwargs, control_plane_stub, method_name=function._use_method_name)
+        input_item = await _create_input(args, kwargs, stub, method_name=function._use_method_name)
 
         request = api_pb2.AttemptStartRequest(
             function_id=function_id,
             parent_input_id=current_input_id() or "",
             input=input_item,
         )
-        metadata: list[tuple[str, str]] = []
-        if input_plane_region and input_plane_region != "":
-            metadata.append(("x-modal-input-plane-region", input_plane_region))
-        response = await retry_transient_errors(stub.AttemptStart, request, metadata=metadata)
+        response = await retry_transient_errors(stub.AttemptStart, request)
         attempt_token = response.attempt_token
 
-        return _InputPlaneInvocation(stub, attempt_token, client, input_item, function_id, input_plane_region)
+        return _InputPlaneInvocation(stub, attempt_token, client, input_item, function_id)
 
     async def run_function(self) -> Any:
         # This will retry when the server returns GENERIC_STATUS_INTERNAL_FAILURE, i.e. lost inputs or worker preemption
@@ -411,14 +397,10 @@ class _InputPlaneInvocation:
                 timeout_secs=OUTPUTS_TIMEOUT,
                 requested_at=time.time(),
             )
-            metadata: list[tuple[str, str]] = []
-            if self.input_plane_region and self.input_plane_region != "":
-                metadata.append(("x-modal-input-plane-region", self.input_plane_region))
             await_response: api_pb2.AttemptAwaitResponse = await retry_transient_errors(
                 self.stub.AttemptAwait,
                 await_request,
                 attempt_timeout=OUTPUTS_TIMEOUT + ATTEMPT_TIMEOUT_GRACE_PERIOD,
-                metadata=metadata,
             )
 
             if await_response.HasField("output"):
@@ -435,11 +417,7 @@ class _InputPlaneInvocation:
                             attempt_token=self.attempt_token,
                         )
                         # TODO(ryan): Add exponential backoff?
-                        retry_response = await retry_transient_errors(
-                            self.stub.AttemptRetry,
-                            retry_request,
-                            metadata=metadata,
-                        )
+                        retry_response = await retry_transient_errors(self.stub.AttemptRetry, retry_request)
                         self.attempt_token = retry_response.attempt_token
                         continue
 
@@ -799,7 +777,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     req.method_definitions[method_name].CopyFrom(method_definition)
             elif webhook_config:
                 req.webhook_config.CopyFrom(webhook_config)
-
             response = await retry_transient_errors(resolver.client.stub.FunctionPrecreate, req)
             self._hydrate(response.function_id, resolver.client, response.handle_metadata)
 
@@ -854,7 +831,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         mount_path=path,
                         volume_id=volume.object_id,
                         allow_background_commits=True,
-                        read_only=volume._read_only,
                     )
                     for path, volume in validated_volumes_no_cloud_buckets
                 ]
@@ -1108,7 +1084,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         mount_path=path,
                         volume_id=volume.object_id,
                         allow_background_commits=True,
-                        read_only=volume._read_only,
                     )
                     for path, volume in options.validated_volumes
                 ]
@@ -1281,9 +1256,9 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     ) -> "_Function":
         """Reference a Function from a deployed App by its name.
 
-        This is a lazy method that defers hydrating the local
-        object with metadata from Modal servers until the first
-        time it is actually used.
+        In contrast to `modal.Function.lookup`, this is a lazy method
+        that defers hydrating the local object with metadata from
+        Modal servers until the first time it is actually used.
 
         ```python
         f = modal.Function.from_name("other-app", "function")
@@ -1406,7 +1381,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         self._method_handle_metadata = dict(metadata.method_handle_metadata)
         self._definition_id = metadata.definition_id
         self._input_plane_url = metadata.input_plane_url
-        self._input_plane_region = metadata.input_plane_region
 
     def _get_metadata(self):
         # Overridden concrete implementation of base class method
@@ -1422,7 +1396,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             method_handle_metadata=self._method_handle_metadata,
             function_schema=self._metadata.function_schema if self._metadata else None,
             input_plane_url=self._input_plane_url,
-            input_plane_region=self._input_plane_region,
         )
 
     def _check_no_web_url(self, fn_name: str):
@@ -1518,7 +1491,6 @@ Use the `Function.get_web_url()` method instead.
                 kwargs,
                 client=self.client,
                 input_plane_url=self._input_plane_url,
-                input_plane_region=self._input_plane_region,
             )
         else:
             invocation = await _Invocation.create(
@@ -1699,9 +1671,8 @@ Use the `Function.get_web_url()` method instead.
     async def spawn(self, *args: P.args, **kwargs: P.kwargs) -> "_FunctionCall[ReturnType]":
         """Calls the function with the given arguments, without waiting for the results.
 
-        Returns a [`modal.FunctionCall`](https://modal.com/docs/reference/modal.FunctionCall) object
-        that can later be polled or waited for using
-        [`.get(timeout=...)`](https://modal.com/docs/reference/modal.FunctionCall#get).
+        Returns a [`modal.FunctionCall`](/docs/reference/modal.FunctionCall) object, that can later be polled or
+        waited for using [`.get(timeout=...)`](/docs/reference/modal.FunctionCall#get).
         Conceptually similar to `multiprocessing.pool.apply_async`, or a Future/Promise in other contexts.
         """
         self._check_no_web_url("spawn")
@@ -1777,7 +1748,7 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         """Returns a structure representing the call graph from a given root
         call ID, along with the status of execution for each node.
 
-        See [`modal.call_graph`](https://modal.com/docs/reference/modal.call_graph) reference page
+        See [`modal.call_graph`](/docs/reference/modal.call_graph) reference page
         for documentation on the structure of the returned `InputInfo` items.
         """
         assert self._client and self._client.stub
@@ -1791,7 +1762,7 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
         terminate_containers: bool = False,
     ):
         """Cancels the function call, which will stop its execution and mark its inputs as
-        [`TERMINATED`](https://modal.com/docs/reference/modal.call_graph#modalcall_graphinputstatus).
+        [`TERMINATED`](/docs/reference/modal.call_graph#modalcall_graphinputstatus).
 
         If `terminate_containers=True` - the containers running the cancelled inputs are all terminated
         causing any non-cancelled inputs on those containers to be rescheduled in new containers.

{modal-1.0.5 → modal-1.0.5.dev2}/modal/_partial_function.py

@@ -538,7 +538,7 @@ def _wsgi_app(
     Web Server Gateway Interface (WSGI) is a standard for synchronous Python web apps.
     It has been [succeeded by the ASGI interface](https://asgi.readthedocs.io/en/latest/introduction.html#wsgi-compatibility)
     which is compatible with ASGI and supports additional functionality such as web sockets.
-    Modal supports ASGI via [`asgi_app`](https://modal.com/docs/reference/modal.asgi_app).
+    Modal supports ASGI via [`asgi_app`](/docs/reference/modal.asgi_app).
 
     **Usage:**
 

{modal-1.0.5 → modal-1.0.5.dev2}/modal/_runtime/container_io_manager.pyi

@@ -9,21 +9,10 @@ import synchronicity.combined_types
 import typing
 import typing_extensions
 
-class UserException(Exception):
-    """Used to shut down the task gracefully."""
-
-    ...
-
-class Sentinel:
-    """Used to get type-stubs to work with this object."""
-
-    ...
+class UserException(Exception): ...
+class Sentinel: ...
 
 class IOContext:
-    """Context object for managing input, function calls, and function executions
-    in a batched or single input context.
-    """
-
     input_ids: list[str]
     retry_counts: list[int]
     function_call_ids: list[str]
@@ -41,10 +30,7 @@ class IOContext:
         function_inputs: list[modal_proto.api_pb2.FunctionInput],
         is_batched: bool,
         client: modal.client._Client,
-    ):
-        """Initialize self.  See help(type(self)) for accurate signature."""
-        ...
-
+    ): ...
     @classmethod
     async def create(
         cls,
@@ -60,17 +46,12 @@ class IOContext:
     def validate_output_data(self, data: typing.Any) -> list[typing.Any]: ...
 
 class InputSlots:
-    """A semaphore that allows dynamically adjusting the concurrency."""
-
     active: int
     value: int
     waiter: typing.Optional[asyncio.Future]
     closed: bool
 
-    def __init__(self, value: int) -> None:
-        """Initialize self.  See help(type(self)) for accurate signature."""
-        ...
-
+    def __init__(self, value: int) -> None: ...
     async def acquire(self) -> None: ...
     def _wake_waiter(self) -> None: ...
     def release(self) -> None: ...
@@ -78,12 +59,6 @@ class InputSlots:
     async def close(self) -> None: ...
 
 class _ContainerIOManager:
-    """Synchronizes all RPC calls and network operations for a running container.
-
-    TODO: maybe we shouldn't synchronize the whole class.
-    Then we could potentially move a bunch of the global functions onto it.
-    """
-
     task_id: str
     function_id: str
     app_id: str
@@ -115,15 +90,9 @@ class _ContainerIOManager:
     @staticmethod
     def __new__(
         cls, container_args: modal_proto.api_pb2.ContainerArguments, client: modal.client._Client
-    ) -> _ContainerIOManager:
-        """Create and return a new object.  See help(type) for accurate signature."""
-        ...
-
+    ) -> _ContainerIOManager: ...
     @classmethod
-    def _reset_singleton(cls):
-        """Only used for tests."""
-        ...
-
+    def _reset_singleton(cls): ...
     async def hello(self): ...
     async def _run_heartbeat_loop(self): ...
     async def _heartbeat_handle_cancellations(self) -> bool: ...
@@ -133,35 +102,15 @@ class _ContainerIOManager:
     async def _dynamic_concurrency_loop(self): ...
     def serialize_data_format(self, obj: typing.Any, data_format: int) -> bytes: ...
     async def format_blob_data(self, data: bytes) -> dict[str, typing.Any]: ...
-    def get_data_in(self, function_call_id: str) -> collections.abc.AsyncIterator[typing.Any]:
-        """Read from the `data_in` stream of a function call."""
-        ...
-
+    def get_data_in(self, function_call_id: str) -> collections.abc.AsyncIterator[typing.Any]: ...
     async def put_data_out(
         self, function_call_id: str, start_index: int, data_format: int, serialized_messages: list[typing.Any]
-    ) -> None:
-        """Put data onto the `data_out` stream of a function call.
-
-        This is used for generator outputs, which includes web endpoint responses. Note that this
-        was introduced as a performance optimization in client version 0.57, so older clients will
-        still use the previous Postgres-backed system based on `FunctionPutOutputs()`.
-        """
-        ...
-
+    ) -> None: ...
     async def generator_output_task(
         self, function_call_id: str, data_format: int, message_rx: asyncio.queues.Queue
-    ) -> None:
-        """Task that feeds generator outputs into a function call's `data_out` stream."""
-        ...
-
-    async def _queue_create(self, size: int) -> asyncio.queues.Queue:
-        """Create a queue, on the synchronicity event loop (needed on Python 3.8 and 3.9)."""
-        ...
-
-    async def _queue_put(self, queue: asyncio.queues.Queue, value: typing.Any) -> None:
-        """Put a value onto a queue, using the synchronicity event loop."""
-        ...
-
+    ) -> None: ...
+    async def _queue_create(self, size: int) -> asyncio.queues.Queue: ...
+    async def _queue_put(self, queue: asyncio.queues.Queue, value: typing.Any) -> None: ...
     def get_average_call_time(self) -> float: ...
     def get_max_inputs_to_fetch(self): ...
     def _generate_inputs(
@@ -182,33 +131,15 @@ class _ContainerIOManager:
     ) -> None: ...
     def serialize_exception(self, exc: BaseException) -> bytes: ...
     def serialize_traceback(self, exc: BaseException) -> tuple[typing.Optional[bytes], typing.Optional[bytes]]: ...
-    def handle_user_exception(self) -> typing.AsyncContextManager[None]:
-        """Sets the task as failed in a way where it's not retried.
-
-        Used for handling exceptions from container lifecycle methods at the moment, which should
-        trigger a task failure state.
-        """
-        ...
-
-    def handle_input_exception(self, io_context: IOContext, started_at: float) -> typing.AsyncContextManager[None]:
-        """Handle an exception while processing a function input."""
-        ...
-
+    def handle_user_exception(self) -> typing.AsyncContextManager[None]: ...
+    def handle_input_exception(self, io_context: IOContext, started_at: float) -> typing.AsyncContextManager[None]: ...
     def exit_context(self, started_at, input_ids: list[str]): ...
     async def push_outputs(
         self, io_context: IOContext, started_at: float, data: typing.Any, data_format: int
     ) -> None: ...
     async def memory_restore(self) -> None: ...
-    async def memory_snapshot(self) -> None:
-        """Message server indicating that function is ready to be checkpointed."""
-        ...
-
-    async def volume_commit(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.
-        """
-        ...
-
+    async def memory_snapshot(self) -> None: ...
+    async def volume_commit(self, volume_ids: list[str]) -> None: ...
     async def interact(self, from_breakpoint: bool = False): ...
     @property
     def target_concurrency(self) -> int: ...
@@ -217,35 +148,15 @@ class _ContainerIOManager:
     @property
     def input_concurrency_enabled(self) -> int: ...
     @classmethod
-    def get_input_concurrency(cls) -> int:
-        """Returns the number of usable input slots.
-
-        If concurrency is reduced, active slots can exceed allotted slots. Returns the larger value
-        in this case.
-        """
-        ...
-
+    def get_input_concurrency(cls) -> int: ...
     @classmethod
-    def set_input_concurrency(cls, concurrency: int):
-        """Edit the number of input slots.
-
-        This disables the background loop which automatically adjusts concurrency
-        within [target_concurrency, max_concurrency].
-        """
-        ...
-
+    def set_input_concurrency(cls, concurrency: int): ...
     @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.
-
-    TODO: maybe we shouldn't synchronize the whole class.
-    Then we could potentially move a bunch of the global functions onto it.
-    """
-
     task_id: str
     function_id: str
     app_id: str
@@ -271,17 +182,12 @@ class ContainerIOManager:
     _GENERATOR_STOP_SENTINEL: typing.ClassVar[Sentinel]
     _singleton: typing.ClassVar[typing.Optional[ContainerIOManager]]
 
-    def __init__(self, /, *args, **kwargs):
-        """Initialize self.  See help(type(self)) for accurate signature."""
-        ...
-
+    def __init__(self, /, *args, **kwargs): ...
     def _init(self, container_args: modal_proto.api_pb2.ContainerArguments, client: modal.client.Client): ...
     @property
     def heartbeat_condition(self) -> asyncio.locks.Condition: ...
     @classmethod
-    def _reset_singleton(cls):
-        """Only used for tests."""
-        ...
+    def _reset_singleton(cls): ...
 
     class __hello_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, /): ...
@@ -332,71 +238,36 @@ class ContainerIOManager:
     format_blob_data: __format_blob_data_spec[typing_extensions.Self]
 
     class __get_data_in_spec(typing_extensions.Protocol[SUPERSELF]):
-        def __call__(self, /, function_call_id: str) -> typing.Iterator[typing.Any]:
-            """Read from the `data_in` stream of a function call."""
-            ...
-
-        def aio(self, /, function_call_id: str) -> collections.abc.AsyncIterator[typing.Any]:
-            """Read from the `data_in` stream of a function call."""
-            ...
+        def __call__(self, /, function_call_id: str) -> typing.Iterator[typing.Any]: ...
+        def aio(self, /, function_call_id: str) -> collections.abc.AsyncIterator[typing.Any]: ...
 
     get_data_in: __get_data_in_spec[typing_extensions.Self]
 
     class __put_data_out_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self, /, function_call_id: str, start_index: int, data_format: int, serialized_messages: list[typing.Any]
-        ) -> None:
-            """Put data onto the `data_out` stream of a function call.
-
-            This is used for generator outputs, which includes web endpoint responses. Note that this
-            was introduced as a performance optimization in client version 0.57, so older clients will
-            still use the previous Postgres-backed system based on `FunctionPutOutputs()`.
-            """
-            ...
-
+        ) -> None: ...
         async def aio(
             self, /, function_call_id: str, start_index: int, data_format: int, serialized_messages: list[typing.Any]
-        ) -> None:
-            """Put data onto the `data_out` stream of a function call.
-
-            This is used for generator outputs, which includes web endpoint responses. Note that this
-            was introduced as a performance optimization in client version 0.57, so older clients will
-            still use the previous Postgres-backed system based on `FunctionPutOutputs()`.
-            """
-            ...
+        ) -> None: ...
 
     put_data_out: __put_data_out_spec[typing_extensions.Self]
 
     class __generator_output_task_spec(typing_extensions.Protocol[SUPERSELF]):
-        def __call__(self, /, function_call_id: str, data_format: int, message_rx: asyncio.queues.Queue) -> None:
-            """Task that feeds generator outputs into a function call's `data_out` stream."""
-            ...
-
-        async def aio(self, /, function_call_id: str, data_format: int, message_rx: asyncio.queues.Queue) -> None:
-            """Task that feeds generator outputs into a function call's `data_out` stream."""
-            ...
+        def __call__(self, /, function_call_id: str, data_format: int, message_rx: asyncio.queues.Queue) -> None: ...
+        async def aio(self, /, function_call_id: str, data_format: int, message_rx: asyncio.queues.Queue) -> None: ...
 
     generator_output_task: __generator_output_task_spec[typing_extensions.Self]
 
     class ___queue_create_spec(typing_extensions.Protocol[SUPERSELF]):
-        def __call__(self, /, size: int) -> asyncio.queues.Queue:
-            """Create a queue, on the synchronicity event loop (needed on Python 3.8 and 3.9)."""
-            ...
-
-        async def aio(self, /, size: int) -> asyncio.queues.Queue:
-            """Create a queue, on the synchronicity event loop (needed on Python 3.8 and 3.9)."""
-            ...
+        def __call__(self, /, size: int) -> asyncio.queues.Queue: ...
+        async def aio(self, /, size: int) -> asyncio.queues.Queue: ...
 
     _queue_create: ___queue_create_spec[typing_extensions.Self]
 
     class ___queue_put_spec(typing_extensions.Protocol[SUPERSELF]):
-        def __call__(self, /, queue: asyncio.queues.Queue, value: typing.Any) -> None:
-            """Put a value onto a queue, using the synchronicity event loop."""
-            ...
-
-        async def aio(self, /, queue: asyncio.queues.Queue, value: typing.Any) -> None:
-            """Put a value onto a queue, using the synchronicity event loop."""
-            ...
+        def __call__(self, /, queue: asyncio.queues.Queue, value: typing.Any) -> None: ...
+        async def aio(self, /, queue: asyncio.queues.Queue, value: typing.Any) -> None: ...
 
     _queue_put: ___queue_put_spec[typing_extensions.Self]
 
@@ -455,34 +326,16 @@ class ContainerIOManager:
     def serialize_traceback(self, exc: BaseException) -> tuple[typing.Optional[bytes], typing.Optional[bytes]]: ...
 
     class __handle_user_exception_spec(typing_extensions.Protocol[SUPERSELF]):
-        def __call__(self, /) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]:
-            """Sets the task as failed in a way where it's not retried.
-
-            Used for handling exceptions from container lifecycle methods at the moment, which should
-            trigger a task failure state.
-            """
-            ...
-
-        def aio(self, /) -> typing.AsyncContextManager[None]:
-            """Sets the task as failed in a way where it's not retried.
-
-            Used for handling exceptions from container lifecycle methods at the moment, which should
-            trigger a task failure state.
-            """
-            ...
+        def __call__(self, /) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]: ...
+        def aio(self, /) -> typing.AsyncContextManager[None]: ...
 
     handle_user_exception: __handle_user_exception_spec[typing_extensions.Self]
 
     class __handle_input_exception_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(
             self, /, io_context: IOContext, started_at: float
-        ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]:
-            """Handle an exception while processing a function input."""
-            ...
-
-        def aio(self, /, io_context: IOContext, started_at: float) -> typing.AsyncContextManager[None]:
-            """Handle an exception while processing a function input."""
-            ...
+        ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[None]: ...
+        def aio(self, /, io_context: IOContext, started_at: float) -> typing.AsyncContextManager[None]: ...
 
     handle_input_exception: __handle_input_exception_spec[typing_extensions.Self]
 
@@ -503,28 +356,14 @@ class ContainerIOManager:
     memory_restore: __memory_restore_spec[typing_extensions.Self]
 
     class __memory_snapshot_spec(typing_extensions.Protocol[SUPERSELF]):
-        def __call__(self, /) -> None:
-            """Message server indicating that function is ready to be checkpointed."""
-            ...
-
-        async def aio(self, /) -> None:
-            """Message server indicating that function is ready to be checkpointed."""
-            ...
+        def __call__(self, /) -> None: ...
+        async def aio(self, /) -> None: ...
 
     memory_snapshot: __memory_snapshot_spec[typing_extensions.Self]
 
     class __volume_commit_spec(typing_extensions.Protocol[SUPERSELF]):
-        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.
-            """
-            ...
-
-        async def aio(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.
-            """
-            ...
+        def __call__(self, /, volume_ids: list[str]) -> None: ...
+        async def aio(self, /, volume_ids: list[str]) -> None: ...
 
     volume_commit: __volume_commit_spec[typing_extensions.Self]
 
@@ -541,34 +380,13 @@ class ContainerIOManager:
     @property
     def input_concurrency_enabled(self) -> int: ...
     @classmethod
-    def get_input_concurrency(cls) -> int:
-        """Returns the number of usable input slots.
-
-        If concurrency is reduced, active slots can exceed allotted slots. Returns the larger value
-        in this case.
-        """
-        ...
-
+    def get_input_concurrency(cls) -> int: ...
     @classmethod
-    def set_input_concurrency(cls, concurrency: int):
-        """Edit the number of input slots.
-
-        This disables the background loop which automatically adjusts concurrency
-        within [target_concurrency, max_concurrency].
-        """
-        ...
-
+    def set_input_concurrency(cls, concurrency: int): ...
     @classmethod
     def stop_fetching_inputs(cls): ...
 
-def check_fastapi_pydantic_compatibility(exc: ImportError) -> None:
-    """Add a helpful note to an exception that is likely caused by a pydantic<>fastapi version incompatibility.
-
-    We need this becasue the legacy set of container requirements (image_builder_version=2023.12) contains a
-    version of fastapi that is not forwards-compatible with pydantic 2.0+, and users commonly run into issues
-    building an image that specifies a more recent version only for pydantic.
-    """
-    ...
+def check_fastapi_pydantic_compatibility(exc: ImportError) -> None: ...
 
 MAX_OUTPUT_BATCH_SIZE: int
 

modal-1.0.5.dev2/modal/_runtime/execution_context.pyi

@@ -0,0 +1,24 @@
+import collections.abc
+import contextvars
+import typing
+import typing_extensions
+
+def is_local() -> bool: ...
+async def _interact() -> None: ...
+
+class __interact_spec(typing_extensions.Protocol):
+    def __call__(self, /) -> None: ...
+    async def aio(self, /) -> None: ...
+
+interact: __interact_spec
+
+def current_input_id() -> typing.Optional[str]: ...
+def current_function_call_id() -> typing.Optional[str]: ...
+def _set_current_context_ids(
+    input_ids: list[str], function_call_ids: list[str]
+) -> collections.abc.Callable[[], None]: ...
+def _import_context(): ...
+
+_current_input_id: contextvars.ContextVar
+
+_current_function_call_id: contextvars.ContextVar