modal 0.62.115__py3-none-any.whl → 0.72.13__py3-none-any.whl

modal_proto/modal_api_grpc.py

@@ -0,0 +1,149 @@
+# Generated by the Modal Protocol Buffers compiler. DO NOT EDIT!
+# source: modal_proto/api.proto
+# plugin: __main__
+
+import modal._utils.grpc_utils
+import modal_proto.api_grpc
+import typing
+if typing.TYPE_CHECKING:
+    import modal.client
+
+
+class ModalClientModal:
+
+    def __init__(self, grpclib_stub: modal_proto.api_grpc.ModalClientStub, client: "modal.client._Client") -> None:
+        self.AppClientDisconnect = modal.client.UnaryUnaryWrapper(grpclib_stub.AppClientDisconnect, client)
+        self.AppCreate = modal.client.UnaryUnaryWrapper(grpclib_stub.AppCreate, client)
+        self.AppDeploy = modal.client.UnaryUnaryWrapper(grpclib_stub.AppDeploy, client)
+        self.AppDeploymentHistory = modal.client.UnaryUnaryWrapper(grpclib_stub.AppDeploymentHistory, client)
+        self.AppGetByDeploymentName = modal.client.UnaryUnaryWrapper(grpclib_stub.AppGetByDeploymentName, client)
+        self.AppGetLayout = modal.client.UnaryUnaryWrapper(grpclib_stub.AppGetLayout, client)
+        self.AppGetLogs = modal.client.UnaryStreamWrapper(grpclib_stub.AppGetLogs, client)
+        self.AppGetObjects = modal.client.UnaryUnaryWrapper(grpclib_stub.AppGetObjects, client)
+        self.AppGetOrCreate = modal.client.UnaryUnaryWrapper(grpclib_stub.AppGetOrCreate, client)
+        self.AppHeartbeat = modal.client.UnaryUnaryWrapper(grpclib_stub.AppHeartbeat, client)
+        self.AppList = modal.client.UnaryUnaryWrapper(grpclib_stub.AppList, client)
+        self.AppLookup = modal.client.UnaryUnaryWrapper(grpclib_stub.AppLookup, client)
+        self.AppPublish = modal.client.UnaryUnaryWrapper(grpclib_stub.AppPublish, client)
+        self.AppRollback = modal.client.UnaryUnaryWrapper(grpclib_stub.AppRollback, client)
+        self.AppSetObjects = modal.client.UnaryUnaryWrapper(grpclib_stub.AppSetObjects, client)
+        self.AppStop = modal.client.UnaryUnaryWrapper(grpclib_stub.AppStop, client)
+        self.BlobCreate = modal.client.UnaryUnaryWrapper(grpclib_stub.BlobCreate, client)
+        self.BlobGet = modal.client.UnaryUnaryWrapper(grpclib_stub.BlobGet, client)
+        self.ClassCreate = modal.client.UnaryUnaryWrapper(grpclib_stub.ClassCreate, client)
+        self.ClassGet = modal.client.UnaryUnaryWrapper(grpclib_stub.ClassGet, client)
+        self.ClientHello = modal.client.UnaryUnaryWrapper(grpclib_stub.ClientHello, client)
+        self.ContainerCheckpoint = modal.client.UnaryUnaryWrapper(grpclib_stub.ContainerCheckpoint, client)
+        self.ContainerExec = modal.client.UnaryUnaryWrapper(grpclib_stub.ContainerExec, client)
+        self.ContainerExecGetOutput = modal.client.UnaryStreamWrapper(grpclib_stub.ContainerExecGetOutput, client)
+        self.ContainerExecPutInput = modal.client.UnaryUnaryWrapper(grpclib_stub.ContainerExecPutInput, client)
+        self.ContainerExecWait = modal.client.UnaryUnaryWrapper(grpclib_stub.ContainerExecWait, client)
+        self.ContainerFilesystemExec = modal.client.UnaryUnaryWrapper(grpclib_stub.ContainerFilesystemExec, client)
+        self.ContainerFilesystemExecGetOutput = modal.client.UnaryStreamWrapper(grpclib_stub.ContainerFilesystemExecGetOutput, client)
+        self.ContainerHeartbeat = modal.client.UnaryUnaryWrapper(grpclib_stub.ContainerHeartbeat, client)
+        self.ContainerHello = modal.client.UnaryUnaryWrapper(grpclib_stub.ContainerHello, client)
+        self.ContainerLog = modal.client.UnaryUnaryWrapper(grpclib_stub.ContainerLog, client)
+        self.ContainerStop = modal.client.UnaryUnaryWrapper(grpclib_stub.ContainerStop, client)
+        self.DictClear = modal.client.UnaryUnaryWrapper(grpclib_stub.DictClear, client)
+        self.DictContains = modal.client.UnaryUnaryWrapper(grpclib_stub.DictContains, client)
+        self.DictContents = modal.client.UnaryStreamWrapper(grpclib_stub.DictContents, client)
+        self.DictDelete = modal.client.UnaryUnaryWrapper(grpclib_stub.DictDelete, client)
+        self.DictGet = modal.client.UnaryUnaryWrapper(grpclib_stub.DictGet, client)
+        self.DictGetOrCreate = modal.client.UnaryUnaryWrapper(grpclib_stub.DictGetOrCreate, client)
+        self.DictHeartbeat = modal.client.UnaryUnaryWrapper(grpclib_stub.DictHeartbeat, client)
+        self.DictLen = modal.client.UnaryUnaryWrapper(grpclib_stub.DictLen, client)
+        self.DictList = modal.client.UnaryUnaryWrapper(grpclib_stub.DictList, client)
+        self.DictPop = modal.client.UnaryUnaryWrapper(grpclib_stub.DictPop, client)
+        self.DictUpdate = modal.client.UnaryUnaryWrapper(grpclib_stub.DictUpdate, client)
+        self.DomainCertificateVerify = modal.client.UnaryUnaryWrapper(grpclib_stub.DomainCertificateVerify, client)
+        self.DomainCreate = modal.client.UnaryUnaryWrapper(grpclib_stub.DomainCreate, client)
+        self.DomainList = modal.client.UnaryUnaryWrapper(grpclib_stub.DomainList, client)
+        self.EnvironmentCreate = modal.client.UnaryUnaryWrapper(grpclib_stub.EnvironmentCreate, client)
+        self.EnvironmentDelete = modal.client.UnaryUnaryWrapper(grpclib_stub.EnvironmentDelete, client)
+        self.EnvironmentGetOrCreate = modal.client.UnaryUnaryWrapper(grpclib_stub.EnvironmentGetOrCreate, client)
+        self.EnvironmentList = modal.client.UnaryUnaryWrapper(grpclib_stub.EnvironmentList, client)
+        self.EnvironmentUpdate = modal.client.UnaryUnaryWrapper(grpclib_stub.EnvironmentUpdate, client)
+        self.FunctionAsyncInvoke = modal.client.UnaryUnaryWrapper(grpclib_stub.FunctionAsyncInvoke, client)
+        self.FunctionBindParams = modal.client.UnaryUnaryWrapper(grpclib_stub.FunctionBindParams, client)
+        self.FunctionCallCancel = modal.client.UnaryUnaryWrapper(grpclib_stub.FunctionCallCancel, client)
+        self.FunctionCallGetDataIn = modal.client.UnaryStreamWrapper(grpclib_stub.FunctionCallGetDataIn, client)
+        self.FunctionCallGetDataOut = modal.client.UnaryStreamWrapper(grpclib_stub.FunctionCallGetDataOut, client)
+        self.FunctionCallList = modal.client.UnaryUnaryWrapper(grpclib_stub.FunctionCallList, client)
+        self.FunctionCallPutDataOut = modal.client.UnaryUnaryWrapper(grpclib_stub.FunctionCallPutDataOut, client)
+        self.FunctionCreate = modal.client.UnaryUnaryWrapper(grpclib_stub.FunctionCreate, client)
+        self.FunctionGet = modal.client.UnaryUnaryWrapper(grpclib_stub.FunctionGet, client)
+        self.FunctionGetCallGraph = modal.client.UnaryUnaryWrapper(grpclib_stub.FunctionGetCallGraph, client)
+        self.FunctionGetCurrentStats = modal.client.UnaryUnaryWrapper(grpclib_stub.FunctionGetCurrentStats, client)
+        self.FunctionGetDynamicConcurrency = modal.client.UnaryUnaryWrapper(grpclib_stub.FunctionGetDynamicConcurrency, client)
+        self.FunctionGetInputs = modal.client.UnaryUnaryWrapper(grpclib_stub.FunctionGetInputs, client)
+        self.FunctionGetOutputs = modal.client.UnaryUnaryWrapper(grpclib_stub.FunctionGetOutputs, client)
+        self.FunctionGetSerialized = modal.client.UnaryUnaryWrapper(grpclib_stub.FunctionGetSerialized, client)
+        self.FunctionMap = modal.client.UnaryUnaryWrapper(grpclib_stub.FunctionMap, client)
+        self.FunctionPrecreate = modal.client.UnaryUnaryWrapper(grpclib_stub.FunctionPrecreate, client)
+        self.FunctionPutInputs = modal.client.UnaryUnaryWrapper(grpclib_stub.FunctionPutInputs, client)
+        self.FunctionPutOutputs = modal.client.UnaryUnaryWrapper(grpclib_stub.FunctionPutOutputs, client)
+        self.FunctionRetryInputs = modal.client.UnaryUnaryWrapper(grpclib_stub.FunctionRetryInputs, client)
+        self.FunctionStartPtyShell = modal.client.UnaryUnaryWrapper(grpclib_stub.FunctionStartPtyShell, client)
+        self.FunctionUpdateSchedulingParams = modal.client.UnaryUnaryWrapper(grpclib_stub.FunctionUpdateSchedulingParams, client)
+        self.ImageFromId = modal.client.UnaryUnaryWrapper(grpclib_stub.ImageFromId, client)
+        self.ImageGetOrCreate = modal.client.UnaryUnaryWrapper(grpclib_stub.ImageGetOrCreate, client)
+        self.ImageJoinStreaming = modal.client.UnaryStreamWrapper(grpclib_stub.ImageJoinStreaming, client)
+        self.MountGetOrCreate = modal.client.UnaryUnaryWrapper(grpclib_stub.MountGetOrCreate, client)
+        self.MountPutFile = modal.client.UnaryUnaryWrapper(grpclib_stub.MountPutFile, client)
+        self.ProxyCreate = modal.client.UnaryUnaryWrapper(grpclib_stub.ProxyCreate, client)
+        self.ProxyDelete = modal.client.UnaryUnaryWrapper(grpclib_stub.ProxyDelete, client)
+        self.ProxyGet = modal.client.UnaryUnaryWrapper(grpclib_stub.ProxyGet, client)
+        self.ProxyGetOrCreate = modal.client.UnaryUnaryWrapper(grpclib_stub.ProxyGetOrCreate, client)
+        self.ProxyList = modal.client.UnaryUnaryWrapper(grpclib_stub.ProxyList, client)
+        self.QueueClear = modal.client.UnaryUnaryWrapper(grpclib_stub.QueueClear, client)
+        self.QueueDelete = modal.client.UnaryUnaryWrapper(grpclib_stub.QueueDelete, client)
+        self.QueueGet = modal.client.UnaryUnaryWrapper(grpclib_stub.QueueGet, client)
+        self.QueueGetOrCreate = modal.client.UnaryUnaryWrapper(grpclib_stub.QueueGetOrCreate, client)
+        self.QueueHeartbeat = modal.client.UnaryUnaryWrapper(grpclib_stub.QueueHeartbeat, client)
+        self.QueueLen = modal.client.UnaryUnaryWrapper(grpclib_stub.QueueLen, client)
+        self.QueueList = modal.client.UnaryUnaryWrapper(grpclib_stub.QueueList, client)
+        self.QueueNextItems = modal.client.UnaryUnaryWrapper(grpclib_stub.QueueNextItems, client)
+        self.QueuePut = modal.client.UnaryUnaryWrapper(grpclib_stub.QueuePut, client)
+        self.SandboxCreate = modal.client.UnaryUnaryWrapper(grpclib_stub.SandboxCreate, client)
+        self.SandboxGetLogs = modal.client.UnaryStreamWrapper(grpclib_stub.SandboxGetLogs, client)
+        self.SandboxGetTaskId = modal.client.UnaryUnaryWrapper(grpclib_stub.SandboxGetTaskId, client)
+        self.SandboxGetTunnels = modal.client.UnaryUnaryWrapper(grpclib_stub.SandboxGetTunnels, client)
+        self.SandboxList = modal.client.UnaryUnaryWrapper(grpclib_stub.SandboxList, client)
+        self.SandboxSnapshotFs = modal.client.UnaryUnaryWrapper(grpclib_stub.SandboxSnapshotFs, client)
+        self.SandboxStdinWrite = modal.client.UnaryUnaryWrapper(grpclib_stub.SandboxStdinWrite, client)
+        self.SandboxTagsSet = modal.client.UnaryUnaryWrapper(grpclib_stub.SandboxTagsSet, client)
+        self.SandboxTerminate = modal.client.UnaryUnaryWrapper(grpclib_stub.SandboxTerminate, client)
+        self.SandboxWait = modal.client.UnaryUnaryWrapper(grpclib_stub.SandboxWait, client)
+        self.SecretDelete = modal.client.UnaryUnaryWrapper(grpclib_stub.SecretDelete, client)
+        self.SecretGetOrCreate = modal.client.UnaryUnaryWrapper(grpclib_stub.SecretGetOrCreate, client)
+        self.SecretList = modal.client.UnaryUnaryWrapper(grpclib_stub.SecretList, client)
+        self.SharedVolumeDelete = modal.client.UnaryUnaryWrapper(grpclib_stub.SharedVolumeDelete, client)
+        self.SharedVolumeGetFile = modal.client.UnaryUnaryWrapper(grpclib_stub.SharedVolumeGetFile, client)
+        self.SharedVolumeGetOrCreate = modal.client.UnaryUnaryWrapper(grpclib_stub.SharedVolumeGetOrCreate, client)
+        self.SharedVolumeHeartbeat = modal.client.UnaryUnaryWrapper(grpclib_stub.SharedVolumeHeartbeat, client)
+        self.SharedVolumeList = modal.client.UnaryUnaryWrapper(grpclib_stub.SharedVolumeList, client)
+        self.SharedVolumeListFiles = modal.client.UnaryUnaryWrapper(grpclib_stub.SharedVolumeListFiles, client)
+        self.SharedVolumeListFilesStream = modal.client.UnaryStreamWrapper(grpclib_stub.SharedVolumeListFilesStream, client)
+        self.SharedVolumePutFile = modal.client.UnaryUnaryWrapper(grpclib_stub.SharedVolumePutFile, client)
+        self.SharedVolumeRemoveFile = modal.client.UnaryUnaryWrapper(grpclib_stub.SharedVolumeRemoveFile, client)
+        self.TaskClusterHello = modal.client.UnaryUnaryWrapper(grpclib_stub.TaskClusterHello, client)
+        self.TaskCurrentInputs = modal.client.UnaryUnaryWrapper(grpclib_stub.TaskCurrentInputs, client)
+        self.TaskList = modal.client.UnaryUnaryWrapper(grpclib_stub.TaskList, client)
+        self.TaskResult = modal.client.UnaryUnaryWrapper(grpclib_stub.TaskResult, client)
+        self.TokenFlowCreate = modal.client.UnaryUnaryWrapper(grpclib_stub.TokenFlowCreate, client)
+        self.TokenFlowWait = modal.client.UnaryUnaryWrapper(grpclib_stub.TokenFlowWait, client)
+        self.TunnelStart = modal.client.UnaryUnaryWrapper(grpclib_stub.TunnelStart, client)
+        self.TunnelStop = modal.client.UnaryUnaryWrapper(grpclib_stub.TunnelStop, client)
+        self.VolumeCommit = modal.client.UnaryUnaryWrapper(grpclib_stub.VolumeCommit, client)
+        self.VolumeCopyFiles = modal.client.UnaryUnaryWrapper(grpclib_stub.VolumeCopyFiles, client)
+        self.VolumeDelete = modal.client.UnaryUnaryWrapper(grpclib_stub.VolumeDelete, client)
+        self.VolumeGetFile = modal.client.UnaryUnaryWrapper(grpclib_stub.VolumeGetFile, client)
+        self.VolumeGetOrCreate = modal.client.UnaryUnaryWrapper(grpclib_stub.VolumeGetOrCreate, client)
+        self.VolumeHeartbeat = modal.client.UnaryUnaryWrapper(grpclib_stub.VolumeHeartbeat, client)
+        self.VolumeList = modal.client.UnaryUnaryWrapper(grpclib_stub.VolumeList, client)
+        self.VolumeListFiles = modal.client.UnaryStreamWrapper(grpclib_stub.VolumeListFiles, client)
+        self.VolumePutFiles = modal.client.UnaryUnaryWrapper(grpclib_stub.VolumePutFiles, client)
+        self.VolumeReload = modal.client.UnaryUnaryWrapper(grpclib_stub.VolumeReload, client)
+        self.VolumeRemoveFile = modal.client.UnaryUnaryWrapper(grpclib_stub.VolumeRemoveFile, client)
+        self.VolumeRename = modal.client.UnaryUnaryWrapper(grpclib_stub.VolumeRename, client)
+        self.WorkspaceNameLookup = modal.client.UnaryUnaryWrapper(grpclib_stub.WorkspaceNameLookup, client)

