modal 0.76.5.dev0__tar.gz → 0.76.5.dev4__tar.gz

{modal-0.76.5.dev0 → modal-0.76.5.dev4}/PKG-INFO

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

{modal-0.76.5.dev0 → modal-0.76.5.dev4}/modal/client.pyi

@@ -31,7 +31,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "0.76.5.dev0",
+        version: str = "0.76.5.dev4",
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -94,7 +94,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "0.76.5.dev0",
+        version: str = "0.76.5.dev4",
     ): ...
     def is_closed(self) -> bool: ...
     @property

{modal-0.76.5.dev0 → modal-0.76.5.dev4}/modal/functions.pyi

@@ -234,11 +234,11 @@ class Function(
 
     _call_generator_nowait: ___call_generator_nowait_spec[typing_extensions.Self]
 
-    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER: ...
         async def aio(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> ReturnType_INNER: ...
 
-    remote: __remote_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
+    remote: __remote_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
 
     class __remote_gen_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, /, *args, **kwargs) -> typing.Generator[typing.Any, None, None]: ...
@@ -253,12 +253,12 @@ class Function(
         self, *args: modal._functions.P.args, **kwargs: modal._functions.P.kwargs
     ) -> modal._functions.OriginalReturnType: ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
         async def aio(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
 
     _experimental_spawn: ___experimental_spawn_spec[
-        modal._functions.ReturnType, modal._functions.P, typing_extensions.Self
+        modal._functions.P, modal._functions.ReturnType, typing_extensions.Self
     ]
 
     class ___spawn_map_inner_spec(typing_extensions.Protocol[P_INNER, SUPERSELF]):
@@ -267,11 +267,11 @@ class Function(
 
     _spawn_map_inner: ___spawn_map_inner_spec[modal._functions.P, typing_extensions.Self]
 
-    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER, SUPERSELF]):
+    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER, SUPERSELF]):
         def __call__(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
         async def aio(self, /, *args: P_INNER.args, **kwargs: P_INNER.kwargs) -> FunctionCall[ReturnType_INNER]: ...
 
-    spawn: __spawn_spec[modal._functions.ReturnType, modal._functions.P, typing_extensions.Self]
+    spawn: __spawn_spec[modal._functions.P, modal._functions.ReturnType, typing_extensions.Self]
 
     def get_raw_f(self) -> collections.abc.Callable[..., typing.Any]: ...
 
@@ -328,7 +328,7 @@ class Function(
 
     class __for_each_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, /, *input_iterators, kwargs={}, ignore_exceptions: bool = False): ...
-        async def aio(self, /, *input_iterators, kwargs={}, ignore_exceptions: bool = False): ...
+        async def aio(self, /, *input_iterators, kwargs={}, ignore_exceptions: bool = False) -> None: ...
 
     for_each: __for_each_spec[typing_extensions.Self]
 

{modal-0.76.5.dev0 → modal-0.76.5.dev4}/modal/parallel_map.py

@@ -381,6 +381,94 @@ async def _map_invocation(
     await log_debug_stats_task
 
 
+async def _map_helper(
+    self: "modal.functions.Function",
+    async_input_gen: typing.AsyncGenerator[Any, None],
+    kwargs={},  # any extra keyword arguments for the function
+    order_outputs: bool = True,  # return outputs in order
+    return_exceptions: bool = False,  # propagate exceptions (False) or aggregate them in the results list (True)
+) -> typing.AsyncGenerator[Any, None]:
+    """Core implementation that supports `_map_async()`, `_starmap_async()` and `_for_each_async()`.
+
+    Runs in an event loop on the main thread. Concurrently feeds new input to the input queue and yields available
+    outputs to the caller.
+
+    Note that since the iterator(s) can block, it's a bit opaque how often the event
+    loop decides to get a new input vs how often it will emit a new output.
+
+    We could make this explicit as an improvement or even let users decide what they
+    prefer: throughput (prioritize queueing inputs) or latency (prioritize yielding results)
+    """
+
+    raw_input_queue: Any = SynchronizedQueue()  # type: ignore
+    raw_input_queue.init()
+
+    async def feed_queue():
+        async with aclosing(async_input_gen) as streamer:
+            async for args in streamer:
+                await raw_input_queue.put.aio((args, kwargs))
+        await raw_input_queue.put.aio(None)  # end-of-input sentinel
+        if False:
+            # make this a never yielding generator so we can async_merge it below
+            # this is important so any exception raised in feed_queue will be propagated
+            yield
+
+    # note that `map()`, `map.aio()`, `starmap()`, `starmap.aio()`, `for_each()`, `for_each.aio()` are not
+    # synchronicity-wrapped, since they accept executable code in the form of iterators that we don't want to run inside
+    # the synchronicity thread. Instead, we delegate to `._map()` with a safer Queue as input.
+    async with aclosing(
+        async_merge(self._map.aio(raw_input_queue, order_outputs, return_exceptions), feed_queue())
+    ) as map_output_stream:
+        async for output in map_output_stream:
+            yield output
+
+
+@warn_if_generator_is_not_consumed(function_name="Function.map.aio")
+async def _map_async(
+    self: "modal.functions.Function",
+    *input_iterators: typing.Union[
+        typing.Iterable[Any], typing.AsyncIterable[Any]
+    ],  # one input iterator per argument in the mapped-over function/generator
+    kwargs={},  # any extra keyword arguments for the function
+    order_outputs: bool = True,  # return outputs in order
+    return_exceptions: bool = False,  # propagate exceptions (False) or aggregate them in the results list (True)
+) -> typing.AsyncGenerator[Any, None]:
+    async_input_gen = async_zip(*[sync_or_async_iter(it) for it in input_iterators])
+    async for output in _map_helper(
+        self, async_input_gen, kwargs=kwargs, order_outputs=order_outputs, return_exceptions=return_exceptions
+    ):
+        yield output
+
+
+@warn_if_generator_is_not_consumed(function_name="Function.starmap.aio")
+async def _starmap_async(
+    self,
+    input_iterator: typing.Union[typing.Iterable[typing.Sequence[Any]], typing.AsyncIterable[typing.Sequence[Any]]],
+    *,
+    kwargs={},
+    order_outputs: bool = True,
+    return_exceptions: bool = False,
+) -> typing.AsyncIterable[Any]:
+    async for output in _map_helper(
+        self,
+        sync_or_async_iter(input_iterator),
+        kwargs=kwargs,
+        order_outputs=order_outputs,
+        return_exceptions=return_exceptions,
+    ):
+        yield output
+
+
+async def _for_each_async(self, *input_iterators, kwargs={}, ignore_exceptions: bool = False) -> None:
+    # TODO(erikbern): it would be better if this is more like a map_spawn that immediately exits
+    # rather than iterating over the result
+    async_input_gen = async_zip(*[sync_or_async_iter(it) for it in input_iterators])
+    async for _ in _map_helper(
+        self, async_input_gen, kwargs=kwargs, order_outputs=False, return_exceptions=ignore_exceptions
+    ):
+        pass
+
+
 @warn_if_generator_is_not_consumed(function_name="Function.map")
 def _map_sync(
     self,
@@ -431,60 +519,13 @@ def _map_sync(
             self, *input_iterators, kwargs=kwargs, order_outputs=order_outputs, return_exceptions=return_exceptions
         ),
         nested_async_message=(
-            "You can't iter(Function.map()) or Function.for_each() from an async function. "
-            "Use async for ... Function.map.aio() or Function.for_each.aio() instead."
+            "You can't iter(Function.map()) from an async function. Use async for ... in Function.map.aio() instead."
         ),
     )
 
 
-@warn_if_generator_is_not_consumed(function_name="Function.map.aio")
-async def _map_async(
-    self: "modal.functions.Function",
-    *input_iterators: typing.Union[
-        typing.Iterable[Any], typing.AsyncIterable[Any]
-    ],  # one input iterator per argument in the mapped-over function/generator
-    kwargs={},  # any extra keyword arguments for the function
-    order_outputs: bool = True,  # return outputs in order
-    return_exceptions: bool = False,  # propagate exceptions (False) or aggregate them in the results list (True)
-) -> typing.AsyncGenerator[Any, None]:
-    """mdmd:hidden
-    This runs in an event loop on the main thread
-
-    It concurrently feeds new input to the input queue and yields available outputs
-    to the caller.
-    Note that since the iterator(s) can block, it's a bit opaque how often the event
-    loop decides to get a new input vs how often it will emit a new output.
-    We could make this explicit as an improvement or even let users decide what they
-    prefer: throughput (prioritize queueing inputs) or latency (prioritize yielding results)
-    """
-    raw_input_queue: Any = SynchronizedQueue()  # type: ignore
-    raw_input_queue.init()
-
-    async def feed_queue():
-        # This runs in a main thread event loop, so it doesn't block the synchronizer loop
-        async with aclosing(async_zip(*[sync_or_async_iter(it) for it in input_iterators])) as streamer:
-            async for args in streamer:
-                await raw_input_queue.put.aio((args, kwargs))
-        await raw_input_queue.put.aio(None)  # end-of-input sentinel
-        if False:
-            # make this a never yielding generator so we can async_merge it below
-            # this is important so any exception raised in feed_queue will be propagated
-            yield
-
-    # note that `map()` and `map.aio()` are not synchronicity-wrapped, since
-    # they accept executable code in the form of
-    # iterators that we don't want to run inside the synchronicity thread.
-    # Instead, we delegate to `._map()` with a safer Queue as input
-    async with aclosing(
-        async_merge(self._map.aio(raw_input_queue, order_outputs, return_exceptions), feed_queue())
-    ) as map_output_stream:
-        async for output in map_output_stream:
-            yield output
-
-
 async def _spawn_map_async(self, *input_iterators, kwargs={}) -> None:
-    """mdmd:hidden
-    This runs in an event loop on the main thread. It consumes inputs from the input iterators and creates async
+    """This runs in an event loop on the main thread. It consumes inputs from the input iterators and creates async
     function calls for each.
     """
 
@@ -538,47 +579,16 @@ def _for_each_sync(self, *input_iterators, kwargs={}, ignore_exceptions: bool =
     Convenient alias for `.map()` in cases where the function just needs to be called.
     as the caller doesn't have to consume the generator to process the inputs.
     """
-    # TODO(erikbern): it would be better if this is more like a map_spawn that immediately exits
-    # rather than iterating over the result
-    for _ in self.map(*input_iterators, kwargs=kwargs, order_outputs=False, return_exceptions=ignore_exceptions):
-        pass
-
 
-async def _for_each_async(self, *input_iterators, kwargs={}, ignore_exceptions: bool = False):
-    async for _ in self.map.aio(  # type: ignore
-        *input_iterators, kwargs=kwargs, order_outputs=False, return_exceptions=ignore_exceptions
-    ):
-        pass
+    return run_coroutine_in_temporary_event_loop(
+        _for_each_async(self, *input_iterators, kwargs=kwargs, ignore_exceptions=ignore_exceptions),
+        nested_async_message=(
+            "You can't run `Function.for_each()` from an async function. Use `await Function.for_each.aio()` instead."
+        ),
+    )
 
 
 @warn_if_generator_is_not_consumed(function_name="Function.starmap")
-async def _starmap_async(
-    self,
-    input_iterator: typing.Union[typing.Iterable[typing.Sequence[Any]], typing.AsyncIterable[typing.Sequence[Any]]],
-    *,
-    kwargs={},
-    order_outputs: bool = True,
-    return_exceptions: bool = False,
-) -> typing.AsyncIterable[Any]:
-    raw_input_queue: Any = SynchronizedQueue()  # type: ignore
-    raw_input_queue.init()
-
-    async def feed_queue():
-        # This runs in a main thread event loop, so it doesn't block the synchronizer loop
-        async with aclosing(sync_or_async_iter(input_iterator)) as streamer:
-            async for args in streamer:
-                await raw_input_queue.put.aio((args, kwargs))
-        await raw_input_queue.put.aio(None)  # end-of-input sentinel
-
-    feed_input_task = asyncio.create_task(feed_queue())
-    try:
-        async for output in self._map.aio(raw_input_queue, order_outputs, return_exceptions):  # type: ignore[reportFunctionMemberAccess]
-            yield output
-    finally:
-        feed_input_task.cancel()  # should only be needed in case of exceptions
-
-
-@warn_if_generator_is_not_consumed(function_name="Function.starmap.aio")
 def _starmap_sync(
     self,
     input_iterator: typing.Iterable[typing.Sequence[Any]],
@@ -608,8 +618,8 @@ def _starmap_sync(
             self, input_iterator, kwargs=kwargs, order_outputs=order_outputs, return_exceptions=return_exceptions
         ),
         nested_async_message=(
-            "You can't run Function.map() or Function.for_each() from an async function. "
-            "Use Function.map.aio()/Function.for_each.aio() instead."
+            "You can't `iter(Function.starmap())` from an async function. "
+            "Use `async for ... in Function.starmap.aio()` instead."
         ),
     )
 

{modal-0.76.5.dev0 → modal-0.76.5.dev4}/modal/parallel_map.pyi

@@ -55,9 +55,13 @@ def _map_invocation(
     count_update_callback: typing.Optional[collections.abc.Callable[[int, int], None]],
     function_call_invocation_type: int,
 ): ...
-def _map_sync(
-    self, *input_iterators, kwargs={}, order_outputs: bool = True, return_exceptions: bool = False
-) -> modal._utils.async_utils.AsyncOrSyncIterable: ...
+def _map_helper(
+    self: modal.functions.Function,
+    async_input_gen: typing.AsyncGenerator[typing.Any, None],
+    kwargs={},
+    order_outputs: bool = True,
+    return_exceptions: bool = False,
+) -> typing.AsyncGenerator[typing.Any, None]: ...
 def _map_async(
     self: modal.functions.Function,
     *input_iterators: typing.Union[typing.Iterable[typing.Any], typing.AsyncIterable[typing.Any]],
@@ -65,10 +69,6 @@ def _map_async(
     order_outputs: bool = True,
     return_exceptions: bool = False,
 ) -> typing.AsyncGenerator[typing.Any, None]: ...
-async def _spawn_map_async(self, *input_iterators, kwargs={}) -> None: ...
-def _spawn_map_sync(self, *input_iterators, kwargs={}) -> None: ...
-def _for_each_sync(self, *input_iterators, kwargs={}, ignore_exceptions: bool = False): ...
-async def _for_each_async(self, *input_iterators, kwargs={}, ignore_exceptions: bool = False): ...
 def _starmap_async(
     self,
     input_iterator: typing.Union[
@@ -79,6 +79,13 @@ def _starmap_async(
     order_outputs: bool = True,
     return_exceptions: bool = False,
 ) -> typing.AsyncIterable[typing.Any]: ...
+async def _for_each_async(self, *input_iterators, kwargs={}, ignore_exceptions: bool = False) -> None: ...
+def _map_sync(
+    self, *input_iterators, kwargs={}, order_outputs: bool = True, return_exceptions: bool = False
+) -> modal._utils.async_utils.AsyncOrSyncIterable: ...
+async def _spawn_map_async(self, *input_iterators, kwargs={}) -> None: ...
+def _spawn_map_sync(self, *input_iterators, kwargs={}) -> None: ...
+def _for_each_sync(self, *input_iterators, kwargs={}, ignore_exceptions: bool = False): ...
 def _starmap_sync(
     self,
     input_iterator: typing.Iterable[typing.Sequence[typing.Any]],

{modal-0.76.5.dev0 → modal-0.76.5.dev4}/modal.egg-info/PKG-INFO

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

{modal-0.76.5.dev0 → modal-0.76.5.dev4}/modal_version/__init__.py

@@ -1,4 +1,4 @@
 # Copyright Modal Labs 2025
 """Supplies the current version of the modal client library."""
 
-__version__ = "0.76.5.dev0"
+__version__ = "0.76.5.dev4"