modal 1.4.4.dev17__tar.gz → 1.4.4.dev19__tar.gz

{modal-1.4.4.dev17 → modal-1.4.4.dev19}/PKG-INFO

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

{modal-1.4.4.dev17 → modal-1.4.4.dev19}/modal/_container_entrypoint.py

@@ -28,7 +28,7 @@ from modal._clustered_functions import initialize_clustered_function
 from modal._runtime.user_code_event_loop import UserCodeEventLoop
 from modal._serialization import deserialize, deserialize_params
 from modal._utils.async_utils import TaskContext, aclosing, synchronizer
-from modal.app import App, _App
+from modal.app import _App
 from modal.client import Client, _Client
 from modal.config import logger
 from modal.exception import ExecutionError, InputCancellation
@@ -288,7 +288,7 @@ def get_serialized_user_class_and_function(
 
 
 def get_server_service(
-    container_args: api_pb2.ContainerArguments, function_def: api_pb2.Function, _client: _Client, client: Client
+    container_args: api_pb2.ContainerArguments, function_def: api_pb2.Function, _client: _Client
 ) -> Service:
     ser_usr_cls, ser_fun = get_serialized_user_class_and_function(function_def, _client)
     service_base_function_id = container_args.app_layout.function_ids[function_def.function_name]
@@ -298,14 +298,14 @@ def get_server_service(
     service = import_server_service(
         function_def,
         service_function_hydration_data,
-        client,
+        _client,
         ser_usr_cls,
     )
     return service
 
 
 def get_class_service(
-    container_args: api_pb2.ContainerArguments, function_def: api_pb2.Function, _client: _Client, client: Client
+    container_args: api_pb2.ContainerArguments, function_def: api_pb2.Function, _client: _Client
 ) -> Service:
     ser_usr_cls, ser_fun = get_serialized_user_class_and_function(function_def, _client)
     if container_args.serialized_params:
@@ -326,7 +326,7 @@ def get_class_service(
         function_def,
         service_function_hydration_data,
         class_id,
-        client,
+        _client,
         ser_usr_cls,
         param_args,
         param_kwargs,
@@ -349,16 +349,15 @@ def hydrate_function(
     task_lifecycle_manager: TaskLifecycleManager,
     function_def: api_pb2.Function,
     _client: _Client,
-    client: Client,
 ) -> Service:
     active_app: _App
     service: Service
     with task_lifecycle_manager.handle_task_lifecycle_exception():
         with execution_context._import_context():
             if function_def.is_server:
-                service = get_server_service(container_args, function_def, _client, client)
+                service = get_server_service(container_args, function_def, _client)
             elif function_def.is_class:
-                service = get_class_service(container_args, function_def, _client, client)
+                service = get_class_service(container_args, function_def, _client)
             else:
                 service = get_function_service(function_def, _client)
 
@@ -369,8 +368,7 @@ def hydrate_function(
 
     # Initialize objects on the app.
     # This is basically only functions and classes - anything else is deprecated and will be unsupported soon
-    app: App = cast(App, synchronizer._translate_out(active_app))
-    app._init_container(client, container_app)
+    active_app._init_container(_client, container_app)
 
     # Hydrate all function dependencies.
     # TODO(erikbern): we an remove this once we
@@ -406,7 +404,7 @@ def run_server(container_args: api_pb2.ContainerArguments, client: Client):
         client,
     )
 
-    service: Service = hydrate_function(container_args, task_lifecycle_manager, function_def, _client, client)
+    service: Service = hydrate_function(container_args, task_lifecycle_manager, function_def, _client)
     # Initialize clustered functions.
     if function_def._experimental_group_size > 0:
         initialize_clustered_function(
@@ -442,7 +440,7 @@ def run_function(container_args: api_pb2.ContainerArguments, client: Client):
     with container_io_manager.heartbeats(is_snapshotting_function), UserCodeEventLoop() as event_loop:
         # Initialize the function, importing user code.
         service: Service = hydrate_function(
-            container_args, container_io_manager.get_task_lifecycle_manager(), function_def, _client, client
+            container_args, container_io_manager.get_task_lifecycle_manager(), function_def, _client
         )
         if function_def.pty_info.pty_type == api_pb2.PTYInfo.PTY_TYPE_SHELL:
             # Concurrency and batching doesn't apply for `modal shell`.

{modal-1.4.4.dev17 → modal-1.4.4.dev19}/modal/_function_variants.py

@@ -185,6 +185,48 @@ class _FunctionOptions:
         )
 
 
+async def _function_bind_params_cached(
+    base_function: "_Function",
+    req: api_pb2.FunctionBindParamsRequest,
+) -> api_pb2.FunctionBindParamsResponse:
+    """Cache layer for FunctionBindParams RPCs, scoped to a base Function handle.
+
+    We have this because users probably do not realize that Function invocations structured as
+
+        res = f.with_options(...).remote(...)
+
+    would always need to do two sequential RPCs (bind params / call function variant).
+
+    The bound Function ID from FunctionBindParams is deterministic with respect to the full request,
+    so we can avoid the unnecessary call and hydrate the new instance from a cached response.
+
+    The cache is stored on the base Function handle so that the variant cache behaves similarly to
+    the local reference to the base Function metadata.
+
+    """
+    cache = base_function._bind_params_cache
+    cache_key = req.SerializeToString(deterministic=True)
+
+    cached_response = cache.get(cache_key)
+    if cached_response is not None:
+        cache.move_to_end(cache_key)
+        response = api_pb2.FunctionBindParamsResponse()
+        response.ParseFromString(cached_response)
+        return response
+
+    assert base_function._client and base_function._client.stub
+    response = await base_function._client.stub.FunctionBindParams(req)
+
+    cache[cache_key] = response.SerializeToString(deterministic=True)
+    cache.move_to_end(cache_key)
+
+    max_cache_size = 32
+    while len(cache) > max_cache_size:
+        cache.popitem(last=False)
+
+    return response
+
+
 def _make_function_variant(
     base_function: "_Function",
     options: _FunctionOptions | None,
@@ -229,7 +271,7 @@ def _make_function_variant(
             or "",  # TODO: investigate shouldn't environment name always be specified here?
         )
 
-        response = await base_function._client.stub.FunctionBindParams(req)
+        response = await _function_bind_params_cached(base_function, req)
         function_variant._hydrate(response.bound_function_id, base_function._client, response.handle_metadata)
 
     def _deps():

{modal-1.4.4.dev17 → modal-1.4.4.dev19}/modal/_functions.py

@@ -5,6 +5,7 @@ import inspect
 import time
 import typing
 import warnings
+from collections import OrderedDict
 from collections.abc import AsyncGenerator, AsyncIterator, Callable, Collection, Sequence
 from dataclasses import dataclass
 from pathlib import PurePosixPath
@@ -1354,6 +1355,11 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         self._options = _FunctionOptions()
         self._base_function = None
 
+        # An OrderedDict[bytes, bytes] LRU of FunctionBindParams responses for
+        # variants derived from this base Function. Omitted from class-level annotations because
+        # Synchronicity doesn't understand OrderedDict as a type hint.
+        self._bind_params_cache = OrderedDict()
+
     def _hydrate_metadata(self, metadata: Message | None):
         # Overridden concrete implementation of base class method
         assert metadata and isinstance(metadata, api_pb2.FunctionHandleMetadata), (
@@ -1382,6 +1388,10 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         )
         self._experimental_flash_urls = metadata._experimental_flash_urls
 
+        # Invalidate the Function variant cache when we load new metadata, since the base Function handle
+        # is now in sync with the server but any previously-cached variants may be stale.
+        self._bind_params_cache.clear()
+
     def _get_metadata(self):
         # Overridden concrete implementation of base class method
         assert self._function_name, f"Function name must be set before metadata can be retrieved for {self}"

{modal-1.4.4.dev17 → modal-1.4.4.dev19}/modal/_image.py

@@ -40,6 +40,7 @@ from ._utils.docker_utils import (
 )
 from ._utils.function_utils import FunctionInfo, parse_gpu_config
 from ._utils.mount_utils import validate_only_modal_volumes, validate_volumes_by_object_id
+from ._utils.name_utils import check_object_name
 from .client import _Client
 from .cloud_bucket_mount import _CloudBucketMount
 from .config import config, logger, user_config_path
@@ -103,6 +104,27 @@ See https://modal.com/docs/guide/modal-1-0-migration for more details.
 P = typing_extensions.ParamSpec("P")
 
 
+def _validate_image_name(name: str) -> None:
+    check_object_name(name, "Image")
+    # Reserve the "im-" prefix for image IDs so CLI args can be parsed
+    # unambiguously as either an image ID or an image name.
+    if name.startswith("im-"):
+        raise InvalidError("Image name cannot start with 'im-' (reserved for image IDs).")
+
+
+def _validate_image_tag(tag: str) -> None:
+    check_object_name(tag, "Image tag")
+
+
+def _parse_named_image_ref(name: str) -> str:
+    image_name, sep, tag = name.partition(":")
+    if not sep:
+        tag = "latest"
+    _validate_image_name(image_name)
+    _validate_image_tag(tag)
+    return f"{image_name}:{tag}"
+
+
 def _validate_python_version(
     python_version: str | None,
     builder_version: ImageBuilderVersion,
@@ -2844,6 +2866,86 @@ class _Image(_Object, type_prefix="im"):
                 if task_log.data:
                     yield task_log.data
 
+    @staticmethod
+    def from_name(
+        name: str,
+        *,
+        environment_name: str | None = None,
+        client: _Client | None = None,
+    ) -> "_Image":
+        """Reference a named Image that was previously published with `.publish()`.
+
+        Names can contain an optional `:tag` part - if no tag part is included `":latest"` is used,
+        matching Docker conventions.
+
+        ```python notest
+        image = modal.Image.from_name("my-image")     # references my-image:latest
+        image_v1 = modal.Image.from_name("my-image:v1")
+
+        @app.function(image=image)
+        def run():
+            ...
+        ```
+        """
+        tag = _parse_named_image_ref(name)
+
+        async def _load(self: _Image, resolver: Resolver, load_context: LoadContext, existing_object_id: str | None):
+            req = api_pb2.ImageGetByTagRequest(
+                tag=tag,
+                environment_name=load_context.environment_name,
+            )
+            response = await load_context.client.stub.ImageGetByTag(req)
+            self._hydrate(response.image_id, load_context.client, None)
+
+        rep = _Image._repr(tag, environment_name)
+        return _Image._from_loader(
+            _load,
+            rep,
+            hydrate_lazily=True,
+            skip_reload=True,
+            load_context_overrides=LoadContext(environment_name=environment_name, client=client),
+        )
+
+    async def publish(
+        self,
+        name: str,
+        *,
+        environment_name: str | None = None,
+        client: _Client | None = None,
+    ) -> None:
+        """Publish this image under the given name
+
+        The Image must already be created (typically by calling `image.build()` or `sandbox.snapshot_filesystem()`).
+
+        Image names can contain an explicit tag designation (using the `name:tag`). If no tag is included in the name,
+        `":latest"` is used, matching Docker conventions. To publish multiple tags, call `.publish()` once per tag.
+
+        ```python notest
+        image = modal.Image.debian_slim().pip_install("numpy")
+        image.build(app)
+        image.publish("my-image-with-numpy")     # my-image-with-numpy:latest
+        image.publish("my-image-with-numpy:v1")
+        ```
+        """
+        tag = _parse_named_image_ref(name)
+
+        if not self.is_hydrated:
+            raise InvalidError("Cannot publish an image that has not been created yet. Call `.build()` first.")
+
+        _client = client or self._client
+        assert _client is not None
+
+        resolved_env = environment_name or config.get("environment") or ""
+
+        await _client.stub.ImagePublish(
+            api_pb2.ImagePublishRequest(
+                image_id=self.object_id,
+                environment_name=resolved_env,
+                is_public=False,
+                tag=tag,
+            )
+        )
+
     async def hydrate(self, client: _Client | None = None) -> Self:
         """mdmd:hidden"""
         # Image inherits hydrate() from Object but can't be hydrated on demand

{modal-1.4.4.dev17 → modal-1.4.4.dev19}/modal/_runtime/user_code_imports.py

@@ -571,7 +571,7 @@ def import_class_service(
     function_def: api_pb2.Function,
     service_function_hydration_data: api_pb2.Object,
     class_id: str,
-    client: "modal.client.Client",
+    _client: "modal.client._Client",
     ser_user_cls: type | None,
     cls_args,
     cls_kwargs,
@@ -599,7 +599,6 @@ def import_class_service(
         # Undecorated user class (serialized or local scope-decoration).
         service_deps = None  # we can't infer service deps for now
         active_app = get_active_app_fallback(function_def)
-        _client = typing.cast("modal.client._Client", synchronizer._translate_in(client))
         _service_function: modal._functions._Function[Any, Any, Any] = modal._functions._Function._new_hydrated(
             service_function_hydration_data.object_id,
             _client,
@@ -627,7 +626,7 @@ def import_class_service(
 def import_server_service(
     function_def: api_pb2.Function,
     service_function_hydration_data: api_pb2.Object,
-    client: "modal.client.Client",
+    _client: "modal.client._Client",
     ser_user_cls: type | None,
 ) -> Service:
     """
@@ -654,7 +653,6 @@ def import_server_service(
         # Undecorated user class (serialized or local scope-decoration).
         service_deps = None  # we can't infer service deps for now
         active_app = get_active_app_fallback(function_def)
-        _client = typing.cast("modal.client._Client", synchronizer._translate_in(client))
         _service_function: modal._functions._Function[Any, Any, Any] = modal._functions._Function._new_hydrated(
             service_function_hydration_data.object_id,
             _client,

{modal-1.4.4.dev17 → modal-1.4.4.dev19}/modal/_utils/sandbox_fs_utils.py

@@ -285,6 +285,53 @@ def make_stat_command(remote_path: str) -> str:
     return json.dumps({"Stat": {"path": remote_path}})
 
 
+def raise_watch_error(returncode: int, stderr: str | bytes, remote_path: str) -> NoReturn:
+    if payload := try_parse_error_payload(stderr):
+        logger.debug(
+            f"sandbox-fs-tools watch error: path={remote_path}, "
+            f"error_kind={payload.error_kind}, message={payload.message}, detail={payload.detail}"
+        )
+        if payload.error_kind == "NotFound":
+            raise SandboxFilesystemNotFoundError(f"{payload.message}: {remote_path}")
+        if payload.error_kind == "PermissionDenied":
+            raise SandboxFilesystemPermissionError(f"{payload.message}: {remote_path}")
+        if payload.error_kind == "NotSupported":
+            raise InvalidError(
+                f"{payload.message}: {remote_path} - this operation is not supported for CloudBucketMounts"
+            )
+        raise SandboxFilesystemError(payload.message)
+
+    if stderr_text := _stderr_to_text(stderr):
+        logger.debug(f"Unstructured modal-sandbox-fs-tools stderr: {stderr_text}")
+    raise SandboxFilesystemError(f"Operation on '{remote_path}' failed with exit code {returncode}")
+
+
+def make_watch_command(
+    remote_path: str,
+    *,
+    recursive: bool,
+    filter: list[str] | None,
+    timeout: int | None,
+) -> str:
+    """Build the JSON command string for a Watch operation.
+
+    The returned JSON must match the `Command` enum in the modal-sandbox-fs-tools
+    Rust crate (crates/modal-sandbox-fs-tools/src/lib.rs). Treat changes to
+    this schema like protobuf changes: fields must not be removed or renamed,
+    only added with backwards-compatible defaults.
+    """
+    return json.dumps(
+        {
+            "Watch": {
+                "path": remote_path,
+                "recursive": recursive,
+                "filter": filter,
+                "timeout_secs": timeout,
+            }
+        }
+    )
+
+
 def validate_absolute_remote_path(remote_path: str, operation: str) -> None:
     if not PurePosixPath(remote_path).is_absolute():
         raise InvalidError(f"Sandbox.filesystem.{operation}() currently only supports absolute remote_path values")

{modal-1.4.4.dev17 → modal-1.4.4.dev19}/modal/billing.py

@@ -3,4 +3,8 @@ from ._billing import WorkspaceBillingReportItem, _workspace_billing_report
 from ._utils.async_utils import synchronize_api
 
 workspace_billing_report = synchronize_api(_workspace_billing_report)
-assert WorkspaceBillingReportItem
+
+__all__ = [
+    "workspace_billing_report",
+    "WorkspaceBillingReportItem",
+]

{modal-1.4.4.dev17 → modal-1.4.4.dev19}/modal/client.pyi

@@ -35,7 +35,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.4.4.dev17",
+        version: str = "1.4.4.dev19",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -205,7 +205,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.4.4.dev17",
+        version: str = "1.4.4.dev19",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.4.4.dev17 → modal-1.4.4.dev19}/modal/file_io.py

@@ -1,10 +1,8 @@
 # Copyright Modal Labs 2024
 import asyncio
-import enum
 import io
 from collections.abc import AsyncIterator, Sequence
-from dataclasses import dataclass
-from typing import TYPE_CHECKING, Generic, TypeVar, Union, cast
+from typing import TYPE_CHECKING, Generic, Optional, TypeVar, Union, cast
 
 if TYPE_CHECKING:
     import _typeshed
@@ -15,6 +13,7 @@ from grpclib.exceptions import StreamTerminatedError
 
 from modal._utils.async_utils import TaskContext
 from modal.exception import ClientClosed
+from modal.sandbox_fs import FileWatchEvent, FileWatchEventType
 from modal_proto import api_pb2
 
 from ._utils.async_utils import synchronize_api
@@ -60,21 +59,7 @@ async def _replace_bytes(file: "_FileIO", data: bytes, start: int | None = None,
     deprecation_error((2025, 12, 3), "replace_bytes has been removed.")
 
 
-class FileWatchEventType(enum.Enum):
-    Unknown = "Unknown"
-    Access = "Access"
-    Create = "Create"
-    Modify = "Modify"
-    Remove = "Remove"
-
-
-@dataclass
-class FileWatchEvent:
-    paths: list[str]
-    type: FileWatchEventType
-
-
-async def _consume_output(client: _Client, exec_id: str) -> AsyncIterator[bytes | None | Exception]:
+async def _consume_output(client: _Client, exec_id: str) -> AsyncIterator[Optional[bytes] | Exception]:
     req = api_pb2.ContainerFilesystemExecGetOutputRequest(
         exec_id=exec_id,
         timeout=55,
@@ -424,7 +409,7 @@ class _FileIO(Generic[T]):
     ) -> AsyncIterator[FileWatchEvent]:
         deprecation_warning(
             (2026, 3, 9),
-            "`FileIO.watch()` is deprecated. Use `Sandbox.watch()` instead.",
+            "`FileIO.watch()` is deprecated. Use `Sandbox.filesystem.watch()` instead.",
         )
         async for event in watch(path, client, task_id, filter, recursive, timeout):
             yield event

{modal-1.4.4.dev17 → modal-1.4.4.dev19}/modal/file_io.pyi

@@ -1,8 +1,8 @@
 import _io
 import _typeshed
 import collections.abc
-import enum
 import modal.client
+import modal.sandbox_fs
 import typing
 import typing_extensions
 
@@ -22,31 +22,6 @@ async def _replace_bytes(
     """
     ...
 
-class FileWatchEventType(enum.Enum):
-    Unknown = "Unknown"
-    Access = "Access"
-    Create = "Create"
-    Modify = "Modify"
-    Remove = "Remove"
-
-class FileWatchEvent:
-    """FileWatchEvent(paths: list[str], type: modal.file_io.FileWatchEventType)"""
-
-    paths: list[str]
-    type: FileWatchEventType
-
-    def __init__(self, paths: list[str], type: FileWatchEventType) -> None:
-        """Initialize self.  See help(type(self)) for accurate signature."""
-        ...
-
-    def __repr__(self):
-        """Return repr(self)."""
-        ...
-
-    def __eq__(self, other):
-        """Return self==value."""
-        ...
-
 def _consume_output(
     client: modal.client._Client, exec_id: str
 ) -> collections.abc.AsyncIterator[typing.Union[bytes, None, Exception]]: ...
@@ -157,10 +132,10 @@ class _FileIO(typing.Generic[T]):
         path: str,
         client: modal.client._Client,
         task_id: str,
-        filter: typing.Optional[list[FileWatchEventType]] = None,
+        filter: typing.Optional[list[modal.sandbox_fs.FileWatchEventType]] = None,
         recursive: bool = False,
         timeout: typing.Optional[int] = None,
-    ) -> collections.abc.AsyncIterator[FileWatchEvent]: ...
+    ) -> collections.abc.AsyncIterator[modal.sandbox_fs.FileWatchEvent]: ...
     async def _close(self) -> None: ...
     async def close(self) -> None:
         """Flush the buffer and close the file."""
@@ -190,10 +165,10 @@ def watch(
     path: str,
     client: modal.client._Client,
     task_id: str,
-    filter: typing.Optional[list[FileWatchEventType]] = None,
+    filter: typing.Optional[list[modal.sandbox_fs.FileWatchEventType]] = None,
     recursive: bool = False,
     timeout: typing.Optional[int] = None,
-) -> collections.abc.AsyncIterator[FileWatchEvent]:
+) -> collections.abc.AsyncIterator[modal.sandbox_fs.FileWatchEvent]:
     """Watch a file or directory for changes."""
     ...
 
@@ -428,20 +403,20 @@ class FileIO(typing.Generic[T]):
             path: str,
             client: modal.client.Client,
             task_id: str,
-            filter: typing.Optional[list[FileWatchEventType]] = None,
+            filter: typing.Optional[list[modal.sandbox_fs.FileWatchEventType]] = None,
             recursive: bool = False,
             timeout: typing.Optional[int] = None,
-        ) -> typing.Iterator[FileWatchEvent]: ...
+        ) -> typing.Iterator[modal.sandbox_fs.FileWatchEvent]: ...
         def aio(
             self,
             /,
             path: str,
             client: modal.client.Client,
             task_id: str,
-            filter: typing.Optional[list[FileWatchEventType]] = None,
+            filter: typing.Optional[list[modal.sandbox_fs.FileWatchEventType]] = None,
             recursive: bool = False,
             timeout: typing.Optional[int] = None,
-        ) -> collections.abc.AsyncIterator[FileWatchEvent]: ...
+        ) -> collections.abc.AsyncIterator[modal.sandbox_fs.FileWatchEvent]: ...
 
     watch: typing.ClassVar[__watch_spec]
 

{modal-1.4.4.dev17 → modal-1.4.4.dev19}/modal/functions.pyi

@@ -465,7 +465,7 @@ class Function(
 
     _call_generator: ___call_generator_spec
 
-    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_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.
 
@@ -490,7 +490,7 @@ class Function(
             """
             ...
 
-    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType]
+    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P]
 
     class __remote_gen_spec(typing_extensions.Protocol):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]:
@@ -540,7 +540,7 @@ class Function(
         """
         ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_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.
 
@@ -573,7 +573,7 @@ class Function(
             """
             ...
 
-    _experimental_spawn: ___experimental_spawn_spec[modal._functions.P, modal._functions.ReturnType]
+    _experimental_spawn: ___experimental_spawn_spec[modal._functions.ReturnType, modal._functions.P]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> None: ...
@@ -581,7 +581,7 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P]
 
-    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
+    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_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.
 
@@ -614,7 +614,7 @@ class Function(
             """
             ...
 
-    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType]
+    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]:
         """Return the inner Python object wrapped by this Modal Function.