modal 1.0.6.dev58__py3-none-any.whl → 1.2.3.dev7__py3-none-any.whl

modal/parallel_map.pyi

@@ -1,9 +1,11 @@
 import asyncio
 import asyncio.events
+import asyncio.queues
 import collections.abc
 import enum
 import modal._functions
 import modal._utils.async_utils
+import modal._utils.grpc_utils
 import modal.client
 import modal.functions
 import modal.retries
@@ -60,6 +62,80 @@ class _OutputValue:
         """Return self==value."""
         ...
 
+class InputPreprocessor:
+    """Constructs FunctionPutInputsItem objects from the raw-input queue, and puts them in the processed-input queue."""
+    def __init__(
+        self,
+        client: modal.client._Client,
+        *,
+        raw_input_queue: _SynchronizedQueue,
+        processed_input_queue: asyncio.queues.Queue,
+        function: modal._functions._Function,
+        created_callback: collections.abc.Callable[[int], None],
+        done_callback: collections.abc.Callable[[], None],
+    ):
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
+    def input_iter(self): ...
+    def create_input_factory(self): ...
+    def drain_input_generator(self): ...
+
+class InputPumper:
+    """Reads inputs from a queue of FunctionPutInputsItems, and sends them to the server."""
+    def __init__(
+        self,
+        client: modal.client._Client,
+        *,
+        input_queue: asyncio.queues.Queue,
+        function: modal._functions._Function,
+        function_call_id: str,
+        max_batch_size: int,
+        map_items_manager: typing.Optional[_MapItemsManager] = None,
+    ):
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
+    def pump_inputs(self): ...
+    @property
+    def _function_inputs_retry(self) -> modal._utils.grpc_utils.Retry: ...
+
+class SyncInputPumper(InputPumper):
+    """Reads inputs from a queue of FunctionPutInputsItems, and sends them to the server."""
+    def __init__(
+        self,
+        client: modal.client._Client,
+        *,
+        input_queue: asyncio.queues.Queue,
+        retry_queue: modal._utils.async_utils.TimestampPriorityQueue,
+        function: modal._functions._Function,
+        function_call_jwt: str,
+        function_call_id: str,
+        map_items_manager: _MapItemsManager,
+    ):
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
+    def retry_inputs(self): ...
+
+class AsyncInputPumper(InputPumper):
+    """Reads inputs from a queue of FunctionPutInputsItems, and sends them to the server."""
+    def __init__(
+        self,
+        client: modal.client._Client,
+        *,
+        input_queue: asyncio.queues.Queue,
+        function: modal._functions._Function,
+        function_call_id: str,
+    ):
+        """Initialize self.  See help(type(self)) for accurate signature."""
+        ...
+
+    def pump_inputs(self): ...
+
+async def _spawn_map_invocation(
+    function: modal._functions._Function, raw_input_queue: _SynchronizedQueue, client: modal.client._Client
+) -> tuple[str, int]: ...
 def _map_invocation(
     function: modal._functions._Function,
     raw_input_queue: _SynchronizedQueue,
@@ -70,6 +146,23 @@ def _map_invocation(
     count_update_callback: typing.Optional[collections.abc.Callable[[int, int], None]],
     function_call_invocation_type: int,
 ): ...
+def _map_invocation_inputplane(
+    function: modal._functions._Function,
+    raw_input_queue: _SynchronizedQueue,
+    client: modal.client._Client,
+    order_outputs: bool,
+    return_exceptions: bool,
+    wrap_returned_exceptions: bool,
+    count_update_callback: typing.Optional[collections.abc.Callable[[int, int], None]],
+) -> typing.AsyncGenerator[typing.Any, None]:
+    """Input-plane implementation of a function map invocation.
+
+    This is analogous to `_map_invocation`, but instead of the control-plane
+    `FunctionMap` / `FunctionPutInputs` / `FunctionGetOutputs` RPCs it speaks
+    the input-plane protocol consisting of `MapStartOrContinue`, `MapAwait`, and `MapCheckInputs`.
+    """
+    ...
+
 def _map_helper(
     self: modal.functions.Function,
     async_input_gen: typing.AsyncGenerator[typing.Any, None],
@@ -162,6 +255,33 @@ def _map_sync(
     """
     ...
 
+async def _experimental_spawn_map_async(self, *input_iterators, kwargs={}) -> modal._functions._FunctionCall: ...
+async def _spawn_map_helper(
+    self: modal.functions.Function, async_input_gen, kwargs={}
+) -> modal._functions._FunctionCall: ...
+def _experimental_spawn_map_sync(self, *input_iterators, kwargs={}) -> modal._functions._FunctionCall:
+    """mdmd:hidden
+    Spawn parallel execution over a set of inputs, returning as soon as the inputs are created.
+
+    Unlike `modal.Function.map`, this method does not block on completion of the remote execution but
+    returns a `modal.FunctionCall` object that can be used to poll status and retrieve results later.
+
+    Takes one iterator argument per argument in the function being mapped over.
+
+    Example:
+    ```python
+    @app.function()
+    def my_func(a, b):
+        return a ** b
+
+
+    @app.local_entrypoint()
+    def main():
+        fc = my_func.spawn_map([1, 2], [3, 4])
+    ```
+    """
+    ...
+
 async def _spawn_map_async(self, *input_iterators, kwargs={}) -> None:
     """This runs in an event loop on the main thread. It consumes inputs from the input iterators and creates async
     function calls for each.
@@ -260,10 +380,12 @@ class _MapItemContext:
         input: modal_proto.api_pb2.FunctionInput,
         retry_manager: modal.retries.RetryManager,
         sync_client_retries_enabled: bool,
+        is_input_plane_instance: bool = False,
     ):
         """Initialize self.  See help(type(self)) for accurate signature."""
         ...
 
+    def handle_map_start_or_continue_response(self, attempt_token: str): ...
     def handle_put_inputs_response(self, item: modal_proto.api_pb2.FunctionPutInputsResponseItem): ...
     async def handle_get_outputs_response(
         self,
@@ -279,7 +401,9 @@ class _MapItemContext:
         ...
 
     async def prepare_item_for_retry(self) -> modal_proto.api_pb2.FunctionRetryInputsItem: ...
+    def set_retry_policy(self, retry_policy: modal_proto.api_pb2.FunctionRetryPolicy): ...
     def handle_retry_response(self, input_jwt: str): ...
+    async def create_map_start_or_continue_item(self, idx: int) -> modal_proto.api_pb2.MapStartOrContinueItem: ...
 
 class _MapItemsManager:
     def __init__(
@@ -289,22 +413,32 @@ class _MapItemsManager:
         retry_queue: modal._utils.async_utils.TimestampPriorityQueue,
         sync_client_retries_enabled: bool,
         max_inputs_outstanding: int,
+        is_input_plane_instance: bool = False,
     ):
         """Initialize self.  See help(type(self)) for accurate signature."""
         ...
 
+    def set_retry_policy(self, retry_policy: modal_proto.api_pb2.FunctionRetryPolicy): ...
     async def add_items(self, items: list[modal_proto.api_pb2.FunctionPutInputsItem]): ...
+    async def add_items_inputplane(self, items: list[modal_proto.api_pb2.MapStartOrContinueItem]): ...
     async def prepare_items_for_retry(
         self, retriable_idxs: list[int]
     ) -> list[modal_proto.api_pb2.FunctionRetryInputsItem]: ...
+    def update_items_retry_policy(self, retry_policy: modal_proto.api_pb2.FunctionRetryPolicy): ...
     def get_input_jwts_waiting_for_output(self) -> list[str]:
         """Returns a list of input_jwts for inputs that are waiting for output."""
         ...
 
+    def get_input_idxs_waiting_for_output(self) -> list[tuple[int, str]]:
+        """Returns a list of input_idxs for inputs that are waiting for output."""
+        ...
+
     def _remove_item(self, item_idx: int): ...
     def get_item_context(self, item_idx: int) -> _MapItemContext: ...
+    def handle_put_continue_response(self, items: list[tuple[int, str]]): ...
     def handle_put_inputs_response(self, items: list[modal_proto.api_pb2.FunctionPutInputsResponseItem]): ...
     def handle_retry_response(self, input_jwts: list[str]): ...
+    async def handle_check_inputs_response(self, response: list[tuple[int, bool]]): ...
     async def handle_get_outputs_response(
         self, item: modal_proto.api_pb2.FunctionGetOutputsItem, now_seconds: int
     ) -> _OutputType: ...

modal/partial_function.pyi

@@ -329,7 +329,10 @@ def batched(
     ...
 
 def concurrent(
-    _warn_parentheses_missing=None, *, max_inputs: int, target_inputs: typing.Optional[int] = None
+    _warn_parentheses_missing=None,
+    *,
+    max_inputs: typing.Optional[int] = None,
+    target_inputs: typing.Optional[int] = None,
 ) -> collections.abc.Callable[
     [
         typing.Union[

modal/proxy.py

@@ -3,9 +3,11 @@ from typing import Optional
 
 from modal_proto import api_pb2
 
-from ._object import _get_environment_name, _Object
+from ._load_context import LoadContext
+from ._object import _Object
 from ._resolver import Resolver
 from ._utils.async_utils import synchronize_api
+from .client import _Client
 
 
 class _Proxy(_Object, type_prefix="pr"):
@@ -20,6 +22,7 @@ class _Proxy(_Object, type_prefix="pr"):
         name: str,
         *,
         environment_name: Optional[str] = None,
+        client: Optional[_Client] = None,
     ) -> "_Proxy":
         """Reference a Proxy by its name.
 
@@ -28,15 +31,21 @@ class _Proxy(_Object, type_prefix="pr"):
 
         """
 
-        async def _load(self: _Proxy, resolver: Resolver, existing_object_id: Optional[str]):
+        async def _load(self: _Proxy, resolver: Resolver, load_context: LoadContext, existing_object_id: Optional[str]):
             req = api_pb2.ProxyGetRequest(
                 name=name,
-                environment_name=_get_environment_name(environment_name, resolver),
+                environment_name=load_context.environment_name,
             )
-            response: api_pb2.ProxyGetResponse = await resolver.client.stub.ProxyGet(req)
-            self._hydrate(response.proxy.proxy_id, resolver.client, None)
-
-        return _Proxy._from_loader(_load, "Proxy()", is_another_app=True)
+            response: api_pb2.ProxyGetResponse = await load_context.client.stub.ProxyGet(req)
+            self._hydrate(response.proxy.proxy_id, load_context.client, None)
+
+        rep = _Proxy._repr(name, environment_name)
+        return _Proxy._from_loader(
+            _load,
+            rep,
+            is_another_app=True,
+            load_context_overrides=LoadContext(client=client, environment_name=environment_name),
+        )
 
 
 Proxy = synchronize_api(_Proxy, target_module=__name__)

modal/proxy.pyi

@@ -1,4 +1,5 @@
 import modal._object
+import modal.client
 import modal.object
 import typing
 
@@ -9,7 +10,12 @@ class _Proxy(modal._object._Object):
     a database. See [the guide](https://modal.com/docs/guide/proxy-ips) for more information.
     """
     @staticmethod
-    def from_name(name: str, *, environment_name: typing.Optional[str] = None) -> _Proxy:
+    def from_name(
+        name: str,
+        *,
+        environment_name: typing.Optional[str] = None,
+        client: typing.Optional[modal.client._Client] = None,
+    ) -> _Proxy:
         """Reference a Proxy by its name.
 
         In contrast to most other Modal objects, new Proxy objects must be
@@ -28,7 +34,9 @@ class Proxy(modal.object.Object):
         ...
 
     @staticmethod
-    def from_name(name: str, *, environment_name: typing.Optional[str] = None) -> Proxy:
+    def from_name(
+        name: str, *, environment_name: typing.Optional[str] = None, client: typing.Optional[modal.client.Client] = None
+    ) -> Proxy:
         """Reference a Proxy by its name.
 
         In contrast to most other Modal objects, new Proxy objects must be