modal 1.2.1.dev19__py3-none-any.whl → 1.2.2.dev19__py3-none-any.whl

modal/client.pyi

@@ -33,7 +33,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.1.dev19",
+        version: str = "1.2.2.dev19",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -164,7 +164,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.1.dev19",
+        version: str = "1.2.2.dev19",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -339,95 +339,6 @@ class Client:
         ],
     ) -> collections.abc.AsyncGenerator[typing.Any, None]: ...
 
-class grpc_error_converter:
-    def __enter__(self): ...
-    def __exit__(self, exc_type, exc, traceback) -> bool: ...
-
-class UnaryUnaryWrapper(typing.Generic[RequestType, ResponseType]):
-    """Abstract base class for generic types.
-
-    A generic type is typically declared by inheriting from
-    this class parameterized with one or more type variables.
-    For example, a generic mapping type might be defined as::
-
-      class Mapping(Generic[KT, VT]):
-          def __getitem__(self, key: KT) -> VT:
-              ...
-          # Etc.
-
-    This class can then be used as follows::
-
-      def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
-          try:
-              return mapping[key]
-          except KeyError:
-              return default
-    """
-
-    wrapped_method: grpclib.client.UnaryUnaryMethod[RequestType, ResponseType]
-    client: _Client
-
-    def __init__(
-        self,
-        wrapped_method: grpclib.client.UnaryUnaryMethod[RequestType, ResponseType],
-        client: _Client,
-        server_url: str,
-    ):
-        """Initialize self.  See help(type(self)) for accurate signature."""
-        ...
-
-    @property
-    def name(self) -> str: ...
-    async def __call__(
-        self,
-        req: RequestType,
-        *,
-        timeout: typing.Optional[float] = None,
-        metadata: typing.Union[
-            collections.abc.Mapping[str, typing.Union[str, bytes]],
-            collections.abc.Collection[tuple[str, typing.Union[str, bytes]]],
-            None,
-        ] = None,
-    ) -> ResponseType:
-        """Call self as a function."""
-        ...
-
-class UnaryStreamWrapper(typing.Generic[RequestType, ResponseType]):
-    """Abstract base class for generic types.
-
-    A generic type is typically declared by inheriting from
-    this class parameterized with one or more type variables.
-    For example, a generic mapping type might be defined as::
-
-      class Mapping(Generic[KT, VT]):
-          def __getitem__(self, key: KT) -> VT:
-              ...
-          # Etc.
-
-    This class can then be used as follows::
-
-      def lookup_name(mapping: Mapping[KT, VT], key: KT, default: VT) -> VT:
-          try:
-              return mapping[key]
-          except KeyError:
-              return default
-    """
-
-    wrapped_method: grpclib.client.UnaryStreamMethod[RequestType, ResponseType]
-
-    def __init__(
-        self,
-        wrapped_method: grpclib.client.UnaryStreamMethod[RequestType, ResponseType],
-        client: _Client,
-        server_url: str,
-    ):
-        """Initialize self.  See help(type(self)) for accurate signature."""
-        ...
-
-    @property
-    def name(self) -> str: ...
-    def unary_stream(self, request, metadata: typing.Optional[typing.Any] = None): ...
-
 HEARTBEAT_INTERVAL: float
 
 HEARTBEAT_TIMEOUT: float

modal/cls.py

@@ -30,7 +30,6 @@ from ._utils.deprecation import (
     warn_if_passing_namespace,
     warn_on_renamed_autoscaler_settings,
 )
-from ._utils.grpc_utils import retry_transient_errors
 from ._utils.mount_utils import validate_volumes
 from .cloud_bucket_mount import _CloudBucketMount
 from .config import config
@@ -643,7 +642,7 @@ More information on class parameterization can be found here: https://modal.com/
                 only_class_function=True,
             )
             try:
