modal 0.66.41__py3-none-any.whl → 0.66.43__py3-none-any.whl

modal/_container_entrypoint.py

@@ -499,7 +499,7 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
             call_lifecycle_functions(event_loop, container_io_manager, list(pre_snapshot_methods.values()))
 
         # If this container is being used to create a checkpoint, checkpoint the container after
-        # global imports and innitialization. Checkpointed containers run from this point onwards.
+        # global imports and initialization. Checkpointed containers run from this point onwards.
         if is_snapshotting_function:
             container_io_manager.memory_snapshot()
 

modal/_runtime/user_code_imports.py

@@ -197,7 +197,7 @@ def get_user_class_instance(
         modal_obj: modal.cls.Obj = cls(*args, **kwargs)
         modal_obj.entered = True  # ugly but prevents .local() from triggering additional enter-logic
         # TODO: unify lifecycle logic between .local() and container_entrypoint
-        user_cls_instance = modal_obj._get_user_cls_instance()
+        user_cls_instance = modal_obj._cached_user_cls_instance()
     else:
         # undecorated class (non-global decoration or serialized)
         user_cls_instance = cls(*args, **kwargs)

modal/_utils/grpc_testing.py

@@ -52,7 +52,7 @@ def patch_mock_servicer(cls):
         ctx = InterceptionContext()
         servicer.interception_context = ctx
         yield ctx
-        ctx.assert_responses_consumed()
+        ctx._assert_responses_consumed()
         servicer.interception_context = None
 
     cls.intercept = intercept
@@ -64,7 +64,7 @@ def patch_mock_servicer(cls):
                 ctx = servicer_self.interception_context
                 if ctx:
                     intercepted_stream = await InterceptedStream(ctx, method_name, stream).initialize()
-                    custom_responder = ctx.next_custom_responder(method_name, intercepted_stream.request_message)
+                    custom_responder = ctx._next_custom_responder(method_name, intercepted_stream.request_message)
                     if custom_responder:
                         return await custom_responder(servicer_self, intercepted_stream)
                     else:
@@ -105,19 +105,23 @@ class InterceptionContext:
         self.custom_responses: Dict[str, List[Tuple[Callable[[Any], bool], List[Any]]]] = defaultdict(list)
         self.custom_defaults: Dict[str, Callable[["MockClientServicer", grpclib.server.Stream], Awaitable[None]]] = {}
 
-    def add_recv(self, method_name: str, msg):
-        self.calls.append((method_name, msg))
-
     def add_response(
         self, method_name: str, first_payload, *, request_filter: Callable[[Any], bool] = lambda req: True
     ):
-        # adds one response to a queue of responses for requests of the specified type
+        """Adds one response payload to an expected queue of responses for a method.
+
+        These responses will be used once each instead of calling the MockServicer's
+        implementation of the method.
+
+        The interception context will throw an exception on exit if not all of the added
+        responses have been consumed.
+        """
         self.custom_responses[method_name].append((request_filter, [first_payload]))
 
     def set_responder(
         self, method_name: str, responder: Callable[["MockClientServicer", grpclib.server.Stream], Awaitable[None]]
     ):
-        """Replace the default responder method. E.g.
+        """Replace the default responder from the MockClientServicer with a custom implementation
 
         ```python notest
         def custom_responder(servicer, stream):
@@ -128,11 +132,28 @@ class InterceptionContext:
             ctx.set_responder("SomeMethod", custom_responder)
         ```
 
-        Responses added via `.add_response()` take precedence.
+        Responses added via `.add_response()` take precedence over the use of this replacement
         """
         self.custom_defaults[method_name] = responder
 
-    def next_custom_responder(self, method_name, request):
+    def pop_request(self, method_name):
+        # fast forward to the next request of type method_name
+        # dropping any preceding requests if there is a match
+        # returns the payload of the request
+        for i, (_method_name, msg) in enumerate(self.calls):
+            if _method_name == method_name:
+                self.calls = self.calls[i + 1 :]
+                return msg
+
+        raise KeyError(f"No message of that type in call list: {self.calls}")
+
+    def get_requests(self, method_name: str) -> List[Any]:
+        return [msg for _method_name, msg in self.calls if _method_name == method_name]
+
+    def _add_recv(self, method_name: str, msg):
+        self.calls.append((method_name, msg))
+
+    def _next_custom_responder(self, method_name, request):
         method_responses = self.custom_responses[method_name]
         for i, (request_filter, response_messages) in enumerate(method_responses):
             try:
@@ -159,7 +180,7 @@ class InterceptionContext:
 
         return responder
 
-    def assert_responses_consumed(self):
+    def _assert_responses_consumed(self):
         unconsumed = []
         for method_name, queued_responses in self.custom_responses.items():
             unconsumed += [method_name] * len(queued_responses)
@@ -167,23 +188,9 @@ class InterceptionContext:
         if unconsumed:
             raise ResponseNotConsumed(unconsumed)
 
-    def pop_request(self, method_name):
-        # fast forward to the next request of type method_name
-        # dropping any preceding requests if there is a match
-        # returns the payload of the request
-        for i, (_method_name, msg) in enumerate(self.calls):
-            if _method_name == method_name:
-                self.calls = self.calls[i + 1 :]
-                return msg
-
-        raise KeyError(f"No message of that type in call list: {self.calls}")
-
-    def get_requests(self, method_name: str) -> List[Any]:
-        return [msg for _method_name, msg in self.calls if _method_name == method_name]
-
 
 class InterceptedStream:
-    def __init__(self, interception_context, method_name, stream):
+    def __init__(self, interception_context: InterceptionContext, method_name: str, stream):
         self.interception_context = interception_context
         self.method_name = method_name
         self.stream = stream
@@ -200,7 +207,7 @@ class InterceptedStream:
             return ret
 
         msg = await self.stream.recv_message()
-        self.interception_context.add_recv(self.method_name, msg)
+        self.interception_context._add_recv(self.method_name, msg)
         return msg
 
     async def send_message(self, msg):

modal/client.pyi

@@ -31,7 +31,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[typing.Tuple[str, str]],
-        version: str = "0.66.41",
+        version: str = "0.66.43",
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -90,7 +90,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[typing.Tuple[str, str]],
-        version: str = "0.66.41",
+        version: str = "0.66.43",
     ): ...
     def is_closed(self) -> bool: ...
     @property

modal/cls.py

@@ -113,7 +113,7 @@ class _Obj:
                 method = self._instance_service_function._bind_instance_method(class_bound_method)
                 self._method_functions[method_name] = method
         else:
-            # <v0.63 classes - bind each individual method to the new parameters
+            # looked up <v0.63 classes - bind each individual method to the new parameters
             self._instance_service_function = None
             for method_name, class_bound_method in classbound_methods.items():
                 method = class_bound_method._bind_parameters(self, from_other_workspace, options, args, kwargs)
@@ -125,12 +125,14 @@ class _Obj:
         self._user_cls = user_cls
         self._construction_args = (args, kwargs)  # used for lazy construction in case of explicit constructors
 
-    def _user_cls_instance_constr(self):
+    def _new_user_cls_instance(self):
         args, kwargs = self._construction_args
         if not _use_annotation_parameters(self._user_cls):
             # TODO(elias): deprecate this code path eventually
             user_cls_instance = self._user_cls(*args, **kwargs)
         else:
+            # ignore constructor (assumes there is no custom constructor,
+            # which is guaranteed by _use_annotation_parameters)
             # set the attributes on the class corresponding to annotations
             # with = parameter() specifications
             sig = _get_class_constructor_signature(self._user_cls)
@@ -139,6 +141,7 @@ class _Obj:
             user_cls_instance = self._user_cls.__new__(self._user_cls)  # new instance without running __init__
             user_cls_instance.__dict__.update(bound_vars.arguments)
 
+        # TODO: always use Obj instances instead of making modifications to user cls
         user_cls_instance._modal_functions = self._method_functions  # Needed for PartialFunction.__get__
         return user_cls_instance
 
@@ -163,10 +166,12 @@ class _Obj:
             )
         await self._instance_service_function.keep_warm(warm_pool_size)
 
-    def _get_user_cls_instance(self):
-        """Construct local object lazily. Used for .local() calls."""
+    def _cached_user_cls_instance(self):
+        """Get or construct the local object
+
+        Used for .local() calls and getting attributes of classes"""
         if not self._user_cls_instance:
-            self._user_cls_instance = self._user_cls_instance_constr()  # Instantiate object
+            self._user_cls_instance = self._new_user_cls_instance()  # Instantiate object
 
         return self._user_cls_instance
 
@@ -196,7 +201,7 @@ class _Obj:
     @synchronizer.nowrap
     async def aenter(self):
         if not self.entered:
-            user_cls_instance = self._get_user_cls_instance()
+            user_cls_instance = self._cached_user_cls_instance()
             if hasattr(user_cls_instance, "__aenter__"):
                 await user_cls_instance.__aenter__()
             elif hasattr(user_cls_instance, "__enter__"):
@@ -205,20 +210,22 @@ class _Obj:
 
     def __getattr__(self, k):
         if k in self._method_functions:
-            # if we know the user is accessing a method, we don't have to create an instance
-            # yet, since the user might just call `.remote()` on it which doesn't require
-            # a local instance (in case __init__ does stuff that can't locally)
+            # If we know the user is accessing a *method* and not another attribute,
+            # we don't have to create an instance of the user class yet.
+            # This is because it might just be a call to `.remote()` on it which
+            # doesn't require a local instance.
+            # As long as we have the service function or params, we can do remote calls
+            # without calling the constructor of the class in the calling context.
             return self._method_functions[k]
-        elif self._user_cls_instance_constr:
-            # if it's *not* a method
-            # TODO: To get lazy loading (from_name) of classes to work, we need to avoid
-            #  this path, otherwise local initialization will happen regardless if user
-            #  only runs .remote(), since we don't know methods for the class until we
-            #  load it
-            user_cls_instance = self._get_user_cls_instance()
-            return getattr(user_cls_instance, k)
-        else:
-            raise AttributeError(k)
+
+        # if it's *not* a method, it *might* be an attribute of the class,
+        # so we construct it and proxy the attribute
+        # TODO: To get lazy loading (from_name) of classes to work, we need to avoid
+        #  this path, otherwise local initialization will happen regardless if user
+        #  only runs .remote(), since we don't know methods for the class until we
+        #  load it
+        user_cls_instance = self._cached_user_cls_instance()
+        return getattr(user_cls_instance, k)
 
 
 Obj = synchronize_api(_Obj)

modal/cls.pyi

@@ -37,9 +37,9 @@ class _Obj:
         args,
         kwargs,
     ): ...
-    def _user_cls_instance_constr(self): ...
+    def _new_user_cls_instance(self): ...
     async def keep_warm(self, warm_pool_size: int) -> None: ...
-    def _get_user_cls_instance(self): ...
+    def _cached_user_cls_instance(self): ...
     def enter(self): ...
     @property
     def entered(self): ...
@@ -66,7 +66,7 @@ class Obj:
         kwargs,
     ): ...
     def _uses_common_service_function(self): ...
-    def _user_cls_instance_constr(self): ...
+    def _new_user_cls_instance(self): ...
 
     class __keep_warm_spec(typing_extensions.Protocol):
         def __call__(self, warm_pool_size: int) -> None: ...
@@ -74,7 +74,7 @@ class Obj:
 
     keep_warm: __keep_warm_spec
 
-    def _get_user_cls_instance(self): ...
+    def _cached_user_cls_instance(self): ...
     def enter(self): ...
     @property
     def entered(self): ...

modal/functions.py

@@ -314,7 +314,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     _tag: str
     _raw_f: Callable[..., Any]
     _build_args: dict
-    _can_use_base_function: bool = False  # whether we need to call FunctionBindParams
+
     _is_generator: Optional[bool] = None
     _cluster_size: Optional[int] = None
 
@@ -323,10 +323,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     _use_function_id: str  # The function to invoke
     _use_method_name: str = ""
 
-    # TODO (elias): remove _parent. In case of instance functions, and methods bound on those,
-    #  this references the parent class-function and is used to infer the client for lazy-loaded methods
-    _parent: Optional["_Function"] = None
-
     _class_parameter_info: Optional["api_pb2.ClassParameterInfo"] = None
     _method_handle_metadata: Optional[Dict[str, "api_pb2.FunctionHandleMetadata"]] = None
 
@@ -511,7 +507,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         fun._info = class_bound_method._info
         fun._obj = instance_service_function._obj
         fun._is_method = True
-        fun._parent = instance_service_function._parent
         fun._app = class_bound_method._app
         fun._spec = class_bound_method._spec
         return fun
@@ -1019,27 +1014,37 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         Binds a class-function to a specific instance of (init params, options) or a new workspace
         """
 
-        async def _load(self: _Function, resolver: Resolver, existing_object_id: Optional[str]):
-            if self._parent is None:
+        # In some cases, reuse the base function, i.e. not create new clones of each method or the "service function"
+        can_use_parent = len(args) + len(kwargs) == 0 and not from_other_workspace and options is None
+        parent = self
+
+        async def _load(param_bound_func: _Function, resolver: Resolver, existing_object_id: Optional[str]):
+            if parent is None:
                 raise ExecutionError("Can't find the parent class' service function")
             try:
-                identity = f"{self._parent.info.function_name} class service function"
+                identity = f"{parent.info.function_name} class service function"
             except Exception:
                 # Can't always look up the function name that way, so fall back to generic message
                 identity = "class service function for a parameterized class"
-            if not self._parent.is_hydrated:
-                if self._parent.app._running_app is None:
+            if not parent.is_hydrated:
+                if parent.app._running_app is None:
                     reason = ", because the App it is defined on is not running"
                 else:
                     reason = ""
                 raise ExecutionError(
                     f"The {identity} has not been hydrated with the metadata it needs to run on Modal{reason}."
                 )
-            assert self._parent._client.stub
+
+            assert parent._client.stub
+
+            if can_use_parent:
+                # We can end up here if parent wasn't hydrated when class was instantiated, but has been since.
+                param_bound_func._hydrate_from_other(parent)
+                return
+
             if (
-                self._parent._class_parameter_info
-                and self._parent._class_parameter_info.format
-                == api_pb2.ClassParameterInfo.PARAM_SERIALIZATION_FORMAT_PROTO
+                parent._class_parameter_info
+                and parent._class_parameter_info.format == api_pb2.ClassParameterInfo.PARAM_SERIALIZATION_FORMAT_PROTO
             ):
                 if args:
                     # TODO(elias) - We could potentially support positional args as well, if we want to?
@@ -1047,34 +1052,30 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         "Can't use positional arguments with modal.parameter-based synthetic constructors.\n"
                         "Use (<parameter_name>=value) keyword arguments when constructing classes instead."
                     )
