modal 1.0.5.dev27__tar.gz → 1.0.5.dev30__tar.gz

{modal-1.0.5.dev27 → modal-1.0.5.dev30}/PKG-INFO

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

{modal-1.0.5.dev27 → modal-1.0.5.dev30}/modal/_serialization.py

@@ -6,6 +6,8 @@ import typing
 from inspect import Parameter
 from typing import Any
 
+import google.protobuf.message
+
 from modal._utils.async_utils import synchronizer
 from modal_proto import api_pb2
 
@@ -470,10 +472,31 @@ def deserialize_params(serialized_params: bytes, function_def: api_pb2.Function,
         api_pb2.ClassParameterInfo.PARAM_SERIALIZATION_FORMAT_PICKLE,
     ):
         # legacy serialization format - pickle of `(args, kwargs)` w/ support for modal object arguments
-        param_args, param_kwargs = deserialize(serialized_params, _client)
+        try:
+            param_args, param_kwargs = deserialize(serialized_params, _client)
+        except DeserializationError as original_exc:
+            # Fallback in case of proto -> pickle downgrades of a parameter serialization format
+            # I.e. FunctionBindParams binding proto serialized params to a function defintion
+            # that now assumes pickled data according to class_parameter_info
+            param_args = ()
+            try:
+                param_kwargs = deserialize_proto_params(serialized_params)
+            except Exception:
+                raise original_exc
+
     elif function_def.class_parameter_info.format == api_pb2.ClassParameterInfo.PARAM_SERIALIZATION_FORMAT_PROTO:
         param_args = ()  # we use kwargs only for our implicit constructors
-        param_kwargs = deserialize_proto_params(serialized_params)
+        try:
+            param_kwargs = deserialize_proto_params(serialized_params)
+        except google.protobuf.message.DecodeError as original_exc:
+            # Fallback in case of pickle -> proto upgrades of a parameter serialization format
+            # I.e. FunctionBindParams binding pickle serialized params to a function defintion
+            # that now assumes proto data according to class_parameter_info
+            try:
+                param_args, param_kwargs = deserialize(serialized_params, _client)
+            except Exception:
+                raise original_exc
+
     else:
         raise ExecutionError(
             f"Unknown class parameter serialization format: {function_def.class_parameter_info.format}"

{modal-1.0.5.dev27 → modal-1.0.5.dev30}/modal/client.pyi

@@ -31,7 +31,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.0.5.dev27",
+        version: str = "1.0.5.dev30",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -160,7 +160,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.0.5.dev27",
+        version: str = "1.0.5.dev30",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.0.5.dev27 → modal-1.0.5.dev30}/modal/functions.pyi

@@ -428,7 +428,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."""
             ...
@@ -437,7 +437,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]:
@@ -464,7 +464,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.
 
@@ -488,7 +488,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]):
@@ -497,7 +497,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.
 
@@ -518,7 +518,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."""

{modal-1.0.5.dev27 → modal-1.0.5.dev30}/modal/parallel_map.py

@@ -1,6 +1,7 @@
 # Copyright Modal Labs 2024
 import asyncio
 import enum
+import inspect
 import time
 import typing
 from asyncio import FIRST_COMPLETED
@@ -27,6 +28,7 @@ from modal._utils.async_utils import (
     warn_if_generator_is_not_consumed,
 )
 from modal._utils.blob_utils import BLOB_MAX_PARALLELISM