-                response = await retry_transient_errors(resolver.client.stub.ClassGet, request)
+                response = await resolver.client.stub.ClassGet(request)
             except NotFoundError as exc:
                 env_context = f" (in the '{environment_name}' environment)" if environment_name else ""
                 raise NotFoundError(

modal/config.py

@@ -147,7 +147,7 @@ async def _lookup_workspace(server_url: str, token_id: str, token_secret: str) -
 
     credentials = (token_id, token_secret)
     async with _Client(server_url, api_pb2.CLIENT_TYPE_CLIENT, credentials) as client:
-        return await client.stub.WorkspaceNameLookup(Empty(), timeout=3)
+        return await client.stub.WorkspaceNameLookup(Empty(), retry=None, timeout=3)
 
 
 def config_profiles():

modal/container_process.py

@@ -7,7 +7,6 @@ from typing import Generic, Optional, TypeVar
 from modal_proto import api_pb2
 
 from ._utils.async_utils import TaskContext, synchronize_api
-from ._utils.grpc_utils import retry_transient_errors
 from ._utils.shell_utils import stream_from_stdin, write_to_fd
 from ._utils.task_command_router_client import TaskCommandRouterClient
 from .client import _Client
@@ -101,6 +100,7 @@ class _ContainerProcessThroughServer(Generic[T]):
 
         Returns `None` if the process is still running, else returns the exit code.
         """
+        assert self._process_id
         if self._returncode is not None:
             return self._returncode
         if self._exec_deadline and time.monotonic() >= self._exec_deadline:
@@ -110,7 +110,7 @@ class _ContainerProcessThroughServer(Generic[T]):
             return self._returncode
 
         req = api_pb2.ContainerExecWaitRequest(exec_id=self._process_id, timeout=0)
-        resp: api_pb2.ContainerExecWaitResponse = await retry_transient_errors(self._client.stub.ContainerExecWait, req)
+        resp = await self._client.stub.ContainerExecWait(req)
 
         if resp.completed:
             self._returncode = resp.exit_code
@@ -119,11 +119,10 @@ class _ContainerProcessThroughServer(Generic[T]):
         return None
 
     async def _wait_for_completion(self) -> int:
+        assert self._process_id
         while True:
             req = api_pb2.ContainerExecWaitRequest(exec_id=self._process_id, timeout=10)
-            resp: api_pb2.ContainerExecWaitResponse = await retry_transient_errors(
-                self._client.stub.ContainerExecWait, req
-            )
+            resp = await self._client.stub.ContainerExecWait(req)
             if resp.completed:
                 return resp.exit_code
 
@@ -169,9 +168,6 @@ class _ContainerProcessThroughServer(Generic[T]):
             stream_impl = stream._impl
             # Don't skip empty messages so we can detect when the process has booted.
             async for chunk in stream_impl._get_logs(skip_empty_messages=False):
-                if chunk is None:
-                    break
-
                 if not on_connect.is_set():
                     connecting_status.stop()
                     on_connect.set()

modal/dict.py

@@ -9,6 +9,7 @@ from grpclib import GRPCError, Status
 from synchronicity import classproperty
 from synchronicity.async_wrap import asynccontextmanager
 
+from modal._utils.grpc_utils import Retry
 from modal_proto import api_pb2
 
 from ._object import (
@@ -22,7 +23,6 @@ from ._resolver import Resolver
 from ._serialization import deserialize, serialize
 from ._utils.async_utils import TaskContext, synchronize_api
 from ._utils.deprecation import deprecation_warning, warn_if_passing_namespace
-from ._utils.grpc_utils import retry_transient_errors
 from ._utils.name_utils import check_object_name
 from ._utils.time_utils import as_timestamp, timestamp_to_localized_dt
 from .client import _Client
@@ -105,7 +105,7 @@ class _DictManager:
             object_creation_type=object_creation_type,
         )
         try:
-            await retry_transient_errors(client.stub.DictGetOrCreate, req)
+            await client.stub.DictGetOrCreate(req)
         except GRPCError as exc:
             if exc.status == Status.ALREADY_EXISTS and not allow_existing:
                 raise AlreadyExistsError(exc.message)
@@ -157,7 +157,7 @@ class _DictManager:
             req = api_pb2.DictListRequest(
                 environment_name=_get_environment_name(environment_name), pagination=pagination
             )
-            resp = await retry_transient_errors(client.stub.DictList, req)
+            resp = await client.stub.DictList(req)
             items.extend(resp.dicts)
             finished = (len(resp.dicts) < max_page_size) or (max_objects is not None and len(items) >= max_objects)
             return finished
@@ -215,7 +215,7 @@ class _DictManager:
                 raise
         else:
             req = api_pb2.DictDeleteRequest(dict_id=obj.object_id)
-            await retry_transient_errors(obj._client.stub.DictDelete, req)
+            await obj._client.stub.DictDelete(req)
 
 
 DictManager = synchronize_api(_DictManager)
@@ -327,7 +327,7 @@ class _Dict(_Object, type_prefix="di"):
             environment_name=_get_environment_name(environment_name),
             data=serialized,
         )
-        response = await retry_transient_errors(client.stub.DictGetOrCreate, request, total_timeout=10.0)
+        response = await client.stub.DictGetOrCreate(request, retry=Retry(total_timeout=10.0))
         async with TaskContext() as tc:
             request = api_pb2.DictHeartbeatRequest(dict_id=response.dict_id)
             tc.infinite_loop(lambda: client.stub.DictHeartbeat(request), sleep=_heartbeat_sleep)
@@ -418,7 +418,7 @@ class _Dict(_Object, type_prefix="di"):
     async def clear(self) -> None:
         """Remove all items from the Dict."""
         req = api_pb2.DictClearRequest(dict_id=self.object_id)
-        await retry_transient_errors(self._client.stub.DictClear, req)
+        await self._client.stub.DictClear(req)
 
     @live_method
     async def get(self, key: Any, default: Optional[Any] = None) -> Any:
@@ -427,7 +427,7 @@ class _Dict(_Object, type_prefix="di"):
         Returns `default` if key does not exist.
         """
         req = api_pb2.DictGetRequest(dict_id=self.object_id, key=serialize(key))
-        resp = await retry_transient_errors(self._client.stub.DictGet, req)
+        resp = await self._client.stub.DictGet(req)
         if not resp.found:
             return default
         return deserialize(resp.value, self._client)
@@ -436,7 +436,7 @@ class _Dict(_Object, type_prefix="di"):
     async def contains(self, key: Any) -> bool:
         """Return if a key is present."""
         req = api_pb2.DictContainsRequest(dict_id=self.object_id, key=serialize(key))
-        resp = await retry_transient_errors(self._client.stub.DictContains, req)
+        resp = await self._client.stub.DictContains(req)
         return resp.found
 
     @live_method
@@ -446,7 +446,7 @@ class _Dict(_Object, type_prefix="di"):
         Note: This is an expensive operation and will return at most 100,000.
         """
         req = api_pb2.DictLenRequest(dict_id=self.object_id)
-        resp = await retry_transient_errors(self._client.stub.DictLen, req)
+        resp = await self._client.stub.DictLen(req)
         return resp.len
 
     @live_method
@@ -475,7 +475,7 @@ class _Dict(_Object, type_prefix="di"):
         serialized = _serialize_dict(contents)
         req = api_pb2.DictUpdateRequest(dict_id=self.object_id, updates=serialized)
         try:
-            await retry_transient_errors(self._client.stub.DictUpdate, req)
+            await self._client.stub.DictUpdate(req)
         except GRPCError as exc:
             if "status = '413'" in exc.message:
                 raise RequestSizeError("Dict.update request is too large") from exc
@@ -493,7 +493,7 @@ class _Dict(_Object, type_prefix="di"):
         serialized = _serialize_dict(updates)
         req = api_pb2.DictUpdateRequest(dict_id=self.object_id, updates=serialized, if_not_exists=skip_if_exists)
         try:
-            resp = await retry_transient_errors(self._client.stub.DictUpdate, req)
+            resp = await self._client.stub.DictUpdate(req)
             return resp.created
         except GRPCError as exc:
             if "status = '413'" in exc.message:
@@ -516,7 +516,7 @@ class _Dict(_Object, type_prefix="di"):
         If key is not found, return default if provided, otherwise raise KeyError.
         """
         req = api_pb2.DictPopRequest(dict_id=self.object_id, key=serialize(key))
-        resp = await retry_transient_errors(self._client.stub.DictPop, req)
+        resp = await self._client.stub.DictPop(req)
         if not resp.found:
             if default is not _NO_DEFAULT:
                 return default

modal/environments.py

@@ -11,7 +11,6 @@ from modal_proto import api_pb2
 from ._object import _Object
 from ._resolver import Resolver
 from ._utils.async_utils import synchronize_api, synchronizer
-from ._utils.grpc_utils import retry_transient_errors
 from ._utils.name_utils import check_object_name
 from .client import _Client
 from .config import config, logger
@@ -71,7 +70,7 @@ class _Environment(_Object, type_prefix="en"):
                     else api_pb2.OBJECT_CREATION_TYPE_UNSPECIFIED
                 ),
             )