-                serialized_params = serialize_proto_params(kwargs, self._parent._class_parameter_info.schema)
+                serialized_params = serialize_proto_params(kwargs, parent._class_parameter_info.schema)
             else:
                 serialized_params = serialize((args, kwargs))
             environment_name = _get_environment_name(None, resolver)
-            assert self._parent is not None
+            assert parent is not None
             req = api_pb2.FunctionBindParamsRequest(
-                function_id=self._parent._object_id,
+                function_id=parent._object_id,
                 serialized_params=serialized_params,
                 function_options=options,
                 environment_name=environment_name
                 or "",  # TODO: investigate shouldn't environment name always be specified here?
             )
 
-            response = await retry_transient_errors(self._parent._client.stub.FunctionBindParams, req)
-            self._hydrate(response.bound_function_id, self._parent._client, response.handle_metadata)
+            response = await retry_transient_errors(parent._client.stub.FunctionBindParams, req)
+            param_bound_func._hydrate(response.bound_function_id, parent._client, response.handle_metadata)
 
         fun: _Function = _Function._from_loader(_load, "Function(parametrized)", hydrate_lazily=True)
 
-        # In some cases, reuse the base function, i.e. not create new clones of each method or the "service function"
-        fun._can_use_base_function = len(args) + len(kwargs) == 0 and not from_other_workspace and options is None
-        if fun._can_use_base_function and self.is_hydrated:
-            # Edge case that lets us hydrate all objects right away
-            # if the instance didn't use explicit constructor arguments
-            fun._hydrate_from_other(self)
+        if can_use_parent and parent.is_hydrated:
+            # skip the resolver altogether:
+            fun._hydrate_from_other(parent)
 
         fun._info = self._info
         fun._obj = obj