+from modal._utils.deprecation import deprecation_warning
 from modal._utils.function_utils import (
     ATTEMPT_TIMEOUT_GRACE_PERIOD,
     OUTPUTS_TIMEOUT,
@@ -409,7 +411,7 @@ async def _map_invocation(
         async_merge(drain_input_generator(), pump_inputs(), poll_outputs(), retry_inputs())
     ) as streamer:
         async for response in streamer:
-            if response is not None:
+            if response is not None:  # type: ignore[unreachable]
                 yield response.value
     log_debug_stats_task.cancel()
     await log_debug_stats_task
@@ -434,7 +436,6 @@ async def _map_helper(
     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
     await raw_input_queue.init.aio()
 
@@ -460,6 +461,33 @@ async def _map_helper(
             yield output
 
 
+def _maybe_warn_about_exceptions(func_name: str, return_exceptions: bool, wrap_returned_exceptions: bool):
+    if return_exceptions and wrap_returned_exceptions:
+        deprecation_warning(
+            (2025, 6, 27),
+            (
+                f"Function.{func_name} currently leaks an internal exception wrapping type "
+                "(modal.exceptions.UserCodeException) when `return_exceptions=True` is set. "
+                "In the future, this will change, and the underlying exception will be returned directly.\n"
+                "To opt into the future behavior and silence this warning, add `wrap_returned_exceptions=False`:\n\n"
+                f"    f.{func_name}(..., return_exceptions=True, wrap_returned_exceptions=False)"
+            ),
+        )
+
+
+def _invoked_from_sync_wrapper() -> bool:
+    """Check whether the calling function was called from a sync wrapper."""
+    # This is temporary: we only need it to avoind double-firing the wrap_returned_exceptions warning.
+    # (We don't want to push the warning lower in the stack beacuse then we can't attribute to the user's code.)
+    try:
+        frame = inspect.currentframe()
+        caller_function_name = frame.f_back.f_back.f_code.co_name
+        # Embeds some assumptions about how the current calling stack works, but this is just temporary.
+        return caller_function_name == "asend"
+    except Exception:
+        return False
+
+
 @warn_if_generator_is_not_consumed(function_name="Function.map.aio")
 async def _map_async(
     self: "modal.functions.Function",
@@ -471,6 +499,8 @@ async def _map_async(
     return_exceptions: bool = False,  # propagate exceptions (False) or aggregate them in the results list (True)
     wrap_returned_exceptions: bool = True,  # wrap returned exceptions in modal.exception.UserCodeException
 ) -> typing.AsyncGenerator[Any, None]:
+    if not _invoked_from_sync_wrapper():
+        _maybe_warn_about_exceptions("map.aio", return_exceptions, wrap_returned_exceptions)
     async_input_gen = async_zip(*[sync_or_async_iter(it) for it in input_iterators])
     async for output in _map_helper(
         self,
@@ -493,6 +523,8 @@ async def _starmap_async(
     return_exceptions: bool = False,
     wrap_returned_exceptions: bool = True,
 ) -> typing.AsyncIterable[Any]:
+    if not _invoked_from_sync_wrapper():
+        _maybe_warn_about_exceptions("starmap.aio", return_exceptions, wrap_returned_exceptions)
     async for output in _map_helper(
         self,
         sync_or_async_iter(input_iterator),
@@ -509,7 +541,12 @@ async def _for_each_async(self, *input_iterators, kwargs={}, ignore_exceptions:
     # 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
+        self,
+        async_input_gen,
+        kwargs=kwargs,
+        order_outputs=False,
+        return_exceptions=ignore_exceptions,
+        wrap_returned_exceptions=False,
     ):
         pass
 
@@ -559,6 +596,7 @@ def _map_sync(
         print(list(my_func.map(range(3), return_exceptions=True)))
     ```
     """
+    _maybe_warn_about_exceptions("map", return_exceptions, wrap_returned_exceptions)
 
     return AsyncOrSyncIterable(
         _map_async(
@@ -665,6 +703,7 @@ def _starmap_sync(
         assert list(my_func.starmap([(1, 2), (3, 4)])) == [3, 7]
     ```
     """
+    _maybe_warn_about_exceptions("starmap", return_exceptions, wrap_returned_exceptions)
     return AsyncOrSyncIterable(
         _starmap_async(
             self,

{modal-1.0.5.dev27 → modal-1.0.5.dev30}/modal/parallel_map.pyi

@@ -91,6 +91,11 @@ def _map_helper(
     """
     ...
 
+def _maybe_warn_about_exceptions(func_name: str, return_exceptions: bool, wrap_returned_exceptions: bool): ...
+def _invoked_from_sync_wrapper() -> bool:
+    """Check whether the calling function was called from a sync wrapper."""
+    ...
+
 def _map_async(
     self: modal.functions.Function,
     *input_iterators: typing.Union[typing.Iterable[typing.Any], typing.AsyncIterable[typing.Any]],

{modal-1.0.5.dev27 → modal-1.0.5.dev30}/modal.egg-info/PKG-INFO

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

{modal-1.0.5.dev27 → modal-1.0.5.dev30}/modal_proto/api.proto

@@ -1246,8 +1246,21 @@ message FlashContainerDeregisterRequest {
   string service_name = 1;
 }
 
+message FlashContainerListRequest {
+  string function_id = 1;
+}
+
+message FlashContainerListResponse {
+  message Container {
+    string task_id = 1;
+    string host = 2;
+    uint32 port = 3;
+  }
+  repeated Container containers = 1;
+}
+
 message FlashContainerRegisterRequest {
-  string service_name = 1;
+  string service_name = 1;  // not used?
   uint32 priority = 2;
   uint32 weight = 3;
   string host = 4;
@@ -3294,6 +3307,7 @@ service ModalClient {
 
   // Modal Flash (experimental)
   rpc FlashContainerDeregister(FlashContainerDeregisterRequest) returns (google.protobuf.Empty);
+  rpc FlashContainerList(FlashContainerListRequest) returns (FlashContainerListResponse);
   rpc FlashContainerRegister(FlashContainerRegisterRequest) returns (FlashContainerRegisterResponse);
 
   // Functions

{modal-1.0.5.dev27 → modal-1.0.5.dev30}/modal_proto/api_grpc.py

@@ -246,6 +246,10 @@ class ModalClientBase(abc.ABC):
     async def FlashContainerDeregister(self, stream: 'grpclib.server.Stream[modal_proto.api_pb2.FlashContainerDeregisterRequest, google.protobuf.empty_pb2.Empty]') -> None:
         pass
 
+    @abc.abstractmethod
+    async def FlashContainerList(self, stream: 'grpclib.server.Stream[modal_proto.api_pb2.FlashContainerListRequest, modal_proto.api_pb2.FlashContainerListResponse]') -> None:
+        pass
+
     @abc.abstractmethod
     async def FlashContainerRegister(self, stream: 'grpclib.server.Stream[modal_proto.api_pb2.FlashContainerRegisterRequest, modal_proto.api_pb2.FlashContainerRegisterResponse]') -> None:
         pass
@@ -982,6 +986,12 @@ class ModalClientBase(abc.ABC):
                 modal_proto.api_pb2.FlashContainerDeregisterRequest,
                 google.protobuf.empty_pb2.Empty,
             ),
+            '/modal.client.ModalClient/FlashContainerList': grpclib.const.Handler(
+                self.FlashContainerList,
+                grpclib.const.Cardinality.UNARY_UNARY,
+                modal_proto.api_pb2.FlashContainerListRequest,
+                modal_proto.api_pb2.FlashContainerListResponse,
+            ),
             '/modal.client.ModalClient/FlashContainerRegister': grpclib.const.Handler(
                 self.FlashContainerRegister,
                 grpclib.const.Cardinality.UNARY_UNARY,
@@ -1918,6 +1928,12 @@ class ModalClientStub:
             modal_proto.api_pb2.FlashContainerDeregisterRequest,
             google.protobuf.empty_pb2.Empty,
         )
+        self.FlashContainerList = grpclib.client.UnaryUnaryMethod(
+            channel,
+            '/modal.client.ModalClient/FlashContainerList',
+            modal_proto.api_pb2.FlashContainerListRequest,
+            modal_proto.api_pb2.FlashContainerListResponse,
+        )
         self.FlashContainerRegister = grpclib.client.UnaryUnaryMethod(
             channel,
             '/modal.client.ModalClient/FlashContainerRegister',