modal 0.73.54__py3-none-any.whl → 0.73.55__py3-none-any.whl

modal/_container_entrypoint.py

@@ -471,16 +471,16 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
         # TODO(erikbern): we an remove this once we
         # 1. Enable lazy hydration for all objects
         # 2. Fully deprecate .new() objects
-        if service.code_deps is not None:  # this is not set for serialized or non-global scope functions
+        if service.service_deps is not None:  # this is not set for serialized or non-global scope functions
             dep_object_ids: list[str] = [dep.object_id for dep in function_def.object_dependencies]
-            if len(service.code_deps) != len(dep_object_ids):
+            if len(service.service_deps) != len(dep_object_ids):
                 raise ExecutionError(
-                    f"Function has {len(service.code_deps)} dependencies"
+                    f"Function has {len(service.service_deps)} dependencies"
                     f" but container got {len(dep_object_ids)} object ids.\n"
-                    f"Code deps: {service.code_deps}\n"
+                    f"Code deps: {service.service_deps}\n"
                     f"Object ids: {dep_object_ids}"
                 )
-            for object_id, obj in zip(dep_object_ids, service.code_deps):
+            for object_id, obj in zip(dep_object_ids, service.service_deps):
                 metadata: Message = container_app.object_handle_metadata[object_id]
                 obj._hydrate(object_id, _client, metadata)
 

modal/_functions.py

@@ -182,7 +182,8 @@ class _Invocation:
         if timeout is None:
             backend_timeout = OUTPUTS_TIMEOUT
         else:
-            backend_timeout = min(OUTPUTS_TIMEOUT, timeout)  # refresh backend call every 55s
+            # refresh backend call every 55s
+            backend_timeout = min(OUTPUTS_TIMEOUT, timeout)
 
         while True:
             # always execute at least one poll for results, regardless if timeout is 0
@@ -278,7 +279,8 @@ class _Invocation:
 
     async def run_generator(self):
         items_received = 0
