modal 0.76.5.dev0__py3-none-any.whl → 0.76.5.dev2__py3-none-any.whl

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.dev2",
     ): ...
     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.dev2",
     ): ...
     def is_closed(self) -> bool: ...
     @property

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/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/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.dist-info → modal-0.76.5.dev2.dist-info}/METADATA

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

{modal-0.76.5.dev0.dist-info → modal-0.76.5.dev2.dist-info}/RECORD

@@ -22,7 +22,7 @@ modal/app.py,sha256=xojuGZv4LaQwZU5ntj7WbmMjeNuB9Gll8Mzqe2LyiEs,51323
 modal/app.pyi,sha256=zNwR1_2LpmQc9AhemuAeVdk90XNYDw9keOkXAwAATeA,28732
 modal/call_graph.py,sha256=1g2DGcMIJvRy-xKicuf63IVE98gJSnQsr8R_NVMptNc,2581
 modal/client.py,sha256=o-aQThHpvDHUzg_kUafyhWzACViUBhY2WLZ2EitnSHA,16787
-modal/client.pyi,sha256=O0lUvA3yBiRBDelnrS2Jy-Sf6FGo_mdWVqC-NHruCHY,8459
+modal/client.pyi,sha256=D97tNxHcJxjkNMnvLaU5ACI1KmZrSmU3FEGvBsISZUo,8459
 modal/cloud_bucket_mount.py,sha256=YOe9nnvSr4ZbeCn587d7_VhE9IioZYRvF9VYQTQux08,5914
 modal/cloud_bucket_mount.pyi,sha256=30T3K1a89l6wzmEJ_J9iWv9SknoGqaZDx59Xs-ZQcmk,1607
 modal/cls.py,sha256=LZMQdFZ06LpbLDbsCJknniU-393Jb44E1lqveLVM8F8,38365
@@ -39,7 +39,7 @@ modal/file_io.py,sha256=lcMs_E9Xfm0YX1t9U2wNIBPnqHRxmImqjLW1GHqVmyg,20945
 modal/file_io.pyi,sha256=oB7x-rKq7bmm8cA7Z7W9C9yeko7KK9m9i5GidFnkGK4,9569
 modal/file_pattern_matcher.py,sha256=wov-otB5M1oTdrYDtR2_VgacYin2srdtAP4McA1Cqzw,6516
 modal/functions.py,sha256=kcNHvqeGBxPI7Cgd57NIBBghkfbeFJzXO44WW0jSmao,325
-modal/functions.pyi,sha256=3kHFXeXV0YYg0w1hmBqSV4k7djmjU9qfrmUyURlp8lE,16993
+modal/functions.pyi,sha256=0RGY6ZEkaHZcxhKrY_DnwYew9vDIK7hW8BY0LFjm2GM,17001
 modal/gpu.py,sha256=Kbhs_u49FaC2Zi0TjCdrpstpRtT5eZgecynmQi5IZVE,6752
 modal/image.py,sha256=lg3XxIWNYV8je88oEPbihzSEq_9gumc0NLbzZLAhm74,92807
 modal/image.pyi,sha256=MDq7tNJevElK78VxFYrZRe_00kz9gPdg98MN5c6fFoE,25644
@@ -52,8 +52,8 @@ modal/network_file_system.pyi,sha256=58DiUqHGlARmI3cz-Yo7IFObKKFIiGh5UIU5JxGNFfc
 modal/object.py,sha256=bTeskuY8JFrESjU4_UL_nTwYlBQdOLmVaOX3X6EMxsg,164
 modal/object.pyi,sha256=Nc6fCW8ViC8YQPbtJav9KNDCW296-VimRUh-v3AaaYY,5674
 modal/output.py,sha256=q4T9uHduunj4NwY-YSwkHGgjZlCXMuJbfQ5UFaAGRAc,1968