-        fun._parent = self
         return fun
 
     @live_method
@@ -1265,8 +1266,10 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                 + f"or call it locally: {self._function_name}.local()"
             )
 
+    # TODO (live_method on properties is not great, since it could be blocking the event loop from async contexts)
     @property
-    def web_url(self) -> str:
+    @live_method
+    async def web_url(self) -> str:
         """URL of a Function running as a web endpoint."""
         if not self._web_url:
             raise ValueError(
@@ -1439,7 +1442,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
             return fun(*args, **kwargs)
         else:
             # This is a method on a class, so bind the self to the function
-            user_cls_instance = obj._get_user_cls_instance()
+            user_cls_instance = obj._cached_user_cls_instance()
 
             fun = info.raw_f.__get__(user_cls_instance)
 

modal/functions.pyi

@@ -120,12 +120,10 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.
     _tag: str
     _raw_f: typing.Callable[..., typing.Any]
     _build_args: dict
-    _can_use_base_function: bool
     _is_generator: typing.Optional[bool]
     _cluster_size: typing.Optional[int]
     _use_function_id: str
     _use_method_name: str
-    _parent: typing.Optional[_Function]
     _class_parameter_info: typing.Optional[modal_proto.api_pb2.ClassParameterInfo]
     _method_handle_metadata: typing.Optional[typing.Dict[str, modal_proto.api_pb2.FunctionHandleMetadata]]
 
@@ -218,7 +216,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.
     def _get_metadata(self): ...
     def _check_no_web_url(self, fn_name: str): ...
     @property
-    def web_url(self) -> str: ...
+    async def web_url(self) -> str: ...
     @property
     def is_generator(self) -> bool: ...
     @property
@@ -296,12 +294,10 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
     _tag: str
     _raw_f: typing.Callable[..., typing.Any]
     _build_args: dict
-    _can_use_base_function: bool
     _is_generator: typing.Optional[bool]
     _cluster_size: typing.Optional[int]
     _use_function_id: str
     _use_method_name: str
-    _parent: typing.Optional[Function]
     _class_parameter_info: typing.Optional[modal_proto.api_pb2.ClassParameterInfo]
     _method_handle_metadata: typing.Optional[typing.Dict[str, modal_proto.api_pb2.FunctionHandleMetadata]]
 
@@ -450,11 +446,11 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
 
     _call_generator_nowait: ___call_generator_nowait_spec
 
-    class __remote_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class __remote_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
         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[ReturnType, P]
+    remote: __remote_spec[P, ReturnType]
 
     class __remote_gen_spec(typing_extensions.Protocol):
         def __call__(self, *args, **kwargs) -> typing.Generator[typing.Any, None, None]: ...
@@ -466,17 +462,17 @@ class Function(typing.Generic[P, ReturnType, OriginalReturnType], modal.object.O
     def _get_obj(self) -> typing.Optional[modal.cls.Obj]: ...
     def local(self, *args: P.args, **kwargs: P.kwargs) -> OriginalReturnType: ...
 
-    class ___experimental_spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class ___experimental_spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
         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[ReturnType, P]
+    _experimental_spawn: ___experimental_spawn_spec[P, ReturnType]
 
-    class __spawn_spec(typing_extensions.Protocol[ReturnType_INNER, P_INNER]):
+    class __spawn_spec(typing_extensions.Protocol[P_INNER, ReturnType_INNER]):
         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[ReturnType, P]
+    spawn: __spawn_spec[P, ReturnType]
 
     def get_raw_f(self) -> typing.Callable[..., typing.Any]: ...
 

modal/partial_function.py

@@ -91,7 +91,7 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
         if obj:  # accessing the method on an instance of a class, e.g. `MyClass().fun``
             if hasattr(obj, "_modal_functions"):
                 # This happens inside "local" user methods when they refer to other methods,
-                # e.g. Foo().parent_method() doing self.local.other_method()
+                # e.g. Foo().parent_method.remote() calling self.other_method.remote()
                 return getattr(obj, "_modal_functions")[k]
             else:
                 # special edge case: referencing a method of an instance of an

{modal-0.66.41.dist-info → modal-0.66.43.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: modal
-Version: 0.66.41
+Version: 0.66.43
 Summary: Python client library for Modal
 Author: Modal Labs
 Author-email: support@modal.com

{modal-0.66.41.dist-info → modal-0.66.43.dist-info}/RECORD

@@ -2,7 +2,7 @@ modal/__init__.py,sha256=Yn8zS7Jxl5uZjPM331Pc4FdSmp9Rt6VdE7TiE4ZKRc8,2151
 modal/__main__.py,sha256=scYhGFqh8OJcVDo-VOxIT6CCwxOgzgflYWMnIZiMRqE,2871
 modal/_clustered_functions.py,sha256=58spAmCbOk8eyjFKW-H21W-FGyYiJmfpEMK4BnTEUrk,2706
 modal/_clustered_functions.pyi,sha256=UQ7DHiQFI3A2Z8kC3gltNHJkQfvgvPuSbFsse9lSPkw,785
-modal/_container_entrypoint.py,sha256=T0Ql-oxgmj7PRVtdF4wYEGq-_a1ZACuCxe6u2XYj0nk,28671
+modal/_container_entrypoint.py,sha256=qP7TRT92_wKlxR-XuLg1FzJ7w4oknlrWDlp68XE0CwQ,28670
 modal/_ipython.py,sha256=HF_DYy0e0qM9WnGDmTY30s1RxzGya9GeORCauCEpRaE,450
 modal/_location.py,sha256=S3lSxIU3h9HkWpkJ3Pwo0pqjIOSB1fjeSgUsY3x7eec,1202
 modal/_output.py,sha256=SMaLrf1btBzHTV_tH5NzA8ZTWNJh5J0b31iG3sQU8_4,25494
@@ -19,11 +19,11 @@ modal/app.py,sha256=QEBK8qYSrux36oi3iS3msBQmcUOS1r4s2nengzzynjQ,44658
 modal/app.pyi,sha256=wHwBIDqkUb2CQzYVhxZafJ8xZ17TZ-8y-cRyOeZsEm0,25182
 modal/call_graph.py,sha256=l-Wi6vM8aosCdHTWegcCyGeVJGFdZ_fzlCmbRVPBXFI,2593
 modal/client.py,sha256=4SpWb4n0nolITR36kADZl1tYLOg6avukmzZU56UQjCo,16385
-modal/client.pyi,sha256=ks1IlHJEWEcBmBVG63n0TthhPVYiIsSpQQFD1igE1jI,7372
+modal/client.pyi,sha256=rygeOYppvKVoM_DviDsgkMWVmNq1dWUFcr2PZEX7rmg,7372
 modal/cloud_bucket_mount.py,sha256=eWQhCtMIczpokjfTZEgNBCGO_s5ft46PqTSLfKBykq4,5748
 modal/cloud_bucket_mount.pyi,sha256=tTF7M4FR9bTA30cFkz8qq3ZTlFL19NHU_36e_5GgAGA,1424
-modal/cls.py,sha256=Ci7EtMrLm1LExfjZ9K2IXyj-SV9Syq8dAbZCEfddcmY,24234
-modal/cls.pyi,sha256=Dr4kgq8cj7YGRf9ayInuogOxs6yHim5_562Om8Avu14,8332
+modal/cls.py,sha256=apKnBOHKYEpBiMC8mRvHtCDJl1g0vP0tG1r8mUZ1yH0,24684
+modal/cls.pyi,sha256=om3xQuHTMu7q_32BDKJjAz4oP_7Z5JWV27kyDKTPFI8,8332
 modal/config.py,sha256=oVmvclQ2Qlt-VmL3wEp8DgDrnTPh_K5UBEYrSXv4C4s,10928
 modal/container_process.py,sha256=c_jBPtyPeSxbIcbLfs_FzTrt-1eErtRSnsfxkDozFoY,5589
 modal/container_process.pyi,sha256=k2kClwaSzz11eci1pzFZgCm-ptXapHAyHTOENorlazA,2594
@@ -33,8 +33,8 @@ modal/environments.py,sha256=KwKdrWfSnz2XF5eYXZyd0kdac1x1PVw2uxPYsGy8cys,6517
 modal/environments.pyi,sha256=oScvFAclF55-tL9UioLIL_SPBwgy_9O-BBvJ-PLbRgY,3542
 modal/exception.py,sha256=K-czk1oK8wFvK8snWrytXSByo2WNb9SJAlgBVPGWZBs,6417
 modal/experimental.py,sha256=jFuNbwrNHos47viMB9q-cHJSvf2RDxDdoEcss9plaZE,2302
-modal/functions.py,sha256=3iAonXDZ1OXgtUhL1LuTguNxlJi_PtGu-cBibd6Y464,71837
-modal/functions.pyi,sha256=opYVDolZweBVZSfgT4t7OyQj4vBJ82B72IRoS8ZpoYw,24939
+modal/functions.py,sha256=BxccB-3a1migZQ6JA6iiHZJQ7WQ-jYpmg9DEZoTxzcc,71639
+modal/functions.pyi,sha256=0JsvWf9vvj2fMSNIHoXmL9FS7sWoRU4hU6911PyqEls,24800
 modal/gpu.py,sha256=r4rL6uH3UJIQthzYvfWauXNyh01WqCPtKZCmmSX1fd4,6881
 modal/image.py,sha256=j-NH8pLWk4jd5UOGD4y6W7DHWoeb3rG_VR7zPLSqj-Q,78927
 modal/image.pyi,sha256=QEjjnl4ZSmqt7toHww5ZbhL2Re5qaFGgH7qADcJS_vA,24493
@@ -49,7 +49,7 @@ modal/object.pyi,sha256=cwWg93H4rBk9evt1itLZAZXH5wUMyTJBZ_ADazgfjGg,8465
 modal/output.py,sha256=FtPR7yvjZMgdSKD_KYkIcwYgCOiV9EKYjaj7K55Hjvg,1940
 modal/parallel_map.py,sha256=lf8Wer6FAf8-dYqPqoL45cz7FYDU66-TF-h5CO2Kf5Q,16052
 modal/parallel_map.pyi,sha256=pOhT0P3DDYlwLx0fR3PTsecA7DI8uOdXC1N8i-ZkyOY,2328
-modal/partial_function.py,sha256=1zAQZAxTaX8Nn7Rzm6fJ3mwybuVUF6OMQte76F0Vxz8,28206
+modal/partial_function.py,sha256=xkEqMPG0rnP_BUDqGikerv6uiWxDkwZdIFSdoHMDm2A,28216
 modal/partial_function.pyi,sha256=BqKN7It5QLxS2yhhhDX0RgI8EyNMPBD6Duk21kN_fvA,8908
 modal/proxy.py,sha256=ZrOsuQP7dSZFq1OrIxalNnt0Zvsnp1h86Th679sSL40,1417
 modal/proxy.pyi,sha256=UvygdOYneLTuoDY6hVaMNCyZ947Tmx93IdLjErUqkvM,368
@@ -78,13 +78,13 @@ modal/_runtime/asgi.py,sha256=WoAwIiGKpk089MOca3_iA73h36v0uBuoPx0-87ajIDY,19843
 modal/_runtime/container_io_manager.py,sha256=_MEhwyCSYeCaPQnztPxkm0anRXa3CPcwIKi403N53uo,44120
 modal/_runtime/execution_context.py,sha256=cXEVY4wEK-oZJVJptyj1ZplZvVQ1HDzFsyHxhaY4o8M,2718
 modal/_runtime/telemetry.py,sha256=3NbrfwYH6mvDckzdTppymmda2lQKX2oHGc2JwdFZdUc,5191
-modal/_runtime/user_code_imports.py,sha256=R06r4e5Dwmes0bgmHClotBN_vd5Etss8Ml4vVtfW8wI,14542
+modal/_runtime/user_code_imports.py,sha256=2COhqA77zwbP__-DWiDHEScHM-Go3CmI-AlKvT_oBOU,14545
 modal/_utils/__init__.py,sha256=waLjl5c6IPDhSsdWAm9Bji4e2PVxamYABKAze6CHVXY,28
 modal/_utils/app_utils.py,sha256=88BT4TPLWfYAQwKTHcyzNQRHg8n9B-QE2UyJs96iV-0,108
 modal/_utils/async_utils.py,sha256=3H4pBC4DW6rCA6hgRux6FMxGqPgHM-G-BTs7KXZiWz4,23958
 modal/_utils/blob_utils.py,sha256=pAY22w0oVc6ujGfI7La7HPUMOf42FehIapuhSDeeqEs,15835
 modal/_utils/function_utils.py,sha256=28mxgg_-7JF1DDiNnp3iNVsFQkOzMFjORsetdvZZTHU,24475
-modal/_utils/grpc_testing.py,sha256=PQyzEjHBveW7vdqu5Tpn-aNWPO5RPPcsRWzGvXDHCxY,7931
+modal/_utils/grpc_testing.py,sha256=LOzWygTdHINzV-o_Ajbl7sOFbUQFoonP0iKpsJjA_nc,8301
 modal/_utils/grpc_utils.py,sha256=tM1Q32VOU2WG733IfVHTLZdiyCe8Ga0f0Dx0iDLLy_8,7724
 modal/_utils/hash_utils.py,sha256=HefF7zPQPxFxyx3fpz-AdSm4QsHZNNvgL9-iQHY-_F4,1790
 modal/_utils/http_utils.py,sha256=VKXYNPJtrSwZ1ttcXVGQUWmn8cLAXiOTv05g2ac3GbU,2179
@@ -159,10 +159,10 @@ modal_proto/options_pb2_grpc.pyi,sha256=CImmhxHsYnF09iENPoe8S4J-n93jtgUYD2JPAc0y
 modal_proto/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 modal_version/__init__.py,sha256=UnAuHBPuPSstqgdCOx0SBVdfhpeJnMlY_oxEbu44Izg,470
 modal_version/__main__.py,sha256=2FO0yYQQwDTh6udt1h-cBnGd1c4ZyHnHSI4BksxzVac,105
-modal_version/_version_generated.py,sha256=f_VtwXUFTDT3K9eouIGQJ6JPyZoKIj-f8j0FHsz7-08,149
-modal-0.66.41.dist-info/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
-modal-0.66.41.dist-info/METADATA,sha256=WEDpf-y9hIxln-uCT39vrOtjfoTC-rv_H4y7cgM6geY,2329
-modal-0.66.41.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-modal-0.66.41.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
-modal-0.66.41.dist-info/top_level.txt,sha256=1nvYbOSIKcmU50fNrpnQnrrOpj269ei3LzgB6j9xGqg,64
-modal-0.66.41.dist-info/RECORD,,
+modal_version/_version_generated.py,sha256=7WGR5zgAcB_J0SICoQ3twGcle4mHokidCuBdi-SVPYE,149
+modal-0.66.43.dist-info/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+modal-0.66.43.dist-info/METADATA,sha256=KMqp2KMs325ypwcMgvoCDdfV1-QnMjkjJ8uxAQ07DIw,2329
+modal-0.66.43.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+modal-0.66.43.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
+modal-0.66.43.dist-info/top_level.txt,sha256=1nvYbOSIKcmU50fNrpnQnrrOpj269ei3LzgB6j9xGqg,64
+modal-0.66.43.dist-info/RECORD,,

modal_version/_version_generated.py

@@ -1,4 +1,4 @@
 # Copyright Modal Labs 2024
 
 # Note: Reset this value to -1 whenever you make a minor `0.X` release of the client.
-build_number = 41  # git: ebfd9f4
+build_number = 43  # git: f00c791