-        items_total: Union[int, None] = None  # populated when self.run_function() completes
+        # populated when self.run_function() completes
+        items_total: Union[int, None] = None
         async with aclosing(
             async_merge(
                 _stream_function_call_data(self.client, self.function_call_id, variant="data_out"),
@@ -350,7 +352,8 @@ class _FunctionSpec:
     secrets: Sequence[_Secret]
     network_file_systems: dict[Union[str, PurePosixPath], _NetworkFileSystem]
     volumes: dict[Union[str, PurePosixPath], Union[_Volume, _CloudBucketMount]]
-    gpus: Union[GPU_T, list[GPU_T]]  # TODO(irfansharif): Somehow assert that it's the first kind, in sandboxes
+    # TODO(irfansharif): Somehow assert that it's the first kind, in sandboxes
+    gpus: Union[GPU_T, list[GPU_T]]
     cloud: Optional[str]
     cpu: Optional[Union[float, tuple[float, float]]]
     memory: Optional[Union[int, tuple[int, int]]]
@@ -377,16 +380,19 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
     _info: Optional[FunctionInfo]
     _serve_mounts: frozenset[_Mount]  # set at load time, only by loader
     _app: Optional["modal.app._App"] = None
-    _obj: Optional["modal.cls._Obj"] = None  # only set for InstanceServiceFunctions and bound instance methods
+    # only set for InstanceServiceFunctions and bound instance methods
+    _obj: Optional["modal.cls._Obj"] = None
 
-    _webhook_config: Optional[api_pb2.WebhookConfig] = None  # this is set in definition scope, only locally
+    # this is set in definition scope, only locally
+    _webhook_config: Optional[api_pb2.WebhookConfig] = None
     _web_url: Optional[str]  # this is set on hydration
 
     _function_name: Optional[str]
     _is_method: bool
     _spec: Optional[_FunctionSpec] = None
     _tag: str
-    _raw_f: Optional[Callable[..., Any]]  # this is set to None for a "class service [function]"
+    # this is set to None for a "class service [function]"
+    _raw_f: Optional[Callable[..., Any]]
     _build_args: dict
 
     _is_generator: Optional[bool] = None
@@ -401,40 +407,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         None  # set for 0.67+ class service functions
     )
 
-    def _bind_method(
-        self,
-        user_cls,
-        method_name: str,
-        partial_function: "modal._partial_function._PartialFunction",
-    ):
-        """mdmd:hidden
-
-        Creates a _Function that is bound to a specific class method name. This _Function is not uniquely tied
-        to any backend function -- its object_id is the function ID of the class service function.
-
-        """
-        class_service_function = self
-        assert class_service_function._info  # has to be a local function to be able to "bind" it
-        assert not class_service_function._is_method  # should not be used on an already bound method placeholder
-        assert not class_service_function._obj  # should only be used on base function / class service function
-        full_name = f"{user_cls.__name__}.{method_name}"
-
-        rep = f"Method({full_name})"
-        fun = _Object.__new__(_Function)
-        fun._init(rep)
-        fun._tag = full_name
-        fun._raw_f = partial_function.raw_f
-        fun._info = FunctionInfo(
-            partial_function.raw_f, user_cls=user_cls, serialized=class_service_function.info.is_serialized()
-        )  # needed for .local()
-        fun._use_method_name = method_name
-        fun._app = class_service_function._app
-        fun._is_generator = partial_function.is_generator
-        fun._cluster_size = partial_function.cluster_size
-        fun._spec = class_service_function._spec
-        fun._is_method = True
-        return fun
-
     @staticmethod
     def from_local(
         info: FunctionInfo,
@@ -460,7 +432,8 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         batch_wait_ms: Optional[int] = None,
         container_idle_timeout: Optional[int] = None,
         cpu: Optional[Union[float, tuple[float, float]]] = None,
-        keep_warm: Optional[int] = None,  # keep_warm=True is equivalent to keep_warm=1
+        # keep_warm=True is equivalent to keep_warm=1
+        keep_warm: Optional[int] = None,
         cloud: Optional[str] = None,
         scheduler_placement: Optional[SchedulerPlacement] = None,
         is_builder_function: bool = False,
@@ -468,7 +441,8 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         enable_memory_snapshot: bool = False,
         block_network: bool = False,
         i6pn_enabled: bool = False,
-        cluster_size: Optional[int] = None,  # Experimental: Clustered functions
+        # Experimental: Clustered functions
+        cluster_size: Optional[int] = None,
         max_inputs: Optional[int] = None,
         ephemeral_disk: Optional[int] = None,
         # current default: first-party, future default: main-package
@@ -934,7 +908,8 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         raise InvalidError(f"Function {info.function_name} is too large to deploy.")
                     raise
                 function_creation_status.set_response(response)
-            serve_mounts = {m for m in all_mounts if m.is_local()}  # needed for modal.serve file watching
+            # needed for modal.serve file watching
+            serve_mounts = {m for m in all_mounts if m.is_local()}
             serve_mounts |= image._serve_mounts
             obj._serve_mounts = frozenset(serve_mounts)
             self._hydrate(response.function_id, resolver.client, response.handle_metadata)
@@ -1039,6 +1014,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
         fun._info = self._info
         fun._obj = obj
+        fun._spec = self._spec  # TODO (elias): fix - this is incorrect when using with_options
         return fun
 
     @live_method
@@ -1223,7 +1199,9 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
 
     def _hydrate_metadata(self, metadata: Optional[Message]):
         # Overridden concrete implementation of base class method
-        assert metadata and isinstance(metadata, api_pb2.FunctionHandleMetadata)
+        assert metadata and isinstance(metadata, api_pb2.FunctionHandleMetadata), (
+            f"{type(metadata)} is not FunctionHandleMetadata"
+        )
         self._is_generator = metadata.function_type == api_pb2.Function.FUNCTION_TYPE_GENERATOR
         self._web_url = metadata.web_url
         self._function_name = metadata.function_name
@@ -1595,7 +1573,8 @@ class _FunctionCall(typing.Generic[ReturnType], _Object, type_prefix="fc"):
 
     async def cancel(
         self,
-        terminate_containers: bool = False,  # if true, containers running the inputs are forcibly terminated
+        # if true, containers running the inputs are forcibly terminated
+        terminate_containers: bool = False,
     ):
         """Cancels the function call, which will stop its execution and mark its inputs as
         [`TERMINATED`](/docs/reference/modal.call_graph#modalcall_graphinputstatus).

modal/_runtime/user_code_imports.py

@@ -41,7 +41,7 @@ class Service(metaclass=ABCMeta):
 
     user_cls_instance: Any
     app: Optional["modal.app._App"]
-    code_deps: Optional[Sequence["modal._object._Object"]]
+    service_deps: Optional[Sequence["modal._object._Object"]]
 
     @abstractmethod
     def get_finalized_functions(
@@ -93,7 +93,7 @@ def construct_webhook_callable(
 class ImportedFunction(Service):
     user_cls_instance: Any
     app: Optional["modal.app._App"]
-    code_deps: Optional[Sequence["modal._object._Object"]]
+    service_deps: Optional[Sequence["modal._object._Object"]]
 
     _user_defined_callable: Callable[..., Any]
 
@@ -136,7 +136,7 @@ class ImportedFunction(Service):
 class ImportedClass(Service):
     user_cls_instance: Any
     app: Optional["modal.app._App"]
-    code_deps: Optional[Sequence["modal._object._Object"]]
+    service_deps: Optional[Sequence["modal._object._Object"]]
 
     _partial_functions: dict[str, "modal._partial_function._PartialFunction"]
 
@@ -227,8 +227,7 @@ def import_single_function_service(
     the import) runs on the right thread.
     """
     user_defined_callable: Callable
-    function: Optional[_Function] = None
-    code_deps: Optional[Sequence["modal._object._Object"]] = None
+    service_deps: Optional[Sequence["modal._object._Object"]] = None
     active_app: Optional[modal.app._App] = None
 
     if ser_fun is not None:
@@ -249,6 +248,7 @@ def import_single_function_service(
             f = getattr(module, qual_name)
             if isinstance(f, Function):
                 function = synchronizer._translate_in(f)
+                service_deps = function.deps(only_explicit_mounts=True)
                 user_defined_callable = function.get_raw_f()
                 active_app = function._app
             else:
@@ -264,9 +264,7 @@ def import_single_function_service(
                 # The cls decorator is in global scope
                 _cls = synchronizer._translate_in(cls)
                 user_defined_callable = _cls._callables[fun_name]
-                function = _cls._method_functions.get(
-                    fun_name
-                )  # bound to the class service function - there is no instance
+                service_deps = _cls._get_class_service_function().deps(only_explicit_mounts=True)
                 active_app = _cls._app
             else:
                 # This is non-decorated class
@@ -283,13 +281,10 @@ def import_single_function_service(
     else:
         user_cls_instance = None
 
-    if function:
-        code_deps = function.deps(only_explicit_mounts=True)
-
     return ImportedFunction(
         user_cls_instance,
         active_app,
-        code_deps,
+        service_deps,
         user_defined_callable,
     )
 
@@ -306,7 +301,7 @@ def import_class_service(
     See import_function.
     """
     active_app: Optional["modal.app._App"]
-    code_deps: Optional[Sequence["modal._object._Object"]]
+    service_deps: Optional[Sequence["modal._object._Object"]]
     cls: typing.Union[type, modal.cls.Cls]
 
     if function_def.definition_type == api_pb2.Function.DEFINITION_TYPE_SERIALIZED:
@@ -337,12 +332,12 @@ def import_class_service(
         _cls = synchronizer._translate_in(cls)
         method_partials = _cls._get_partial_functions()
         service_function: _Function = _cls._class_service_function
-        code_deps = service_function.deps(only_explicit_mounts=True)
+        service_deps = service_function.deps(only_explicit_mounts=True)
         active_app = service_function.app
     else:
         # Undecorated user class - find all methods
         method_partials = _find_partial_methods_for_user_cls(cls, _PartialFunctionFlags.all())
-        code_deps = None
+        service_deps = None
         active_app = None
 
     user_cls_instance = get_user_class_instance(cls, cls_args, cls_kwargs)
@@ -350,7 +345,7 @@ def import_class_service(
     return ImportedClass(
         user_cls_instance,
         active_app,
-        code_deps,
+        service_deps,
         # TODO (elias/deven): instead of using method_partials here we should use a set of api_pb2.MethodDefinition
         method_partials,
     )

modal/client.pyi

@@ -27,7 +27,7 @@ class _Client:
     _snapshotted: bool
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.73.54"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.73.55"
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -85,7 +85,7 @@ class Client:
     _snapshotted: bool
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.73.54"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.73.55"
     ): ...
     def is_closed(self) -> bool: ...
     @property

modal/cls.py

@@ -8,7 +8,7 @@ from typing import Any, Callable, Optional, TypeVar, Union
 from google.protobuf.message import Message
 from grpclib import GRPCError, Status
 
-from modal._utils.function_utils import CLASS_PARAM_TYPE_MAP
+from modal._utils.function_utils import CLASS_PARAM_TYPE_MAP, FunctionInfo
 from modal_proto import api_pb2
 
 from ._functions import _Function, _parse_retries
@@ -72,30 +72,22 @@ def _get_class_constructor_signature(user_cls: type) -> inspect.Signature:
         return inspect.Signature(constructor_parameters)
 
 
-def _bind_instance_method(service_function: _Function, class_bound_method: _Function):
-    """Binds an "instance service function" to a specific method name.
-    This "dummy" _Function gets no unique object_id and isn't backend-backed at the moment, since all
-    it does it forward invocations to the underlying instance_service_function with the specified method,
-    and we don't support web_config for parametrized methods at the moment.
+def _bind_instance_method(cls: "_Cls", service_function: _Function, method_name: str):
+    """Binds an "instance service function" to a specific method using metadata for that method
+
+    This "dummy" _Function gets no unique object_id and isn't backend-backed at all, since all
+    it does it forward invocations to the underlying instance_service_function with the specified method
     """
-    # TODO(elias): refactor to not use `_from_loader()` as a crutch for lazy-loading the
-    #   underlying instance_service_function. It's currently used in order to take advantage
-    #   of resolver logic and get "chained" resolution of lazy loads, even though this thin
-    #   object itself doesn't need any "loading"
     assert service_function._obj
-    method_name = class_bound_method._use_method_name
-
-    def hydrate_from_instance_service_function(method_placeholder_fun):
-        method_placeholder_fun._hydrate_from_other(service_function)
-        method_placeholder_fun._obj = service_function._obj
-        method_placeholder_fun._web_url = (
-            class_bound_method._web_url
-        )  # TODO: this shouldn't be set when actual parameters are used
-        method_placeholder_fun._function_name = f"{class_bound_method._function_name}[parametrized]"
-        method_placeholder_fun._is_generator = class_bound_method._is_generator
-        method_placeholder_fun._cluster_size = class_bound_method._cluster_size
-        method_placeholder_fun._use_method_name = method_name
-        method_placeholder_fun._is_method = True
+
+    def hydrate_from_instance_service_function(new_function: _Function):
+        assert service_function.is_hydrated
+        assert cls.is_hydrated
+        # After 0.67 is minimum required version, we should be able to use method metadata directly
+        # from the service_function instead (see _Cls._hydrate_metadata), but for now we use the Cls
+        # since it can take the data from the cls metadata OR function metadata depending on source
+        method_metadata = cls._method_metadata[method_name]
+        new_function._hydrate(service_function.object_id, service_function.client, method_metadata)
 
     async def _load(fun: "_Function", resolver: Resolver, existing_object_id: Optional[str]):
         # there is currently no actual loading logic executed to create each method on
@@ -111,7 +103,7 @@ def _bind_instance_method(service_function: _Function, class_bound_method: _Func
             return []
         return [service_function]
 
-    rep = f"Method({method_name})"
+    rep = f"Method({cls._name}.{method_name})"
 
     fun = _Function._from_loader(
         _load,
@@ -123,12 +115,19 @@ def _bind_instance_method(service_function: _Function, class_bound_method: _Func
         # Eager hydration (skip load) if the instance service function is already loaded
         hydrate_from_instance_service_function(fun)
 
-    fun._info = class_bound_method._info
+    if cls._is_local():
+        partial_function = cls._method_partials[method_name]
+        fun._info = FunctionInfo(
+            # ugly - needed for .local()  TODO (elias): Clean up!
+            partial_function.raw_f,
+            user_cls=cls._user_cls,
+            serialized=service_function.info.is_serialized(),
+        )
+
     fun._obj = service_function._obj
     fun._is_method = True
-    fun._app = class_bound_method._app
-    fun._spec = class_bound_method._spec
-    fun._is_web_endpoint = class_bound_method._is_web_endpoint
+    fun._app = service_function._app
+    fun._spec = service_function._spec
     return fun
 
 
@@ -280,31 +279,34 @@ class _Obj:
         # * Support .local() on both hydrated and unhydrated classes (assuming local access to code)
         # * Support attribute access (when local cls is available)
 
-        def _get_method_bound_function() -> Optional["_Function"]:
+        # The returned _Function objects need to be lazily loaded (including loading the Cls and/or service function)
+        # since we can't assume the class is already loaded when this gets called, e.g.
+        # CLs.from_name(...)().my_func.remote().
+
+        def _get_maybe_method() -> Optional["_Function"]:
             """Gets _Function object for method - either for a local or a hydrated remote class
 
             * If class is neither local or hydrated - raise exception (should never happen)
             * If attribute isn't a method - return None
             """
-            if self._cls._method_functions is None:
-                raise ExecutionError("Method is not local and not hydrated")
-
-            if class_bound_method := self._cls._method_functions.get(k, None):
-                # 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 _bind_instance_method(self._cached_service_function(), class_bound_method)
-
-            return None  # The attribute isn't a method
-
-        if self._cls._method_functions is not None:
-            # We get here with either a hydrated Cls or an unhydrated one with local definition
-            if method := _get_method_bound_function():
-                return method
-            elif self._user_cls:
+            if self._cls._is_local():
+                if k not in self._cls._method_partials:
+                    return None
+            elif self._cls.is_hydrated:
+                if k not in self._cls._method_metadata:
+                    return None
+            else:
+                raise ExecutionError(
+                    "Class is neither hydrated or local - this is probably a bug in the Modal client. Contact support"
+                )
+
+            return _bind_instance_method(self._cls, self._cached_service_function(), k)
+
+        if self._cls.is_hydrated or self._cls._is_local():
+            # Class is hydrated or local so we know which methods exist
+            if maybe_method := _get_maybe_method():
+                return maybe_method
+            elif self._cls._is_local():
                 # We have the local definition, and the attribute isn't a method
                 # so we instantiate if we don't have an instance, and try to get the attribute
                 user_cls_instance = self._cached_user_cls_instance()
@@ -319,10 +321,9 @@ class _Obj:
 
         # Not hydrated Cls, and we don't have the class - typically a Cls.from_name that
         # has not yet been loaded. So use a special loader that loads it lazily:
-
         async def method_loader(fun, resolver: Resolver, existing_object_id):
             await resolver.load(self._cls)  # load class so we get info about methods
-            method_function = _get_method_bound_function()
+            method_function = _get_maybe_method()
             if method_function is None:
                 raise NotFoundError(
                     f"Class has no method {k}, and attributes can't be accessed for `Cls.from_name` instances"
@@ -334,7 +335,7 @@ class _Obj:
         # on local classes.
         return _Function._from_loader(
             method_loader,
-            repr,
+            rep=f"Method({self._cls._name}.{k})",
             deps=lambda: [],  # TODO: use cls as dep instead of loading inside method_loader?
             hydrate_lazily=True,
         )
@@ -352,13 +353,19 @@ class _Cls(_Object, type_prefix="cs"):
     Instead, use the [`@app.cls()`](/docs/reference/modal.App#cls) decorator on the App object.
     """
 
-    _user_cls: Optional[type]
     _class_service_function: Optional[_Function]  # The _Function (read "service") serving *all* methods of the class
-    _method_functions: Optional[dict[str, _Function]] = None  # Placeholder _Functions for each method
     _options: Optional[api_pb2.FunctionOptions]
-    _callables: dict[str, Callable[..., Any]]
+
     _app: Optional["modal.app._App"] = None  # not set for lookups
     _name: Optional[str]
+    # Only set for hydrated classes:
+    _method_metadata: Optional[dict[str, api_pb2.FunctionHandleMetadata]] = None
+
+    # These are only set where source is locally available:
+    # TODO: wrap these in a single optional/property for consistency
+    _user_cls: Optional[type] = None
+    _method_partials: Optional[dict[str, _PartialFunction]] = None
+    _callables: dict[str, Callable[..., Any]]
 
     def _initialize_from_empty(self):
         self._user_cls = None
@@ -371,10 +378,11 @@ class _Cls(_Object, type_prefix="cs"):
         super()._initialize_from_other(other)
         self._user_cls = other._user_cls
         self._class_service_function = other._class_service_function
-        self._method_functions = other._method_functions
+        self._method_partials = other._method_partials
         self._options = other._options
         self._callables = other._callables
         self._name = other._name
+        self._method_metadata = other._method_metadata
 
     def _get_partial_functions(self) -> dict[str, _PartialFunction]:
         if not self._user_cls:
@@ -382,59 +390,41 @@ class _Cls(_Object, type_prefix="cs"):
         return _find_partial_methods_for_user_cls(self._user_cls, _PartialFunctionFlags.all())
 
     def _get_app(self) -> "modal.app._App":
+        assert self._app is not None
         return self._app
 
     def _get_user_cls(self) -> type:
+        assert self._user_cls is not None
         return self._user_cls
 
     def _get_name(self) -> str:
+        assert self._name is not None
         return self._name
 
-    def _get_class_service_function(self) -> "modal.functions._Function":
+    def _get_class_service_function(self) -> _Function:
+        assert self._class_service_function is not None
         return self._class_service_function
 
     def _get_method_names(self) -> Collection[str]:
         # returns method names for a *local* class only for now (used by cli)
-        return self._method_functions.keys()
+        return self._method_partials.keys()
 
     def _hydrate_metadata(self, metadata: Message):
         assert isinstance(metadata, api_pb2.ClassHandleMetadata)
-        assert self._class_service_function.is_hydrated
-
-        if self._class_service_function._method_handle_metadata and len(
-            self._class_service_function._method_handle_metadata
-        ):
-            # Method metadata stored on the backend Function object (v0.67+)
-            if self._method_functions:
-                # We're here when the Cls is loaded locally (e.g. _Cls.from_local) so the _method_functions mapping is
-                # populated with (un-hydrated) _Function objects - hydrate using function method metadata
-                for (
-                    method_name,
-                    method_handle_metadata,
-                ) in self._class_service_function._method_handle_metadata.items():
-                    self._method_functions[method_name]._hydrate(
-                        self._class_service_function.object_id, self._client, method_handle_metadata
-                    )
-            else:
-                # We're here when the function is loaded remotely (e.g. _Cls.from_name),
-                # same as above, but we create the method "Functions" from scratch rather
-                # than hydrate existing ones. TODO(elias): feels complicated - refactor?
-                self._method_functions = {}
-                for (
-                    method_name,
-                    method_handle_metadata,
-                ) in self._class_service_function._method_handle_metadata.items():
-                    self._method_functions[method_name] = _Function._new_hydrated(
-                        self._class_service_function.object_id, self._client, method_handle_metadata
-                    )
+        class_service_function = self._get_class_service_function()
+        assert class_service_function.is_hydrated
+
+        if class_service_function._method_handle_metadata and len(class_service_function._method_handle_metadata):
+            # If we have the metadata on the class service function
+            # This should be the case for any loaded class (remote or local) as of v0.67
+            method_metadata = class_service_function._method_handle_metadata
         else:
-            # Method metadata stored on the backend Cls object - pre 0.67
+            # Method metadata stored on the backend Cls object - pre 0.67 lookups
             # Can be removed when v0.67 is least supported version (all metadata is on the function)
-            self._method_functions = {}
+            method_metadata = {}
             for method in metadata.methods:
-                self._method_functions[method.function_name] = _Function._new_hydrated(
-                    self._class_service_function.object_id, self._client, method.function_handle_metadata
-                )
+                method_metadata[method.function_name] = method.function_handle_metadata
+        self._method_metadata = method_metadata
 
     @staticmethod
     def validate_construction_mechanism(user_cls):
@@ -467,19 +457,17 @@ class _Cls(_Object, type_prefix="cs"):
         # validate signature
         _Cls.validate_construction_mechanism(user_cls)
 
-        method_functions: dict[str, _Function] = {}
-        partial_functions: dict[str, _PartialFunction] = _find_partial_methods_for_user_cls(
+        method_partials: dict[str, _PartialFunction] = _find_partial_methods_for_user_cls(
             user_cls, _PartialFunctionFlags.FUNCTION
         )
 
-        for method_name, partial_function in partial_functions.items():
-            method_function = class_service_function._bind_method(user_cls, method_name, partial_function)
+        for method_name, partial_function in method_partials.items():
             if partial_function.webhook_config is not None:
-                app._web_endpoints.append(method_function.tag)
+                full_name = f"{user_cls.__name__}.{method_name}"
+                app._web_endpoints.append(full_name)
             partial_function.wrapped = True
-            method_functions[method_name] = method_function
 
-        # Disable the warning that these are not wrapped
+        # Disable the warning that lifecycle methods are not wrapped
         for partial_function in _find_partial_methods_for_user_cls(user_cls, ~_PartialFunctionFlags.FUNCTION).values():
             partial_function.wrapped = True
 
@@ -503,7 +491,7 @@ class _Cls(_Object, type_prefix="cs"):
         cls._app = app
         cls._user_cls = user_cls
         cls._class_service_function = class_service_function
-        cls._method_functions = method_functions
+        cls._method_partials = method_partials
         cls._callables = callables
         cls._name = user_cls.__name__
         return cls
@@ -676,7 +664,8 @@ class _Cls(_Object, type_prefix="cs"):
 
     def __getattr__(self, k):
         # TODO: remove this method - access to attributes on classes (not instances) should be discouraged
-        if k in self._method_functions:
+        if not self._is_local() or k in self._method_partials:
+            # if not local (== k *could* be a method) or it is local and we know k is a method
             deprecation_warning(
                 (2025, 1, 13),
                 "Usage of methods directly on the class will soon be deprecated, "
@@ -684,7 +673,8 @@ class _Cls(_Object, type_prefix="cs"):
                 f"{self._name}().{k} instead of {self._name}.{k}",
                 pending=True,
             )
-            return self._method_functions[k]
+            return getattr(self(), k)
+        # non-method attribute access on local class - arguably shouldn't be used either:
         return getattr(self._user_cls, k)
 
     def _is_local(self) -> bool:

modal/cls.pyi

@@ -22,9 +22,7 @@ T = typing.TypeVar("T")
 
 def _use_annotation_parameters(user_cls: type) -> bool: ...
 def _get_class_constructor_signature(user_cls: type) -> inspect.Signature: ...
-def _bind_instance_method(
-    service_function: modal._functions._Function, class_bound_method: modal._functions._Function
-): ...
+def _bind_instance_method(cls: _Cls, service_function: modal._functions._Function, method_name: str): ...
 
 class _Obj:
     _cls: _Cls
@@ -95,13 +93,14 @@ class Obj:
     def __getattr__(self, k): ...
 
 class _Cls(modal._object._Object):
-    _user_cls: typing.Optional[type]
     _class_service_function: typing.Optional[modal._functions._Function]
-    _method_functions: typing.Optional[dict[str, modal._functions._Function]]
     _options: typing.Optional[modal_proto.api_pb2.FunctionOptions]
-    _callables: dict[str, collections.abc.Callable[..., typing.Any]]
     _app: typing.Optional[modal.app._App]
     _name: typing.Optional[str]
+    _method_metadata: typing.Optional[dict[str, modal_proto.api_pb2.FunctionHandleMetadata]]
+    _user_cls: typing.Optional[type]
+    _method_partials: typing.Optional[dict[str, modal._partial_function._PartialFunction]]
+    _callables: dict[str, collections.abc.Callable[..., typing.Any]]
 
     def _initialize_from_empty(self): ...
     def _initialize_from_other(self, other: _Cls): ...
@@ -152,13 +151,14 @@ class _Cls(modal._object._Object):
     def _is_local(self) -> bool: ...
 
 class Cls(modal.object.Object):
-    _user_cls: typing.Optional[type]
     _class_service_function: typing.Optional[modal.functions.Function]
-    _method_functions: typing.Optional[dict[str, modal.functions.Function]]
     _options: typing.Optional[modal_proto.api_pb2.FunctionOptions]
-    _callables: dict[str, collections.abc.Callable[..., typing.Any]]
     _app: typing.Optional[modal.app.App]
     _name: typing.Optional[str]
+    _method_metadata: typing.Optional[dict[str, modal_proto.api_pb2.FunctionHandleMetadata]]
+    _user_cls: typing.Optional[type]
+    _method_partials: typing.Optional[dict[str, modal.partial_function.PartialFunction]]
+    _callables: dict[str, collections.abc.Callable[..., typing.Any]]
 
     def __init__(self, *args, **kwargs): ...
     def _initialize_from_empty(self): ...

modal/functions.pyi

@@ -14,7 +14,6 @@ import modal.mount
 import modal.network_file_system
 import modal.object
 import modal.parallel_map
-import modal.partial_function
 import modal.proxy
 import modal.retries
 import modal.schedule
@@ -55,7 +54,6 @@ class Function(
     _method_handle_metadata: typing.Optional[dict[str, modal_proto.api_pb2.FunctionHandleMetadata]]
 
     def __init__(self, *args, **kwargs): ...
-    def _bind_method(self, user_cls, method_name: str, partial_function: modal.partial_function.PartialFunction): ...
     @staticmethod
     def from_local(
         info: modal._utils.function_utils.FunctionInfo,

{modal-0.73.54.dist-info → modal-0.73.55.dist-info}/METADATA

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

{modal-0.73.54.dist-info → modal-0.73.55.dist-info}/RECORD

@@ -2,8 +2,8 @@ modal/__init__.py,sha256=8tE3_OhuKF5UkP4dcmMe8NAbLNNJyuwJFNgDQRBgCig,2333
 modal/__main__.py,sha256=CgIjP8m1xJjjd4AXc-delmR6LdBCZclw2A_V38CFIio,2870
 modal/_clustered_functions.py,sha256=kTf-9YBXY88NutC1akI-gCbvf01RhMPCw-zoOI_YIUE,2700
 modal/_clustered_functions.pyi,sha256=vllkegc99A0jrUOWa8mdlSbdp6uz36TsHhGxysAOpaQ,771
-modal/_container_entrypoint.py,sha256=YtfJ852XUDtAWBD-yVs99zy933-VBEKQyIngEj36Qcw,29286
-modal/_functions.py,sha256=VY9SfEWbcw-kzkALDlg7yHxGlCVVuEaAahH6jAuaNHk,72450
+modal/_container_entrypoint.py,sha256=arhkIoF8nQNfa4iwYGSoqN3QMDg5M38QNAODXC8TlKc,29301
+modal/_functions.py,sha256=EuB4p-9-__OLovkVHOr4qN-RPtUv-ZgwZJ3XRcUnGhg,71203
 modal/_ipython.py,sha256=TW1fkVOmZL3YYqdS2YlM1hqpf654Yf8ZyybHdBnlhSw,301
 modal/_location.py,sha256=joiX-0ZeutEUDTrrqLF1GHXCdVLF-rHzstocbMcd_-k,366
 modal/_object.py,sha256=ItQcsMNkz9Y3kdTsvfNarbW-paJ2qabDyQ7njaqY0XI,11359
@@ -22,11 +22,11 @@ modal/app.py,sha256=o5mHoHtn41nkvskX_ekJkyfG6MXwj5rqerRi_nnPd0w,44725
 modal/app.pyi,sha256=0MMCgskIL4r3eq8oBcfm2lLyeao2gXjS3iXaIfmaJ-o,25959
 modal/call_graph.py,sha256=1g2DGcMIJvRy-xKicuf63IVE98gJSnQsr8R_NVMptNc,2581
 modal/client.py,sha256=8SQawr7P1PNUCq1UmJMUQXG2jIo4Nmdcs311XqrNLRE,15276
-modal/client.pyi,sha256=LprjbulAA-06i_GnsqddKKY06yDMjwtusjYQcg28VaA,7593
+modal/client.pyi,sha256=nZrDHyVUzG8n8lW3ZjoKG0PLL4xEnypRvhECRCu9fFo,7593
 modal/cloud_bucket_mount.py,sha256=YOe9nnvSr4ZbeCn587d7_VhE9IioZYRvF9VYQTQux08,5914
 modal/cloud_bucket_mount.pyi,sha256=30T3K1a89l6wzmEJ_J9iWv9SknoGqaZDx59Xs-ZQcmk,1607
-modal/cls.py,sha256=nJhJr-YuttOmdNWxtMHcBV-q6iQmY5qXkEy9yO43clY,31130
-modal/cls.pyi,sha256=QqYoRKVCKhP_HkHittKpEZ6sqXkEdtEl4n1wMqeoe3M,8897
+modal/cls.py,sha256=wztMTYkhJyW9iUVqx4_Gga4bJJpUiPgGsS6iacUqy-A,30001
+modal/cls.pyi,sha256=4Ms1i4Wty1qe49Dh_wsGhJDCiJz7t-XGqXLcpzwhUqs,9084
 modal/config.py,sha256=XT1W4Y9PVkbYMAXjJRshvQEPDhZmnfW_ZRMwl8XKoqA,11149
 modal/container_process.py,sha256=WTqLn01dJPVkPpwR_0w_JH96ceN5mV4TGtiu1ZR2RRA,6108
 modal/container_process.pyi,sha256=Hf0J5JyDdCCXBJSKx6gvkPOo0XrztCm78xzxamtzUjQ,2828
@@ -41,7 +41,7 @@ modal/file_io.py,sha256=lcMs_E9Xfm0YX1t9U2wNIBPnqHRxmImqjLW1GHqVmyg,20945
 modal/file_io.pyi,sha256=NTRft1tbPSWf9TlWVeZmTlgB5AZ_Zhu2srWIrWr7brk,9445
 modal/file_pattern_matcher.py,sha256=trosX-Bp7dOubudN1bLLhRAoidWy1TcoaR4Pv8CedWw,6497
 modal/functions.py,sha256=kcNHvqeGBxPI7Cgd57NIBBghkfbeFJzXO44WW0jSmao,325
-modal/functions.pyi,sha256=R_I4Foho4htNCFhYc0YKhWoS_jLqZNOrNfTrAA-Clew,14395
+modal/functions.pyi,sha256=p9H14D_n2lAjeVvymu74wDWsL_BnpBrT0BunbAlwviw,14247
 modal/gpu.py,sha256=Kbhs_u49FaC2Zi0TjCdrpstpRtT5eZgecynmQi5IZVE,6752
 modal/image.py,sha256=EtYt7_Rjgi71gt_SutqF8KSjnzWgP5P1Z7XsV-eIoFw,91470
 modal/image.pyi,sha256=Oc2ndYHSdQTcRpZKHSfTdj-m_2oQAsnc2EWTthbNn-s,26380
@@ -90,7 +90,7 @@ modal/_runtime/execution_context.py,sha256=E6ofm6j1POXGPxS841X3V7JU6NheVb8OkQc7J
 modal/_runtime/execution_context.pyi,sha256=wQZwMNADExkeNdB9yKX0PPojovxlFHbap3441wAsiMY,634
 modal/_runtime/gpu_memory_snapshot.py,sha256=tA3m1d1cwnmHpvpCeN_WijDd6n8byn7LWlpicbIxiOI,3144
 modal/_runtime/telemetry.py,sha256=T1RoAGyjBDr1swiM6pPsGRSITm7LI5FDK18oNXxY08U,5163
-modal/_runtime/user_code_imports.py,sha256=qDasIvffN3SJjUeT1DHcpN35lWNepnbomS0Z8yD65mA,14740
+modal/_runtime/user_code_imports.py,sha256=2-_cVZqhodtEea9wAii-FAfc3dQmbbXZn5WcEZRAEA8,14653
 modal/_utils/__init__.py,sha256=waLjl5c6IPDhSsdWAm9Bji4e2PVxamYABKAze6CHVXY,28
 modal/_utils/app_utils.py,sha256=88BT4TPLWfYAQwKTHcyzNQRHg8n9B-QE2UyJs96iV-0,108
 modal/_utils/async_utils.py,sha256=5PdDuI1aSwPOI4a3dIvW0DkPqGw6KZN6RtWE18Dzv1E,25079
@@ -168,10 +168,10 @@ modal_proto/options_pb2_grpc.pyi,sha256=CImmhxHsYnF09iENPoe8S4J-n93jtgUYD2JPAc0y
 modal_proto/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 modal_version/__init__.py,sha256=wiJQ53c-OMs0Xf1UeXOxQ7FwlV1VzIjnX6o-pRYZ_Pk,470
 modal_version/__main__.py,sha256=2FO0yYQQwDTh6udt1h-cBnGd1c4ZyHnHSI4BksxzVac,105
-modal_version/_version_generated.py,sha256=s2jlryO9xPf8xcGboFikDfwaF7F-1rGoYvZQiLDJfRQ,149
-modal-0.73.54.dist-info/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
-modal-0.73.54.dist-info/METADATA,sha256=d8cxP_JRVLAGhVsYMGMB3xcOdFTKEy_-mOFT13MlO0I,2452
-modal-0.73.54.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
-modal-0.73.54.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
-modal-0.73.54.dist-info/top_level.txt,sha256=4BWzoKYREKUZ5iyPzZpjqx4G8uB5TWxXPDwibLcVa7k,43
-modal-0.73.54.dist-info/RECORD,,
+modal_version/_version_generated.py,sha256=zVwEkqZxoWoBV_snchjrReQmz4UyRGbwD5TcvDFAEn4,149
+modal-0.73.55.dist-info/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+modal-0.73.55.dist-info/METADATA,sha256=PIFq_bZuCgqDj8hE86RjViA2cHg33n6D2e5pURrTd7w,2452
+modal-0.73.55.dist-info/WHEEL,sha256=In9FTNxeP60KnTkGw7wk6mJPYd_dQSjEZmXdBdMCI-8,91
+modal-0.73.55.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
+modal-0.73.55.dist-info/top_level.txt,sha256=4BWzoKYREKUZ5iyPzZpjqx4G8uB5TWxXPDwibLcVa7k,43
+modal-0.73.55.dist-info/RECORD,,

modal_version/_version_generated.py

@@ -1,4 +1,4 @@
 # Copyright Modal Labs 2025
 
 # Note: Reset this value to -1 whenever you make a minor `0.X` release of the client.
-build_number = 54  # git: 786ca3a
+build_number = 55  # git: 4d645ae