-            response = await retry_transient_errors(resolver.client.stub.EnvironmentGetOrCreate, request)
+            response = await resolver.client.stub.EnvironmentGetOrCreate(request)
             logger.debug(f"Created environment with id {response.environment_id}")
             self._hydrate(response.environment_id, resolver.client, response.metadata)
 

modal/experimental/__init__.py

@@ -13,7 +13,6 @@ from .._object import _get_environment_name
 from .._partial_function import _clustered
 from .._runtime.container_io_manager import _ContainerIOManager
 from .._utils.async_utils import synchronize_api, synchronizer
-from .._utils.grpc_utils import retry_transient_errors
 from ..app import _App
 from ..client import _Client
 from ..cls import _Cls
@@ -116,7 +115,7 @@ async def get_app_objects(
 
     app = await _App.lookup(app_name, environment_name=environment_name, client=client)
     req = api_pb2.AppGetLayoutRequest(app_id=app.app_id)
-    app_layout_resp = await retry_transient_errors(client.stub.AppGetLayout, req)
+    app_layout_resp = await client.stub.AppGetLayout(req)
 
     app_objects: dict[str, Union[_Function, _Cls]] = {}
 
@@ -361,4 +360,4 @@ async def image_delete(
         client = await _Client.from_env()
 
     req = api_pb2.ImageDeleteRequest(image_id=image_id)
-    await retry_transient_errors(client.stub.ImageDelete, req)
+    await client.stub.ImageDelete(req)

modal/experimental/flash.py

@@ -16,7 +16,6 @@ from modal_proto import api_pb2
 
 from .._tunnel import _forward as _forward_tunnel
 from .._utils.async_utils import synchronize_api, synchronizer
-from .._utils.grpc_utils import retry_transient_errors
 from ..client import _Client
 from ..config import logger
 from ..exception import InvalidError
@@ -126,10 +125,8 @@ class _FlashManager:
                         f"due to error: {port_check_error}, num_failures: {self.num_failures}"
                     )
                     self.num_failures += 1
-                    await retry_transient_errors(
-                        self.client.stub.FlashContainerDeregister,
-                        api_pb2.FlashContainerDeregisterRequest(),
-                    )
+                    await self.client.stub.FlashContainerDeregister(api_pb2.FlashContainerDeregisterRequest())
+
             except asyncio.CancelledError:
                 logger.warning("[Modal Flash] Shutting down...")
                 break
@@ -148,8 +145,7 @@ class _FlashManager:
 
     async def stop(self):
         self.heartbeat_task.cancel()
-        await retry_transient_errors(
-            self.client.stub.FlashContainerDeregister,
+        await self.client.stub.FlashContainerDeregister(
             api_pb2.FlashContainerDeregisterRequest(),
         )
 
@@ -463,12 +459,12 @@ class _FlashPrometheusAutoscaler:
 
     async def _get_all_containers(self):
         req = api_pb2.FlashContainerListRequest(function_id=self.fn.object_id)
-        resp = await retry_transient_errors(self.client.stub.FlashContainerList, req)
+        resp = await self.client.stub.FlashContainerList(req)
         return resp.containers
 
     async def _set_target_slots(self, target_slots: int):
         req = api_pb2.FlashSetTargetSlotsMetricsRequest(function_id=self.fn.object_id, target_slots=target_slots)
-        await retry_transient_errors(self.client.stub.FlashSetTargetSlotsMetrics, req)
+        await self.client.stub.FlashSetTargetSlotsMetrics(req)
         return
 
     def _make_scaling_decision(
@@ -619,5 +615,5 @@ async def flash_get_containers(app_name: str, cls_name: str) -> list[dict[str, A
     assert fn is not None
     await fn.hydrate(client=client)
     req = api_pb2.FlashContainerListRequest(function_id=fn.object_id)
-    resp = await retry_transient_errors(client.stub.FlashContainerList, req)
+    resp = await client.stub.FlashContainerList(req)
     return resp.containers

modal/file_io.py

@@ -13,7 +13,6 @@ import json
 from grpclib.exceptions import GRPCError, StreamTerminatedError
 
 from modal._utils.async_utils import TaskContext
-from modal._utils.grpc_utils import retry_transient_errors
 from modal.exception import ClientClosed
 from modal_proto import api_pb2
 
@@ -57,8 +56,7 @@ async def _delete_bytes(file: "_FileIO", start: Optional[int] = None, end: Optio
     if start is not None and end is not None:
         if start >= end:
             raise ValueError("start must be less than end")
-    resp = await retry_transient_errors(
-        file._client.stub.ContainerFilesystemExec,
+    resp = await file._client.stub.ContainerFilesystemExec(
         api_pb2.ContainerFilesystemExecRequest(
             file_delete_bytes_request=api_pb2.ContainerFileDeleteBytesRequest(
                 file_descriptor=file._file_descriptor,
@@ -85,8 +83,7 @@ async def _replace_bytes(file: "_FileIO", data: bytes, start: Optional[int] = No
             raise InvalidError("start must be less than end")
     if len(data) > WRITE_CHUNK_SIZE:
         raise InvalidError("Write request payload exceeds 16 MiB limit")
-    resp = await retry_transient_errors(
-        file._client.stub.ContainerFilesystemExec,
+    resp = await file._client.stub.ContainerFilesystemExec(
         api_pb2.ContainerFilesystemExecRequest(
             file_write_replace_bytes_request=api_pb2.ContainerFileWriteReplaceBytesRequest(
                 file_descriptor=file._file_descriptor,
@@ -261,8 +258,7 @@ class _FileIO(Generic[T]):
             raise TypeError("Expected str when in text mode")
 
     async def _open_file(self, path: str, mode: str) -> None:
-        resp = await retry_transient_errors(
-            self._client.stub.ContainerFilesystemExec,
+        resp = await self._client.stub.ContainerFilesystemExec(
             api_pb2.ContainerFilesystemExecRequest(
                 file_open_request=api_pb2.ContainerFileOpenRequest(path=path, mode=mode),
                 task_id=self._task_id,
@@ -285,8 +281,7 @@ class _FileIO(Generic[T]):
         return self
 
     async def _make_read_request(self, n: Optional[int]) -> bytes:
-        resp = await retry_transient_errors(
-            self._client.stub.ContainerFilesystemExec,
+        resp = await self._client.stub.ContainerFilesystemExec(
             api_pb2.ContainerFilesystemExecRequest(
                 file_read_request=api_pb2.ContainerFileReadRequest(file_descriptor=self._file_descriptor, n=n),
                 task_id=self._task_id,
@@ -309,8 +304,7 @@ class _FileIO(Generic[T]):
         """Read a single line from the current position."""
         self._check_closed()
         self._check_readable()
-        resp = await retry_transient_errors(
-            self._client.stub.ContainerFilesystemExec,
+        resp = await self._client.stub.ContainerFilesystemExec(
             api_pb2.ContainerFilesystemExecRequest(
                 file_read_line_request=api_pb2.ContainerFileReadLineRequest(file_descriptor=self._file_descriptor),
                 task_id=self._task_id,
@@ -351,8 +345,7 @@ class _FileIO(Generic[T]):
             raise ValueError("Write request payload exceeds 1 GiB limit")
         for i in range(0, len(data), WRITE_CHUNK_SIZE):
             chunk = data[i : i + WRITE_CHUNK_SIZE]
-            resp = await retry_transient_errors(
-                self._client.stub.ContainerFilesystemExec,
+            resp = await self._client.stub.ContainerFilesystemExec(
                 api_pb2.ContainerFilesystemExecRequest(
                     file_write_request=api_pb2.ContainerFileWriteRequest(
                         file_descriptor=self._file_descriptor,
@@ -367,8 +360,7 @@ class _FileIO(Generic[T]):
         """Flush the buffer to disk."""
         self._check_closed()
         self._check_writable()
-        resp = await retry_transient_errors(
-            self._client.stub.ContainerFilesystemExec,
+        resp = await self._client.stub.ContainerFilesystemExec(
             api_pb2.ContainerFilesystemExecRequest(
                 file_flush_request=api_pb2.ContainerFileFlushRequest(file_descriptor=self._file_descriptor),
                 task_id=self._task_id,
@@ -393,8 +385,7 @@ class _FileIO(Generic[T]):
         (relative to the current position) and 2 (relative to the file's end).
         """
         self._check_closed()
-        resp = await retry_transient_errors(
-            self._client.stub.ContainerFilesystemExec,
+        resp = await self._client.stub.ContainerFilesystemExec(
             api_pb2.ContainerFilesystemExecRequest(
                 file_seek_request=api_pb2.ContainerFileSeekRequest(
                     file_descriptor=self._file_descriptor,
@@ -410,8 +401,7 @@ class _FileIO(Generic[T]):
     async def ls(cls, path: str, client: _Client, task_id: str) -> list[str]:
         """List the contents of the provided directory."""
         self = _FileIO(client, task_id)
-        resp = await retry_transient_errors(
-            self._client.stub.ContainerFilesystemExec,
+        resp = await self._client.stub.ContainerFilesystemExec(
             api_pb2.ContainerFilesystemExecRequest(
                 file_ls_request=api_pb2.ContainerFileLsRequest(path=path),
                 task_id=task_id,
@@ -427,8 +417,7 @@ class _FileIO(Generic[T]):
     async def mkdir(cls, path: str, client: _Client, task_id: str, parents: bool = False) -> None:
         """Create a new directory."""
         self = _FileIO(client, task_id)
-        resp = await retry_transient_errors(
-            self._client.stub.ContainerFilesystemExec,
+        resp = await self._client.stub.ContainerFilesystemExec(
             api_pb2.ContainerFilesystemExecRequest(
                 file_mkdir_request=api_pb2.ContainerFileMkdirRequest(path=path, make_parents=parents),
                 task_id=self._task_id,
@@ -440,8 +429,7 @@ class _FileIO(Generic[T]):
     async def rm(cls, path: str, client: _Client, task_id: str, recursive: bool = False) -> None:
         """Remove a file or directory in the Sandbox."""
         self = _FileIO(client, task_id)
-        resp = await retry_transient_errors(
-            self._client.stub.ContainerFilesystemExec,
+        resp = await self._client.stub.ContainerFilesystemExec(
             api_pb2.ContainerFilesystemExecRequest(
                 file_rm_request=api_pb2.ContainerFileRmRequest(path=path, recursive=recursive),
                 task_id=self._task_id,
@@ -460,8 +448,7 @@ class _FileIO(Generic[T]):
         timeout: Optional[int] = None,
     ) -> AsyncIterator[FileWatchEvent]:
         self = _FileIO(client, task_id)
-        resp = await retry_transient_errors(
-            self._client.stub.ContainerFilesystemExec,
+        resp = await self._client.stub.ContainerFilesystemExec(
             api_pb2.ContainerFilesystemExecRequest(
                 file_watch_request=api_pb2.ContainerFileWatchRequest(
                     path=path,
@@ -503,8 +490,7 @@ class _FileIO(Generic[T]):
 
     async def _close(self) -> None:
         # Buffer is flushed by the runner on close
-        resp = await retry_transient_errors(
-            self._client.stub.ContainerFilesystemExec,
+        resp = await self._client.stub.ContainerFilesystemExec(
             api_pb2.ContainerFilesystemExecRequest(
                 file_close_request=api_pb2.ContainerFileCloseRequest(file_descriptor=self._file_descriptor),
                 task_id=self._task_id,

modal/functions.pyi

@@ -401,7 +401,7 @@ class Function(
 
     _call_generator: ___call_generator_spec[typing_extensions.Self]
 
-    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
+    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
         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."""
             ...
@@ -410,7 +410,7 @@ class Function(
             """Calls the function remotely, executing it with the given arguments and returning the execution's result."""
             ...
 
-    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
+    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
 
     class __remote_gen_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]:
@@ -437,7 +437,7 @@ class Function(
         """
         ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
         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.
 
@@ -461,7 +461,7 @@ class Function(
             ...
 
     _experimental_spawn: ___experimental_spawn_spec[
-        modal._functions.P, modal._functions.ReturnType, typing_extensions.Self
+        modal._functions.ReturnType, modal._functions.P, typing_extensions.Self
     ]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER, SUPERSELF]):
@@ -470,7 +470,7 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P, typing_extensions.Self]
 
-    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
+    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
         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.
 
@@ -491,7 +491,7 @@ class Function(
             """
             ...
 
-    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
+    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]:
         """Return the inner Python object wrapped by this Modal Function."""