modal_proto/modal_options_grpc.py

@@ -0,0 +1,3 @@
+# Generated by the Modal Protocol Buffers compiler. DO NOT EDIT!
+# source: modal_proto/options.proto
+# plugin: __main__

modal_proto/options_pb2.pyi

@@ -0,0 +1,20 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+Defines custom options used internally at Modal.
+Custom options must be in the range 50000-99999.
+Reference: https://protobuf.dev/programming-guides/proto2/#customoptions
+"""
+import builtins
+import google.protobuf.descriptor
+import google.protobuf.descriptor_pb2
+import google.protobuf.internal.extension_dict
+
+DESCRIPTOR: google.protobuf.descriptor.FileDescriptor
+
+AUDIT_TARGET_ATTR_FIELD_NUMBER: builtins.int
+AUDIT_EVENT_NAME_FIELD_NUMBER: builtins.int
+AUDIT_EVENT_DESCRIPTION_FIELD_NUMBER: builtins.int
+audit_target_attr: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[google.protobuf.descriptor_pb2.FieldOptions, builtins.bool]
+audit_event_name: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[google.protobuf.descriptor_pb2.MethodOptions, builtins.str]
+audit_event_description: google.protobuf.internal.extension_dict._ExtensionFieldDescriptor[google.protobuf.descriptor_pb2.MethodOptions, builtins.str]

modal_proto/options_pb2_grpc.pyi

@@ -0,0 +1,7 @@
+"""
+@generated by mypy-protobuf.  Do not edit manually!
+isort:skip_file
+Defines custom options used internally at Modal.
+Custom options must be in the range 50000-99999.
+Reference: https://protobuf.dev/programming-guides/proto2/#customoptions
+"""

modal_version/__init__.py

@@ -7,7 +7,7 @@ from ._version_generated import build_number
 major_number = 0
 
 # Bump this manually on breaking changes, then reset the number in _version_generated.py
-minor_number = 62
+minor_number = 72
 
 # Right now, automatically increment the patch number in CI
 __version__ = f"{major_number}.{minor_number}.{max(build_number, 0)}"

modal_version/_version_generated.py

@@ -1,4 +1,4 @@
-# Copyright Modal Labs 2024
+# Copyright Modal Labs 2025
 
 # Note: Reset this value to -1 whenever you make a minor `0.X` release of the client.
-build_number = 115  # git: 8843452
+build_number = 13  # git: 580929c

modal/_asgi.py

@@ -1,370 +0,0 @@
-# Copyright Modal Labs 2022
-import asyncio
-from typing import Any, AsyncGenerator, Callable, Dict, Optional, cast
-
-import aiohttp
-
-from ._utils.async_utils import TaskContext
-from ._utils.blob_utils import MAX_OBJECT_SIZE_BYTES
-from .config import logger
-from .exception import ExecutionError, InvalidError
-from .execution_context import current_function_call_id
-from .experimental import stop_fetching_inputs
-
-FIRST_MESSAGE_TIMEOUT_SECONDS = 5.0
-
-
-def asgi_app_wrapper(asgi_app, function_io_manager) -> Callable[..., AsyncGenerator]:
-    async def fn(scope):
-        function_call_id = current_function_call_id()
-        assert function_call_id, "internal error: function_call_id not set in asgi_app() scope"
-
-        # TODO: Add support for the ASGI lifecycle spec.
-        messages_from_app: asyncio.Queue[Dict[str, Any]] = asyncio.Queue(1)
-        messages_to_app: asyncio.Queue[Dict[str, Any]] = asyncio.Queue(1)
-
-        async def disconnect_app():
-            if scope["type"] == "http":
-                await messages_to_app.put({"type": "http.disconnect"})
-            elif scope["type"] == "websocket":
-                await messages_to_app.put({"type": "websocket.disconnect"})
-
-        async def handle_first_input_timeout():
-            if scope["type"] == "http":
-                await messages_from_app.put({"type": "http.response.start", "status": 502})
-                await messages_from_app.put(
-                    {
-                        "type": "http.response.body",
-                        "body": b"Missing request, possibly due to cancellation or crash",
-                    }
-                )
-            elif scope["type"] == "websocket":
-                await messages_from_app.put(
-                    {
-                        "type": "websocket.close",
-                        "code": 1011,
-                        "reason": "Missing request, possibly due to cancellation or crash",
-                    }
-                )
-            await disconnect_app()
-
-        async def fetch_data_in():
-            # Cancel an ASGI app call if the initial message is not received within a short timeout.
-            #
-            # This initial message, "http.request" or "websocket.connect", should be sent
-            # immediately after starting the ASGI app's function call. If it is not received, that
-            # indicates a request cancellation or other abnormal circumstance.
-            message_gen = function_io_manager.get_data_in.aio(function_call_id)
-
-            try:
-                first_message = await asyncio.wait_for(message_gen.__anext__(), FIRST_MESSAGE_TIMEOUT_SECONDS)
-            except (asyncio.TimeoutError, StopAsyncIteration):
-                # About `StopAsyncIteration` above: The generator shouldn't typically exit,
-                # but if it does, we handle it like a timeout in that case.
-                await handle_first_input_timeout()
-                return
-            except Exception:
-                logger.exception("Internal error in asgi_app_wrapper")
-                await disconnect_app()
-                return
-
-            await messages_to_app.put(first_message)
-            async for message in message_gen:
-                await messages_to_app.put(message)
-
-        async def send(msg):
-            # Automatically split body chunks that are greater than the output size limit, to
-            # prevent them from being uploaded to S3.
-            if msg["type"] == "http.response.body":
-                body_chunk_size = MAX_OBJECT_SIZE_BYTES - 1024  # reserve 1 KiB for framing
-                body_chunk_limit = 20 * body_chunk_size
-                s3_chunk_size = 150 * body_chunk_size
-
-                size = len(msg.get("body", b""))
-                if size <= body_chunk_limit:
-                    chunk_size = body_chunk_size
-                else:
-                    # If the body is _very large_, we should still split it up to avoid sending all
-                    # of the data in a huge chunk in S3.
-                    chunk_size = s3_chunk_size
-
-                if size > chunk_size:
-                    indices = list(range(0, size, chunk_size))
-                    for i in indices[:-1]:
-                        chunk = msg["body"][i : i + chunk_size]
-                        await messages_from_app.put({"type": "http.response.body", "body": chunk, "more_body": True})
-                    msg["body"] = msg["body"][indices[-1] :]
-
-            await messages_from_app.put(msg)
-
-        # Run the ASGI app, while draining the send message queue at the same time,
-        # and yielding results.
-        async with TaskContext(grace=0.01) as tc:
-            fetch_data_in_task = tc.create_task(fetch_data_in())
-
-            async def receive():
-                return await messages_to_app.get()
-
-            app_task = tc.create_task(asgi_app(scope, receive, send))
-            pop_task = None
-            try:
-                while True:
-                    pop_task = tc.create_task(messages_from_app.get())
-
-                    try:
-                        done, pending = await asyncio.wait([pop_task, app_task], return_when=asyncio.FIRST_COMPLETED)
-                    except asyncio.CancelledError:
-                        break
-
-                    if pop_task in done:
-                        yield pop_task.result()
-                    else:
-                        pop_task.cancel()  # clean up the popping task, or we will leak unresolved tasks every loop iteration
-
-                    if app_task in done:
-                        while not messages_from_app.empty():
-                            yield messages_from_app.get_nowait()
-                        app_task.result()  # consume/raise exceptions if there are any!
-                        break
-            finally:
-                fetch_data_in_task.cancel()
-                # Only cancel tasks if they're not done. This lets tracebacks from potential errors
-                # still get displayed when the task gets garbage collected.
-                if not app_task.done():
-                    app_task.cancel()
-                if not pop_task.done():
-                    pop_task.cancel()
-
-    return fn
-
-
-def wsgi_app_wrapper(wsgi_app, function_io_manager):
-    from ._vendor.a2wsgi_wsgi import WSGIMiddleware
-
-    asgi_app = WSGIMiddleware(wsgi_app, workers=10000, send_queue_size=1)  # unlimited workers
-    return asgi_app_wrapper(asgi_app, function_io_manager)
-
-
-def webhook_asgi_app(fn: Callable, method: str):
-    """Return a FastAPI app wrapping a function handler."""
-    # Pulls in `fastapi` module, which is slow to import.
-    from fastapi import FastAPI
-    from fastapi.middleware.cors import CORSMiddleware
-
-    app = FastAPI(docs_url=None, redoc_url=None)
-    app.add_middleware(
-        CORSMiddleware,
-        allow_origins=["*"],
-        allow_credentials=True,
-        allow_methods=["*"],
-        allow_headers=["*"],
-    )
-    app.add_api_route("/", fn, methods=[method])
-    return app
-
-
-def get_ip_address(ifname: bytes):
-    """Get the IP address associated with a network interface in Linux."""
-    import fcntl
-    import socket
-    import struct
-
-    s = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
-    return socket.inet_ntoa(
-        fcntl.ioctl(
-            s.fileno(),
-            0x8915,  # SIOCGIFADDR
-            struct.pack("256s", ifname[:15]),
-        )[20:24]
-    )
-
-
-def wait_for_web_server(host: str, port: int, *, timeout: float) -> None:
-    """Wait until a web server port starts accepting TCP connections."""
-    import socket
-    import time
-
-    start_time = time.monotonic()
-    while True:
-        try:
-            with socket.create_connection((host, port), timeout=timeout):
-                break
-        except OSError as ex:
-            time.sleep(0.01)
-            if time.monotonic() - start_time >= timeout:
-                raise TimeoutError(
-                    f"Waited too long for port {port} to start accepting connections. "
-                    + "Make sure the web server is listening on all interfaces, or adjust `startup_timeout`."
-                ) from ex
-
-
-async def _proxy_http_request(session: aiohttp.ClientSession, scope, receive, send) -> None:
-    proxy_response: Optional[aiohttp.ClientResponse] = None
-
-    async def request_generator():
-        while True:
-            message = await receive()
-            if message["type"] == "http.request":
-                body = message.get("body", b"")
-                if body:
-                    yield body
-                if not message.get("more_body", False):
-                    break
-            elif message["type"] == "http.disconnect":
-                proxy_response.connection.transport.abort()  # Abort the connection.
-                break
-            else:
-                raise ExecutionError(f"Unexpected message type: {message['type']}")
-
-    path = scope["path"]
-    if scope.get("query_string"):
-        path += "?" + scope["query_string"].decode()
-
-    proxy_response = await session.request(
-        method=scope["method"],
-        url=path,
-        headers=[(k.decode(), v.decode()) for k, v in scope["headers"]],
-        data=None if scope["method"] in aiohttp.ClientRequest.GET_METHODS else request_generator(),
-        allow_redirects=False,
-    )
-
-    async def send_response():
-        msg = {
-            "type": "http.response.start",
-            "status": proxy_response.status,
-            "headers": [(k.encode(), v.encode()) for k, v in proxy_response.headers.items()],
-        }
-        await send(msg)
-        async for data in proxy_response.content.iter_any():
-            msg = {"type": "http.response.body", "body": data, "more_body": True}
-            await send(msg)
-        await send({"type": "http.response.body"})
-
-    async def listen_for_disconnect():
-        while True:
-            message = await receive()
-            if message["type"] == "http.disconnect":
-                proxy_response.connection.transport.abort()
-
-    try:
-        send_response_task = asyncio.create_task(send_response())
-        disconnect_task = asyncio.create_task(listen_for_disconnect())
-        await asyncio.wait([send_response_task, disconnect_task], return_when=asyncio.FIRST_COMPLETED)
-    finally:
-        if send_response_task.done():
-            send_response_task.result()
-        else:
-            send_response_task.cancel()
-        if disconnect_task.done():
-            disconnect_task.result()
-        else:
-            disconnect_task.cancel()
-
-
-async def _proxy_websocket_request(session: aiohttp.ClientSession, scope, receive, send) -> None:
-    first_message = await receive()  # Consume the initial "websocket.connect" message.
-    if first_message["type"] == "websocket.disconnect":
-        return
-    elif first_message["type"] != "websocket.connect":
-        raise ExecutionError(f"Unexpected message type: {first_message['type']}")
-
-    path = scope["path"]
-    if scope.get("query_string"):
-        path += "?" + scope["query_string"].decode()
-
-    async with session.ws_connect(
-        url=path,
-        headers=[(k.decode(), v.decode()) for k, v in scope["headers"]],  # type: ignore
-        protocols=scope.get("subprotocols", []),
-    ) as upstream_ws:
-
-        async def client_to_upstream():
-            while True:
-                client_message = await receive()
-                if client_message["type"] == "websocket.disconnect":
-                    await upstream_ws.close(code=client_message.get("code", 1005))
-                    break
-                elif client_message["type"] == "websocket.receive":
-                    if client_message.get("text") is not None:
-                        await upstream_ws.send_str(client_message["text"])
-                    elif client_message.get("bytes") is not None:
-                        await upstream_ws.send_bytes(client_message["bytes"])
-                else:
-                    raise ExecutionError(f"Unexpected message type: {client_message['type']}")
-
-        async def upstream_to_client():
-            msg: Dict[str, Any] = {
-                "type": "websocket.accept",
-                "subprotocol": upstream_ws.protocol,
-            }
-            await send(msg)
-
-            while True:
-                upstream_message = await upstream_ws.receive()
-                if upstream_message.type == aiohttp.WSMsgType.closed:
-                    msg = {"type": "websocket.close"}
-                    if upstream_message.data is not None:
-                        msg["code"] = cast(aiohttp.WSCloseCode, upstream_message.data).value
-                        msg["reason"] = upstream_message.extra
-                    await send(msg)
-                    break
-                elif upstream_message.type == aiohttp.WSMsgType.text:
-                    await send({"type": "websocket.send", "text": upstream_message.data})
-                elif upstream_message.type == aiohttp.WSMsgType.binary:
-                    await send({"type": "websocket.send", "bytes": upstream_message.data})
-                else:
-                    pass  # Ignore all other upstream WebSocket message types.
-
-        client_to_upstream_task = asyncio.create_task(client_to_upstream())
-        upstream_to_client_task = asyncio.create_task(upstream_to_client())
-        try:
-            await asyncio.wait([client_to_upstream_task, upstream_to_client_task], return_when=asyncio.FIRST_COMPLETED)
-        finally:
-            if client_to_upstream_task.done():
-                client_to_upstream_task.result()
-            else:
-                client_to_upstream_task.cancel()
-            if upstream_to_client_task.done():
-                upstream_to_client_task.result()
-            else:
-                upstream_to_client_task.cancel()
-
-
-def web_server_proxy(host: str, port: int):
-    """Return an ASGI app that proxies requests to a web server running on the same host."""
-    if not 0 < port < 65536:
-        raise InvalidError(f"Invalid port number: {port}")
-
-    base_url = f"http://{host}:{port}"
-    session: Optional[aiohttp.ClientSession] = None
-
-    async def web_server_proxy_app(scope, receive, send):
-        nonlocal session
-        if session is None:
-            # TODO: We currently create the ClientSession on container startup and never close it.
-            # This outputs an "Unclosed client session" warning during runner termination. We should
-            # properly close the session once we implement the ASGI lifespan protocol.
-            session = aiohttp.ClientSession(
-                base_url,
-                cookie_jar=aiohttp.DummyCookieJar(),
-                timeout=aiohttp.ClientTimeout(total=3600),
-                auto_decompress=False,
-                read_bufsize=1024 * 1024,  # 1 MiB
-            )
-
-        try:
-            if scope["type"] == "lifespan":
-                pass  # Do nothing for lifespan events.
-            elif scope["type"] == "http":
-                await _proxy_http_request(session, scope, receive, send)
-            elif scope["type"] == "websocket":
-                await _proxy_websocket_request(session, scope, receive, send)
-            else:
-                raise NotImplementedError(f"Scope {scope} is not understood")
-
-        except aiohttp.ClientConnectorError as exc:
-            # If the server is not running or not reachable, we should stop fetching new inputs.
-            logger.warning(f"Terminating runner due to @web_server connection issue: {exc}")
-            stop_fetching_inputs()
-
-    return web_server_proxy_app