-modal/parallel_map.py,sha256=05ynu1N4v8tySedL1wd07de0Fpp7BD0rRzakhNd07Wg,35652
-modal/parallel_map.pyi,sha256=kwggW2Vqnarlr8yk7e7H-8KsLB2GEBUs4OrRz_tUBa0,5883
+modal/parallel_map.py,sha256=zU2zL8_9PmmNC9Ny2GB7K2_HbAdPU7RiVLN0GtzaDls,35923
+modal/parallel_map.pyi,sha256=mhYGQmufQEJbjNrX7vNhBS2gUdfBrpmuWNUHth_Dz6U,6140
 modal/partial_function.py,sha256=SwuAAj2wj4SO6F6nkSnwNZrczEmm9w9YdlQTHh6hr04,1195
 modal/partial_function.pyi,sha256=NFWz1aCAs2B3-GnPf1cTatWRZOLnYpFKCnjP_X9iNRs,6411
 modal/proxy.py,sha256=XEjIHzZvbD3UW4YWyDzbDuNFq6hDUxyPPxupl2qwULY,1429
@@ -146,7 +146,7 @@ modal/requirements/2024.10.txt,sha256=qD-5cVIVM9wXesJ6JC89Ew-3m2KjEElUz3jaw_MddR
 modal/requirements/PREVIEW.txt,sha256=qD-5cVIVM9wXesJ6JC89Ew-3m2KjEElUz3jaw_MddRo,296
 modal/requirements/README.md,sha256=9tK76KP0Uph7O0M5oUgsSwEZDj5y-dcUPsnpR0Sc-Ik,854
 modal/requirements/base-images.json,sha256=57vMSqzMbLBxw5tFWSaMiIkkVEps4JfX5PAtXGnkS4U,740
-modal-0.76.5.dev0.dist-info/licenses/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+modal-0.76.5.dev2.dist-info/licenses/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
 modal_docs/__init__.py,sha256=svYKtV8HDwDCN86zbdWqyq5T8sMdGDj0PVlzc2tIxDM,28
 modal_docs/gen_cli_docs.py,sha256=c1yfBS_x--gL5bs0N4ihMwqwX8l3IBWSkBAKNNIi6bQ,3801
 modal_docs/gen_reference_docs.py,sha256=d_CQUGQ0rfw28u75I2mov9AlS773z9rG40-yq5o7g2U,6359
@@ -169,10 +169,10 @@ modal_proto/options_pb2.pyi,sha256=l7DBrbLO7q3Ir-XDkWsajm0d0TQqqrfuX54i4BMpdQg,1
 modal_proto/options_pb2_grpc.py,sha256=1oboBPFxaTEXt9Aw7EAj8gXHDCNMhZD2VXqocC9l_gk,159
 modal_proto/options_pb2_grpc.pyi,sha256=CImmhxHsYnF09iENPoe8S4J-n93jtgUYD2JPAc0yJSI,247
 modal_proto/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-modal_version/__init__.py,sha256=B11MnICRYZ2rXs9Mave34yDLKflMjf5Mn-_uNfbft1E,121
+modal_version/__init__.py,sha256=VIAUg5xEzI23zthNgRPMiBYG22LeScIAt531W0EPpVY,121
 modal_version/__main__.py,sha256=2FO0yYQQwDTh6udt1h-cBnGd1c4ZyHnHSI4BksxzVac,105
-modal-0.76.5.dev0.dist-info/METADATA,sha256=PUoRb0yq3ocGOoxnIi53F06mF8LJT_ZLrDCLyVqUVDs,2455
-modal-0.76.5.dev0.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
-modal-0.76.5.dev0.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
-modal-0.76.5.dev0.dist-info/top_level.txt,sha256=4BWzoKYREKUZ5iyPzZpjqx4G8uB5TWxXPDwibLcVa7k,43
-modal-0.76.5.dev0.dist-info/RECORD,,
+modal-0.76.5.dev2.dist-info/METADATA,sha256=d9GxdUEVEv74eA-10fLKmVKR_i7ihpQynkywXJim8oA,2455
+modal-0.76.5.dev2.dist-info/WHEEL,sha256=1tXe9gY0PYatrMPMDd6jXqjfpz_B-Wqm32CPfRC58XU,91
+modal-0.76.5.dev2.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
+modal-0.76.5.dev2.dist-info/top_level.txt,sha256=4BWzoKYREKUZ5iyPzZpjqx4G8uB5TWxXPDwibLcVa7k,43
+modal-0.76.5.dev2.dist-info/RECORD,,

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.dev2"