modal 1.5.6.dev20__tar.gz → 1.5.6.dev22__tar.gz

{modal-1.5.6.dev20 → modal-1.5.6.dev22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.5.6.dev20
+Version: 1.5.6.dev22
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License-Expression: Apache-2.0

{modal-1.5.6.dev20 → modal-1.5.6.dev22}/modal/_output/pty.py

@@ -128,8 +128,8 @@ async def get_app_logs_loop(
     async def _put_log(log_batch: api_pb2.TaskLogsBatch, log: api_pb2.TaskLogs):
         if log.task_state:
             output_mgr.update_task_state(log_batch.task_id, log.task_state)
-            if log.task_state == api_pb2.TASK_STATE_WORKER_ASSIGNED:
-                # Close function's queueing progress bar (if it exists)
+            if log_batch.function_id:
+                # Any task state the server reports means the task is on a worker, so close queueing progress
                 output_mgr.update_queueing_progress(
                     function_id=log_batch.function_id, completed=1, total=1, description=None
                 )

{modal-1.5.6.dev20 → modal-1.5.6.dev22}/modal/_output/rich.py

@@ -14,6 +14,7 @@ import io
 import platform
 import re
 import sys
+import time
 from collections.abc import Callable, Generator
 from datetime import timedelta
 from pathlib import Path
@@ -218,6 +219,9 @@ _FD_COLORS: dict[int, AnsiColor] = {
 }
 _ANSI_RESET = "\033[0m"
 
+# Seconds to wait after a task is scheduled before showing queueing progress again for a Function
+QUEUEING_STRAGGLER_GRACE_SECS = 30.0
+
 
 class RichOutputManager(OutputManager):
     """Rich-based implementation of OutputManager.
@@ -230,6 +234,7 @@ class RichOutputManager(OutputManager):
     _stderr_console: Console
     _task_states: dict[str, int]
     _task_progress_items: dict[tuple[str, int], TaskID]
+    _function_scheduled_at: dict[str, float]
     _current_render_group: Group | None
     _function_progress: Progress | None
     _function_queueing_progress: Progress | None
@@ -264,6 +269,7 @@ class RichOutputManager(OutputManager):
         self._stderr_console = _make_console(stderr=True, highlight=True)
         self._task_states = {}
         self._task_progress_items = {}
+        self._function_scheduled_at = {}
         self._current_render_group = None
         self._function_progress = None
         self._function_queueing_progress = None
@@ -587,6 +593,9 @@ class RichOutputManager(OutputManager):
         task_description = description or f"'{function_id}' function waiting on worker"
         task_description = escape(task_description)
         task_desc = f"[yellow]{task_description}. Time in queue:"
+        is_completion = completed == total
+        if is_completion:
+            self._function_scheduled_at[function_id] = time.monotonic()
         if task_key in self._task_progress_items:
             progress_task_id = self._task_progress_items[task_key]
             try:
@@ -596,14 +605,17 @@ class RichOutputManager(OutputManager):
                     completed=completed,
                     total=total,
                 )
-                if completed == total:
+                if is_completion:
                     del self._task_progress_items[task_key]
                     self._function_queueing_progress_bar.remove_task(progress_task_id)
             except KeyError:
                 pass
-        elif completed != total:  # Create new bar for queued function
-            progress_task_id = self._function_queueing_progress_bar.add_task(task_desc, start=True, total=None)
-            self._task_progress_items[task_key] = progress_task_id
+        elif not is_completion:
+            scheduled_at = self._function_scheduled_at.get(function_id)
+            if scheduled_at is None or (time.monotonic() - scheduled_at) >= QUEUEING_STRAGGLER_GRACE_SECS:
+                # Create new bar for queued function
+                progress_task_id = self._function_queueing_progress_bar.add_task(task_desc, start=True, total=None)
+                self._task_progress_items[task_key] = progress_task_id
 
     def _get_line_buffer(self, fd: int, mode: str, callback: Callable[[str], None]) -> LineBufferedOutput:
         """Get or create a LineBufferedOutput for the given file descriptor and mode.

{modal-1.5.6.dev20 → modal-1.5.6.dev22}/modal/_runtime/user_code_imports.py

@@ -29,7 +29,7 @@ from modal._utils.function_utils import (
 from modal.app import _App
 from modal.config import logger
 from modal.exception import ExecutionError, InvalidError
-from modal.experimental.flash import _FlashContainerEntry
+from modal.experimental._flash_container_entry import _FlashContainerEntry
 from modal_proto import api_pb2
 
 if typing.TYPE_CHECKING:

{modal-1.5.6.dev20 → modal-1.5.6.dev22}/modal/_tunnel.py

@@ -173,7 +173,6 @@ async def _forward(
         forwarding code in an `@enter` lifecycle method of an @app.cls, to only make a single
         ssh server and port for each container (and not one for each input to the function).
     """
-
     if not isinstance(port, int):
         raise InvalidError(f"The port argument should be an int, not {port!r}")
     if port < 1 or port > 65535:

{modal-1.5.6.dev20 → modal-1.5.6.dev22}/modal/app.py

@@ -1332,6 +1332,7 @@ class _App:
         memory: int | tuple[int, int] | None = None,  # Memory in MiB to request
         ephemeral_disk: int | None = None,  # Ephemeral disk size in MiB
         target_concurrency: float | None = None,  # Target concurrency for the server; 0 disables autoscaling
+        max_concurrency: int | None = None,  # Maximum concurrent requests per container
         min_containers: int | None = None,  # Minimum number of containers to keep warm
         max_containers: int | None = None,  # Maximum number of containers
         buffer_containers: int | None = None,  # Additional idle containers under active load
@@ -1381,6 +1382,9 @@ class _App:
             target_concurrency:
                 Target number of concurrent requests per container; 0 disables autoscaling. May be
                 fractional, e.g. 1.5 to target three concurrent requests per two containers.
+            max_concurrency:
+                Maximum number of concurrent requests per container. Requests above this limit
+                receive a 503 response. If set to 0 or unset, request concurrency is unlimited.
             min_containers: Minimum number of containers to keep running regardless of demand.
             max_containers: Limit on the number of containers that can be concurrently running.
             buffer_containers: Extra containers to scale up beyond current demand.
@@ -1430,6 +1434,22 @@ class _App:
         if target_concurrency is not None:
             validate_target_concurrency(target_concurrency, "target_concurrency", allow_fractional=True)
 
+        if max_concurrency is not None:
+            if experimental_options is not None and "max_concurrency" in experimental_options:
+                raise InvalidError(
+                    "`max_concurrency` cannot be set both as an app.server parameter and an experimental option."
+                )
+            if isinstance(max_concurrency, bool) or not isinstance(max_concurrency, (int, float)):
+                raise InvalidError(
+                    f"The `max_concurrency` argument must be a number, not {type(max_concurrency).__name__}."
+                )
+            if not isinstance(max_concurrency, int):
+                raise InvalidError("The `max_concurrency` argument must be an integer.")
+            if max_concurrency < 0:
+                raise InvalidError("The `max_concurrency` argument must be non-negative.")
+            if max_concurrency and target_concurrency is not None and target_concurrency > max_concurrency:
+                raise InvalidError("The `target_concurrency` argument cannot be greater than `max_concurrency`.")
+
         if scaleup_window is not None and scaleup_window <= 0:
             raise InvalidError("`scaleup_window` must be > 0")
 
@@ -1491,8 +1511,8 @@ class _App:
                 scaledown_window=scaledown_window,
                 proxy=proxy,
                 retries=None,  # No support for Server level retries
-                max_concurrent_inputs=None,  # No support for Server level concurrent inputs
-                target_concurrent_inputs=target_concurrency,  # No support for Server level concurrent inputs
+                max_concurrent_inputs=max_concurrency,
+                target_concurrent_inputs=target_concurrency,
                 batch_max_size=None,  # No support for Server level batching
                 batch_wait_ms=None,  # No support for Server level batching
                 startup_timeout=startup_timeout,

{modal-1.5.6.dev20 → modal-1.5.6.dev22}/modal/app.pyi

@@ -759,6 +759,7 @@ class _App:
         memory: typing.Union[int, tuple[int, int], None] = None,
         ephemeral_disk: typing.Optional[int] = None,
         target_concurrency: typing.Optional[float] = None,
+        max_concurrency: typing.Optional[int] = None,
         min_containers: typing.Optional[int] = None,
         max_containers: typing.Optional[int] = None,
         buffer_containers: typing.Optional[int] = None,
@@ -808,6 +809,9 @@ class _App:
             target_concurrency:
                 Target number of concurrent requests per container; 0 disables autoscaling. May be
                 fractional, e.g. 1.5 to target three concurrent requests per two containers.
+            max_concurrency:
+                Maximum number of concurrent requests per container. Requests above this limit
+                receive a 503 response. If set to 0 or unset, request concurrency is unlimited.
             min_containers: Minimum number of containers to keep running regardless of demand.
             max_containers: Limit on the number of containers that can be concurrently running.
             buffer_containers: Extra containers to scale up beyond current demand.
@@ -1808,6 +1812,7 @@ class App:
         memory: typing.Union[int, tuple[int, int], None] = None,
         ephemeral_disk: typing.Optional[int] = None,
         target_concurrency: typing.Optional[float] = None,
+        max_concurrency: typing.Optional[int] = None,
         min_containers: typing.Optional[int] = None,
         max_containers: typing.Optional[int] = None,
         buffer_containers: typing.Optional[int] = None,
@@ -1857,6 +1862,9 @@ class App:
             target_concurrency:
                 Target number of concurrent requests per container; 0 disables autoscaling. May be
                 fractional, e.g. 1.5 to target three concurrent requests per two containers.
+            max_concurrency:
+                Maximum number of concurrent requests per container. Requests above this limit
+                receive a 503 response. If set to 0 or unset, request concurrency is unlimited.
             min_containers: Minimum number of containers to keep running regardless of demand.
             max_containers: Limit on the number of containers that can be concurrently running.
             buffer_containers: Extra containers to scale up beyond current demand.

{modal-1.5.6.dev20 → modal-1.5.6.dev22}/modal/cli/entry_point.py

@@ -22,7 +22,6 @@ from .endpoint import endpoint_cli
 from .environment import environment_cli
 from .function import function_cli
 from .image import image_cli
-from .launch import launch_cli
 from .logo import print_logo
 from .network_file_system import nfs_cli
 from .profile import profile_cli
@@ -112,9 +111,6 @@ entrypoint_cli.add_command(run.deploy, "deploy", panel="Commands")
 entrypoint_cli.add_command(run.serve, "serve", panel="Commands")
 entrypoint_cli.add_command(shell_module.shell, "shell", panel="Commands")
 entrypoint_cli.add_command(run.run, "run", panel="Commands")
-# launch is hidden as it's experimental and we're tracking towards removing it
-entrypoint_cli.add_command(launch_cli, hidden=True)
-
 entrypoint_cli.add_command(app_cli, panel="Deployments")
 entrypoint_cli.add_command(container_cli, panel="Deployments")
 entrypoint_cli.add_command(endpoint_cli, panel="Deployments")

{modal-1.5.6.dev20 → modal-1.5.6.dev22}/modal/client.pyi

@@ -77,7 +77,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.6.dev20",
+        version: str = "1.5.6.dev22",
         *,
         oauth_credentials: typing.Optional[_OAuthCredentials] = None,
     ):
@@ -277,7 +277,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.5.6.dev20",
+        version: str = "1.5.6.dev22",
         *,
         oauth_credentials: typing.Optional[_OAuthCredentials] = None,
     ):

{modal-1.5.6.dev20 → modal-1.5.6.dev22}/modal/experimental/__init__.py

@@ -30,6 +30,10 @@ from .flash import (  # noqa: F401
     flash_get_containers,
     http_server,
 )
+from .flash_server import (  # noqa: F401
+    ServerManager,
+    server_forward,
+)
 
 
 @synchronizer.create_blocking

modal-1.5.6.dev22/modal/experimental/_flash_container_entry.py

@@ -0,0 +1,66 @@
+# Copyright Modal Labs 2025
+
+from typing import Protocol
+
+from modal._clustered_functions import get_cluster_info
+from modal_proto import api_pb2
+
+from .._runtime.task_lifecycle_manager import UserException
+from ..config import logger
+from ..exception import InvalidError
+from ..experimental.flash_server import server_forward
+from .flash import flash_forward
+
+
+class _FlashLifecycleManager(Protocol):
+    def stop(self) -> None: ...
+
+    def close(self) -> None: ...
+
+
+class _FlashContainerEntry:
+    """
+    A class that manages the lifecycle of Flash manager for Flash containers.
+
+    It is intentional that stop() runs before exit handlers and close(): new requests stop arriving
+    before exit handlers run, and in-flight requests keep working until the exit grace period has
+    elapsed. For server containers both calls are no-ops.
+    """
+
+    flash_manager: _FlashLifecycleManager | None
+
+    def __init__(self, http_config: api_pb2.HTTPConfig, is_server: bool = False):
+        self.http_config: api_pb2.HTTPConfig = http_config
+        self.flash_manager = None
+        self.is_server = is_server
+
+    def enter(self):
+        if self.http_config != api_pb2.HTTPConfig():
+            try:
+                if self.is_server:
+                    self.flash_manager = server_forward()
+                else:
+                    try:
+                        rank = get_cluster_info().rank
+                        if rank != 0:
+                            return
+                    except InvalidError:
+                        pass
+
+                    self.flash_manager = flash_forward(
+                        self.http_config.port,
+                        startup_timeout=self.http_config.startup_timeout,
+                        exit_grace_period=self.http_config.exit_grace_period,
+                        h2_enabled=self.http_config.h2_enabled,
+                    )
+            except Exception as e:
+                logger.warning(f"[Modal Flash] Startup failed: {e}")
+                raise UserException()
+
+    def stop(self):
+        if self.flash_manager:
+            self.flash_manager.stop()
+
+    def close(self):
+        if self.flash_manager:
+            self.flash_manager.close()

{modal-1.5.6.dev20 → modal-1.5.6.dev22}/modal/experimental/flash.py

@@ -8,12 +8,10 @@ from collections.abc import Callable
 from typing import Any
 from urllib.parse import urlparse
 
-from modal._clustered_functions import get_cluster_info
 from modal._partial_function import _PartialFunctionFlags
 from modal.cls import _Cls
 from modal_proto import api_pb2
 
-from .._runtime.task_lifecycle_manager import UserException
 from .._server import validate_http_server_config
 from .._tunnel import _forward as _forward_tunnel
 from .._utils.async_utils import synchronize_api, synchronizer
@@ -35,17 +33,15 @@ class _FlashManager:
         startup_timeout: int = 30,
         exit_grace_period: int = 0,
         h2_enabled: bool = False,
-        is_server: bool = False,
     ):
         self.client = client
         self.port = port
         self.process = process
+        self.tunnel_manager = _forward_tunnel(port, h2_enabled=h2_enabled, client=client)
         # Health check is not currently being used
         self.health_check_url = health_check_url
         self.startup_timeout = startup_timeout
         self.exit_grace_period = exit_grace_period
-        self.tunnel_manager = _forward_tunnel(port, h2_enabled=h2_enabled, client=client)
-        self.is_server = is_server
         self.stopped = False
         self.num_heartbeat_failures = 0
         self.task_id = os.environ["MODAL_TASK_ID"]
@@ -85,16 +81,8 @@ class _FlashManager:
         host = parsed_url.hostname
         assert host is not None, f"Tunnel URL has no host: {self.tunnel.url}"
         port = parsed_url.port or 443
-
-        if self.is_server:
-            await self._start_server_tunnel()
-            return
         await self._start_flash_registration(host, port)
 
-    async def _start_server_tunnel(self) -> None:
-        # Worker-side HTTP relay owns Flash registration and drain for server tasks.
-        logger.warning(f"[Modal Flash] Server tunnel opened at {self.tunnel.url}.")
-
     async def _start_flash_registration(self, host: str, port: int) -> None:
         try:
             await self._wait_for_port_success(host, port)
@@ -231,12 +219,9 @@ class _FlashManager:
     async def close(self):
         if not self.stopped:
             await self.stop()
-
-        # Server tasks drain via the worker-side HTTP relay, so skip the
-        # Python-side sleep here to avoid double-counting the grace period.
-        if not self.is_server:
-            await asyncio.sleep(self.exit_grace_period)
-
+        # The container is already deregistered at this point, so waiting out the grace period
+        # gives in-flight requests time to finish before the tunnel goes away.
+        await asyncio.sleep(self.exit_grace_period)
         logger.warning(f"[Modal Flash] Closing tunnel on {self.tunnel.url}.")
         await self.tunnel_manager.__aexit__(*sys.exc_info())
 
@@ -252,7 +237,6 @@ async def flash_forward(
     startup_timeout: int = 30,
     exit_grace_period: int = 0,
     h2_enabled: bool = False,
-    is_server: bool = False,
 ) -> _FlashManager:
     """
     Forward a port to the Modal Flash service, exposing that port as a stable endpoint.
@@ -269,7 +253,6 @@ async def flash_forward(
         startup_timeout=startup_timeout,
         exit_grace_period=exit_grace_period,
         h2_enabled=h2_enabled,
-        is_server=is_server,
     )
     await manager._start()
     return manager
@@ -314,7 +297,7 @@ def _http_server(
         raise InvalidError(
             "Positional arguments are not allowed. Did you forget parentheses? Suggestion: `@modal.http_server()`."
         )
-    validate_http_server_config(port, proxy_regions, startup_timeout, exit_grace_period, is_server=False)
+    validate_http_server_config(port, proxy_regions, startup_timeout, exit_grace_period)
 
     from modal._partial_function import _PartialFunction, _PartialFunctionParams
 
@@ -342,48 +325,3 @@ def _http_server(
 
 
 http_server = synchronize_api(_http_server, target_module=__name__)
-
-
-class _FlashContainerEntry:
-    """
-    A class that manages the lifecycle of Flash manager for Flash containers.
-
-    It is intentional that stop() runs before exit handlers and close().
-    This ensures the container is deregistered first, preventing new requests from being routed to it
-    while exit handlers execute and the exit grace period elapses, before finally closing the tunnel.
-    """
-
-    flash_manager: FlashManager | None  # type: ignore
-
-    def __init__(self, http_config: api_pb2.HTTPConfig, is_server: bool = False):
-        self.http_config: api_pb2.HTTPConfig = http_config
-        self.flash_manager = None
-        self.is_server = is_server
-
-    def enter(self):
-        if self.http_config != api_pb2.HTTPConfig():
-            try:
-                rank = get_cluster_info().rank
-                if rank != 0:
-                    return
-            except InvalidError:
-                pass
-            try:
-                self.flash_manager = flash_forward(
-                    self.http_config.port,
-                    startup_timeout=self.http_config.startup_timeout,
-                    exit_grace_period=self.http_config.exit_grace_period,
-                    h2_enabled=self.http_config.h2_enabled,
-                    is_server=self.is_server,
-                )
-            except Exception as e:
-                logger.warning(f"[Modal Flash] Startup failed: {e}")
-                raise UserException()
-
-    def stop(self):
-        if self.flash_manager:
-            self.flash_manager.stop()
-
-    def close(self):
-        if self.flash_manager:
-            self.flash_manager.close()

{modal-1.5.6.dev20 → modal-1.5.6.dev22}/modal/experimental/flash.pyi

@@ -1,5 +1,4 @@
 import modal.client
-import modal_proto.api_pb2
 import subprocess
 import typing
 import typing_extensions
@@ -14,7 +13,6 @@ class _FlashManager:
         startup_timeout: int = 30,
         exit_grace_period: int = 0,
         h2_enabled: bool = False,
-        is_server: bool = False,
     ):
         """Initialize self.  See help(type(self)) for accurate signature."""
         ...
@@ -23,7 +21,6 @@ class _FlashManager:
         self, process: typing.Optional[subprocess.Popen], timeout: float = 0.5
     ) -> tuple[bool, typing.Optional[Exception]]: ...
     async def _start(self): ...
-    async def _start_server_tunnel(self) -> None: ...
     async def _start_flash_registration(self, host: str, port: int) -> None: ...
     async def _deregister(self): ...
     async def _drain_container(self):
@@ -46,7 +43,6 @@ class FlashManager:
         startup_timeout: int = 30,
         exit_grace_period: int = 0,
         h2_enabled: bool = False,
-        is_server: bool = False,
     ): ...
 
     class __is_port_connection_healthy_spec(typing_extensions.Protocol):
@@ -65,12 +61,6 @@ class FlashManager:
 
     _start: ___start_spec
 
-    class ___start_server_tunnel_spec(typing_extensions.Protocol):
-        def __call__(self, /) -> None: ...
-        async def aio(self, /) -> None: ...
-
-    _start_server_tunnel: ___start_server_tunnel_spec
-
     class ___start_flash_registration_spec(typing_extensions.Protocol):
         def __call__(self, /, host: str, port: int) -> None: ...
         async def aio(self, /, host: str, port: int) -> None: ...
@@ -130,7 +120,6 @@ class __flash_forward_spec(typing_extensions.Protocol):
         startup_timeout: int = 30,
         exit_grace_period: int = 0,
         h2_enabled: bool = False,
-        is_server: bool = False,
     ) -> FlashManager:
         """Forward a port to the Modal Flash service, exposing that port as a stable endpoint.
         This is a highly experimental method that can break or be removed at any time without warning.
@@ -147,7 +136,6 @@ class __flash_forward_spec(typing_extensions.Protocol):
         startup_timeout: int = 30,
         exit_grace_period: int = 0,
         h2_enabled: bool = False,
-        is_server: bool = False,
     ) -> FlashManager:
         """Forward a port to the Modal Flash service, exposing that port as a stable endpoint.
         This is a highly experimental method that can break or be removed at any time without warning.
@@ -215,21 +203,3 @@ def http_server(
         exit_grace_period: The time to wait for the HTTP server to exit gracefully.
     """
     ...
-
-class _FlashContainerEntry:
-    """A class that manages the lifecycle of Flash manager for Flash containers.
-
-    It is intentional that stop() runs before exit handlers and close().
-    This ensures the container is deregistered first, preventing new requests from being routed to it
-    while exit handlers execute and the exit grace period elapses, before finally closing the tunnel.
-    """
-
-    flash_manager: typing.Optional[FlashManager]
-
-    def __init__(self, http_config: modal_proto.api_pb2.HTTPConfig, is_server: bool = False):
-        """Initialize self.  See help(type(self)) for accurate signature."""
-        ...
-
-    def enter(self): ...
-    def stop(self): ...
-    def close(self): ...

modal-1.5.6.dev22/modal/experimental/flash_server.py

@@ -0,0 +1,39 @@
+# Copyright Modal Labs 2025
+import os
+
+from modal_proto import api_pb2
+
+from .._utils.async_utils import synchronize_api, synchronizer
+from ..client import _Client
+from ..config import logger
+
+
+class _ServerManager:
+    def __init__(
+        self,
+        client: _Client,
+    ):
+        self.client = client
+        self.task_id = os.environ["MODAL_TASK_ID"]
+
+    async def _start(self):
+        await self.client.stub.ContainerServerLifecycleReady(api_pb2.ContainerServerLifecycleReadyRequest())
+        logger.warning(f"[Modal Server] Ready for task {self.task_id}.")
+
+    async def stop(self):
+        pass
+
+    async def close(self):
+        logger.warning(f"[Modal Server] Drained for task {self.task_id}.")
+
+
+ServerManager = synchronize_api(_ServerManager, target_module=__name__)
+
+
+@synchronizer.create_blocking
+async def server_forward() -> _ServerManager:
+    client = await _Client.from_env()
+
+    manager = _ServerManager(client)
+    await manager._start()
+    return manager

modal-1.5.6.dev22/modal/experimental/flash_server.pyi

@@ -0,0 +1,38 @@
+import modal.client
+import typing_extensions
+
+class _ServerManager:
+    def __init__(self, client: modal.client._Client):
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
+    async def _start(self): ...
+    async def stop(self): ...
+    async def close(self): ...
+
+class ServerManager:
+    def __init__(self, client: modal.client.Client): ...
+
+    class ___start_spec(typing_extensions.Protocol):
+        def __call__(self, /): ...
+        async def aio(self, /): ...
+
+    _start: ___start_spec
+
+    class __stop_spec(typing_extensions.Protocol):
+        def __call__(self, /): ...
+        async def aio(self, /): ...
+
+    stop: __stop_spec
+
+    class __close_spec(typing_extensions.Protocol):
+        def __call__(self, /): ...
+        async def aio(self, /): ...
+
+    close: __close_spec
+
+class __server_forward_spec(typing_extensions.Protocol):
+    def __call__(self, /) -> ServerManager: ...
+    async def aio(self, /) -> ServerManager: ...
+
+server_forward: __server_forward_spec

{modal-1.5.6.dev20 → modal-1.5.6.dev22}/modal/functions.pyi

@@ -653,7 +653,7 @@ class Function(
 
     _call_generator: ___call_generator_spec
 
-    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER:
             """Calls the function remotely, executing it with the given arguments and returning the execution's result.
 
@@ -678,7 +678,7 @@ class Function(
             """
             ...
 
-    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P]
+    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType]
 
     class __remote_gen_spec(typing_extensions.Protocol):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]:
@@ -728,7 +728,7 @@ class Function(
         """
         ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """[Experimental] Calls the function with the given arguments, without waiting for the results.
 
@@ -761,7 +761,7 @@ class Function(
             """
             ...
 
-    _experimental_spawn: ___experimental_spawn_spec[modal._functions.ReturnType, modal._functions.P]
+    _experimental_spawn: ___experimental_spawn_spec[modal._functions.P, modal._functions.ReturnType]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> None: ...
@@ -769,7 +769,7 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P]
 
-    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]:
             """Calls the function with the given arguments, without waiting for the results.
 
@@ -802,7 +802,7 @@ class Function(
             """
             ...
 
-    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P]
+    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]:
         """Return the inner Python object wrapped by this Modal Function.