modal 0.66.44__py3-none-any.whl → 0.67.0__py3-none-any.whl

modal/_resolver.py

@@ -130,9 +130,14 @@ class Resolver:
                         raise NotFoundError(exc.message)
                     raise
 
-                # Check that the id of functions and classes didn't change
+                # Check that the id of functions didn't change
                 # Persisted refs are ignored because their life cycle is managed independently.
-                if not obj._is_another_app and existing_object_id is not None and obj.object_id != existing_object_id:
+                if (
+                    not obj._is_another_app
+                    and existing_object_id is not None
+                    and existing_object_id.startswith("fu-")
+                    and obj.object_id != existing_object_id
+                ):
                     raise Exception(
                         f"Tried creating an object using existing id {existing_object_id}"
                         f" but it has id {obj.object_id}"

modal/_runtime/container_io_manager.py

@@ -452,7 +452,7 @@ class _ContainerIOManager:
             await asyncio.sleep(DYNAMIC_CONCURRENCY_INTERVAL_SECS)
 
     async def get_app_objects(self) -> RunningApp:
-        req = api_pb2.AppGetObjectsRequest(app_id=self.app_id, include_unindexed=True)
+        req = api_pb2.AppGetObjectsRequest(app_id=self.app_id, include_unindexed=True, only_class_function=True)
         resp = await retry_transient_errors(self._client.stub.AppGetObjects, req)
         logger.debug(f"AppGetObjects received {len(resp.items)} objects for app {self.app_id}")
 

modal/app.py

@@ -177,7 +177,8 @@ class _App:
 
     _name: Optional[str]
     _description: Optional[str]
-    _indexed_objects: Dict[str, _Object]
+    _functions: Dict[str, _Function]
+    _classes: Dict[str, _Cls]
 
     _image: Optional[_Image]
     _mounts: Sequence[_Mount]
@@ -223,7 +224,8 @@ class _App:
         if image is not None and not isinstance(image, _Image):
             raise InvalidError("image has to be a modal Image or AioImage object")
 
-        self._indexed_objects = {}
+        self._functions = {}
+        self._classes = {}
         self._image = image
         self._mounts = mounts
         self._secrets = secrets
@@ -312,6 +314,7 @@ class _App:
             raise InvalidError(f"App attribute `{key}` with value {value!r} is not a valid Modal object")
 
     def _add_object(self, tag, obj):
+        # TODO(erikbern): replace this with _add_function and _add_class
         if self._running_app:
             # If this is inside a container, then objects can be defined after app initialization.
             # So we may have to initialize objects once they get bound to the app.
@@ -320,7 +323,12 @@ class _App:
                 metadata: Message = self._running_app.object_handle_metadata[object_id]
                 obj._hydrate(object_id, self._client, metadata)
 
-        self._indexed_objects[tag] = obj
+        if isinstance(obj, _Function):
+            self._functions[tag] = obj
+        elif isinstance(obj, _Cls):
+            self._classes[tag] = obj
+        else:
+            raise RuntimeError(f"Expected `obj` to be a _Function or _Cls (got {type(obj)}")
 
     def __getitem__(self, tag: str):
         deprecation_error((2024, 3, 25), _app_attr_error)
@@ -334,7 +342,7 @@ class _App:
         if tag.startswith("__"):
             # Hacky way to avoid certain issues, e.g. pickle will try to look this up
             raise AttributeError(f"App has no member {tag}")
-        if tag not in self._indexed_objects:
+        if tag not in self._functions or tag not in self._classes:
             # Primarily to make hasattr work
             raise AttributeError(f"App has no member {tag}")
         deprecation_error((2024, 3, 25), _app_attr_error)
@@ -360,7 +368,9 @@ class _App:
 
     def _uncreate_all_objects(self):
         # TODO(erikbern): this doesn't unhydrate objects that aren't tagged
-        for obj in self._indexed_objects.values():
+        for obj in self._functions.values():
+            obj._unhydrate()
+        for obj in self._classes.values():
             obj._unhydrate()
 
     @asynccontextmanager
@@ -459,18 +469,17 @@ class _App:
         return [m for m in all_mounts if m.is_local()]
 
     def _add_function(self, function: _Function, is_web_endpoint: bool):
-        if function.tag in self._indexed_objects:
-            old_function = self._indexed_objects[function.tag]
-            if isinstance(old_function, _Function):
-                if not is_notebook():
-                    logger.warning(
-                        f"Warning: Tag '{function.tag}' collision!"
-                        " Overriding existing function "
-                        f"[{old_function._info.module_name}].{old_function._info.function_name}"
-                        f" with new function [{function._info.module_name}].{function._info.function_name}"
-                    )
-            else:
-                logger.warning(f"Warning: tag {function.tag} exists but is overridden by function")
+        if function.tag in self._functions:
+            if not is_notebook():
+                old_function: _Function = self._functions[function.tag]
+                logger.warning(
+                    f"Warning: Tag '{function.tag}' collision!"
+                    " Overriding existing function "
+                    f"[{old_function._info.module_name}].{old_function._info.function_name}"
+                    f" with new function [{function._info.module_name}].{function._info.function_name}"
+                )
+        if function.tag in self._classes:
+            logger.warning(f"Warning: tag {function.tag} exists but is overridden by function")
 
         self._add_object(function.tag, function)
         if is_web_endpoint:
@@ -484,21 +493,22 @@ class _App:
         _App._container_app = running_app
 
         # Hydrate objects on app
+        indexed_objects = dict(**self._functions, **self._classes)
         for tag, object_id in running_app.tag_to_object_id.items():
-            if tag in self._indexed_objects:
-                obj = self._indexed_objects[tag]
+            if tag in indexed_objects:
+                obj = indexed_objects[tag]
                 handle_metadata = running_app.object_handle_metadata[object_id]
                 obj._hydrate(object_id, client, handle_metadata)
 
     @property
     def registered_functions(self) -> Dict[str, _Function]:
         """All modal.Function objects registered on the app."""
-        return {tag: obj for tag, obj in self._indexed_objects.items() if isinstance(obj, _Function)}
+        return self._functions
 
     @property
     def registered_classes(self) -> Dict[str, _Function]:
         """All modal.Cls objects registered on the app."""
-        return {tag: obj for tag, obj in self._indexed_objects.items() if isinstance(obj, _Cls)}
+        return self._classes
 
     @property
     def registered_entrypoints(self) -> Dict[str, _LocalEntrypoint]:
@@ -507,7 +517,11 @@ class _App:
 
     @property
     def indexed_objects(self) -> Dict[str, _Object]:
-        return self._indexed_objects
+        deprecation_warning(
+            (2024, 11, 25),
+            "`app.indexed_objects` is deprecated! Use `app.registered_functions` or `app.registered_classes` instead.",
+        )
+        return dict(**self._functions, **self._classes)
 
     @property
     def registered_web_endpoints(self) -> List[str]:
@@ -1002,8 +1016,9 @@ class _App:
             bar.remote()
         ```
         """
-        for tag, object in other_app._indexed_objects.items():
-            existing_object = self._indexed_objects.get(tag)
+        indexed_objects = dict(**other_app._functions, **other_app._classes)
+        for tag, object in indexed_objects.items():
+            existing_object = indexed_objects.get(tag)
             if existing_object and existing_object != object:
                 logger.warning(
                     f"Named app object {tag} with existing value {existing_object} is being "

modal/app.pyi

@@ -76,7 +76,8 @@ class _App:
     _container_app: typing.ClassVar[typing.Optional[modal.running_app.RunningApp]]
     _name: typing.Optional[str]
     _description: typing.Optional[str]
-    _indexed_objects: typing.Dict[str, modal.object._Object]
+    _functions: typing.Dict[str, modal.functions._Function]
+    _classes: typing.Dict[str, modal.cls._Cls]
     _image: typing.Optional[modal.image._Image]
     _mounts: typing.Sequence[modal.mount._Mount]
     _secrets: typing.Sequence[modal.secret._Secret]
@@ -270,7 +271,8 @@ class App:
     _container_app: typing.ClassVar[typing.Optional[modal.running_app.RunningApp]]
     _name: typing.Optional[str]
     _description: typing.Optional[str]
-    _indexed_objects: typing.Dict[str, modal.object.Object]
+    _functions: typing.Dict[str, modal.functions.Function]
+    _classes: typing.Dict[str, modal.cls.Cls]
     _image: typing.Optional[modal.image.Image]
     _mounts: typing.Sequence[modal.mount.Mount]
     _secrets: typing.Sequence[modal.secret.Secret]

modal/cli/config.py

@@ -3,6 +3,7 @@ import typer
 from rich.console import Console
 
 from modal.config import _profile, _store_user_config, config
+from modal.environments import Environment
 
 config_cli = typer.Typer(
     name="config",
@@ -38,6 +39,8 @@ when running a command that requires an environment.
 
 @config_cli.command(help=SET_DEFAULT_ENV_HELP)
 def set_environment(environment_name: str):
+    # Confirm that the environment exists by looking it up
+    Environment.lookup(environment_name)
     _store_user_config({"environment": environment_name})
     typer.echo(f"New default environment for profile {_profile}: {environment_name}")
 

modal/cli/import_refs.py

@@ -110,7 +110,7 @@ def get_by_object_path(obj: Any, obj_path: str) -> Optional[Any]:
 def _infer_function_or_help(
     app: App, module, accept_local_entrypoint: bool, accept_webhook: bool
 ) -> Union[Function, LocalEntrypoint]:
-    function_choices = set(tag for tag, func in app.registered_functions.items() if not func.info.is_service_class())
+    function_choices = set(app.registered_functions)
     if not accept_webhook:
         function_choices -= set(app.registered_web_endpoints)
     if accept_local_entrypoint:
@@ -154,7 +154,7 @@ Registered functions and local entrypoints on the selected app are:
         # entrypoint is in entrypoint registry, for now
         return app.registered_entrypoints[function_name]
 
-    function = app.indexed_objects[function_name]  # functions are in blueprint
+    function = app.registered_functions[function_name]
     assert isinstance(function, Function)
     return function
 

modal/cli/launch.py

@@ -25,7 +25,7 @@ launch_cli = Typer(
 )
 
 
-def _launch_program(name: str, filename: str, args: Dict[str, Any]) -> None:
+def _launch_program(name: str, filename: str, detach: bool, args: Dict[str, Any]) -> None:
     os.environ["MODAL_LAUNCH_ARGS"] = json.dumps(args)
 
     program_path = str(Path(__file__).parent / "programs" / filename)
@@ -37,7 +37,7 @@ def _launch_program(name: str, filename: str, args: Dict[str, Any]) -> None:
     func = entrypoint.info.raw_f
     isasync = inspect.iscoroutinefunction(func)
     with enable_output():
-        with run_app(app):
+        with run_app(app, detach=detach):
             try:
                 if isasync:
                     asyncio.run(func())
@@ -57,6 +57,7 @@ def jupyter(
     add_python: Optional[str] = "3.11",
     mount: Optional[str] = None,  # Create a `modal.Mount` from a local directory.
     volume: Optional[str] = None,  # Attach a persisted `modal.Volume` by name (creating if missing).
+    detach: bool = False,  # Run the app in "detached" mode to persist after local client disconnects
 ):
     args = {
         "cpu": cpu,
@@ -68,7 +69,7 @@ def jupyter(
         "mount": mount,
         "volume": volume,
     }
-    _launch_program("jupyter", "run_jupyter.py", args)
+    _launch_program("jupyter", "run_jupyter.py", detach, args)
 
 
 @launch_cli.command(name="vscode", help="Start Visual Studio Code on Modal.")
@@ -79,6 +80,7 @@ def vscode(
     timeout: int = 3600,
     mount: Optional[str] = None,  # Create a `modal.Mount` from a local directory.
     volume: Optional[str] = None,  # Attach a persisted `modal.Volume` by name (creating if missing).
+    detach: bool = False,  # Run the app in "detached" mode to persist after local client disconnects
 ):
     args = {
         "cpu": cpu,
@@ -88,4 +90,4 @@ def vscode(
         "mount": mount,
         "volume": volume,
     }
-    _launch_program("vscode", "vscode.py", args)
+    _launch_program("vscode", "vscode.py", detach, args)

modal/cli/run.py

@@ -136,7 +136,13 @@ def _get_clean_app_description(func_ref: str) -> str:
 
 
 def _get_click_command_for_function(app: App, function_tag):
-    function = app.indexed_objects[function_tag]
+    function = app.registered_functions.get(function_tag)
+    if not function or (isinstance(function, Function) and function.info.user_cls is not None):
+        # This is either a function_tag for a class method function (e.g MyClass.foo) or a function tag for a
+        # class service function (MyClass.*)
+        class_name, method_name = function_tag.rsplit(".", 1)
+        if not function:
+            function = app.registered_functions.get(f"{class_name}.*")
     assert isinstance(function, Function)
     function = typing.cast(Function, function)
     if function.is_generator:
@@ -144,12 +150,19 @@ def _get_click_command_for_function(app: App, function_tag):
 
     signature: Dict[str, ParameterMetadata]
     cls: Optional[Cls] = None
-    method_name: Optional[str] = None
     if function.info.user_cls is not None:
-        class_name, method_name = function_tag.rsplit(".", 1)
-        cls = typing.cast(Cls, app.indexed_objects[class_name])
+        cls = typing.cast(Cls, app.registered_classes[class_name])
         cls_signature = _get_signature(function.info.user_cls)
-        fun_signature = _get_signature(function.info.raw_f, is_method=True)
+        if method_name == "*":
+            method_names = list(cls._get_partial_functions().keys())
+            if len(method_names) == 1:
+                method_name = method_names[0]
+            else:
+                class_name = function.info.user_cls.__name__
+                raise click.UsageError(
+                    f"Please specify a specific method of {class_name} to run, e.g. `modal run foo.py::MyClass.bar`"  # noqa: E501
+                )
+        fun_signature = _get_signature(getattr(cls, method_name).info.raw_f, is_method=True)
         signature = dict(**cls_signature, **fun_signature)  # Pool all arguments
         # TODO(erikbern): assert there's no overlap?
     else:

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.44",
+        version: str = "0.67.0",
     ): ...
     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.44",
+        version: str = "0.67.0",
     ): ...
     def is_closed(self) -> bool: ...
     @property

modal/cls.py

@@ -244,7 +244,7 @@ class _Cls(_Object, type_prefix="cs"):
     _class_service_function: Optional[
         _Function
     ]  # The _Function serving *all* methods of the class, used for version >=v0.63
-    _method_functions: Dict[str, _Function]  # Placeholder _Functions for each method
+    _method_functions: Optional[Dict[str, _Function]] = None  # Placeholder _Functions for each method
     _options: Optional[api_pb2.FunctionOptions]
     _callables: Dict[str, Callable[..., Any]]
     _from_other_workspace: Optional[bool]  # Functions require FunctionBindParams before invocation.
@@ -253,7 +253,6 @@ class _Cls(_Object, type_prefix="cs"):
     def _initialize_from_empty(self):
         self._user_cls = None
         self._class_service_function = None
-        self._method_functions = {}
         self._options = None
         self._callables = {}
         self._from_other_workspace = None
@@ -273,28 +272,46 @@ class _Cls(_Object, type_prefix="cs"):
 
     def _hydrate_metadata(self, metadata: Message):
         assert isinstance(metadata, api_pb2.ClassHandleMetadata)
-
-        for method in metadata.methods:
-            if method.function_name in self._method_functions:
-                # This happens when the class is loaded locally
-                # since each function will already be a loaded dependency _Function
-                self._method_functions[method.function_name]._hydrate(
-                    method.function_id, self._client, method.function_handle_metadata
-                )
+        if (
+            self._class_service_function
+            and self._class_service_function._method_handle_metadata
+            and len(self._class_service_function._method_handle_metadata)
+        ):
+            # The class only has a class service service function and no method placeholders (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
+                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)
+                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
+                    )
+        elif self._class_service_function:
+            # A class with a class service function and method placeholder functions
+            self._method_functions = {}
+            for method in metadata.methods:
                 self._method_functions[method.function_name] = _Function._new_hydrated(
-                    method.function_id, self._client, method.function_handle_metadata
+                    self._class_service_function.object_id, self._client, method.function_handle_metadata
                 )
-
-    def _get_metadata(self) -> api_pb2.ClassHandleMetadata:
-        class_handle_metadata = api_pb2.ClassHandleMetadata()
-        for f_name, f in self._method_functions.items():
-            class_handle_metadata.methods.append(
-                api_pb2.ClassMethod(
-                    function_name=f_name, function_id=f.object_id, function_handle_metadata=f._get_metadata()
+        else:
+            # pre 0.63 class that does not have a class service function and only method functions
+            self._method_functions = {}
+            for method in metadata.methods:
+                self._method_functions[method.function_name] = _Function._new_hydrated(
+                    method.function_id, self._client, method.function_handle_metadata
                 )
-            )
-        return class_handle_metadata
 
     @staticmethod
     def validate_construction_mechanism(user_cls):
@@ -327,16 +344,17 @@ class _Cls(_Object, type_prefix="cs"):
         # validate signature
         _Cls.validate_construction_mechanism(user_cls)
 
-        functions: Dict[str, _Function] = {}
+        method_functions: Dict[str, _Function] = {}
         partial_functions: 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_old(user_cls, method_name, partial_function)
-            app._add_function(method_function, is_web_endpoint=partial_function.webhook_config is not None)
+            method_function = class_service_function._bind_method(user_cls, method_name, partial_function)
+            if partial_function.webhook_config is not None:
+                app._web_endpoints.append(method_function.tag)
             partial_function.wrapped = True
-            functions[method_name] = method_function
+            method_functions[method_name] = method_function
 
         # Disable the warning that these are not wrapped
         for partial_function in _find_partial_methods_for_user_cls(user_cls, ~_PartialFunctionFlags.FUNCTION).values():
@@ -344,31 +362,17 @@ class _Cls(_Object, type_prefix="cs"):
 
         # Get all callables
         callables: Dict[str, Callable] = {
-            k: pf.raw_f for k, pf in _find_partial_methods_for_user_cls(user_cls, ~_PartialFunctionFlags(0)).items()
+            k: pf.raw_f for k, pf in _find_partial_methods_for_user_cls(user_cls, _PartialFunctionFlags.all()).items()
         }
 
         def _deps() -> List[_Function]:
-            return [class_service_function] + list(functions.values())
+            return [class_service_function]
 
         async def _load(self: "_Cls", resolver: Resolver, existing_object_id: Optional[str]):
-            req = api_pb2.ClassCreateRequest(app_id=resolver.app_id, existing_class_id=existing_object_id)
-            for f_name, f in self._method_functions.items():
-                req.methods.append(
-                    api_pb2.ClassMethod(
-                        function_name=f_name, function_id=f.object_id, function_handle_metadata=f._get_metadata()
-                    )
-                )
+            req = api_pb2.ClassCreateRequest(
+                app_id=resolver.app_id, existing_class_id=existing_object_id, only_class_function=True
+            )
             resp = await resolver.client.stub.ClassCreate(req)
-            # Even though we already have the function_handle_metadata for this method locally,
-            # The RPC is going to replace it with function_handle_metadata derived from the server.
-            # We need to overwrite the definition_id sent back from the server here with the definition_id
-            # previously stored in function metadata, which may have been sent back from FunctionCreate.
-            # The problem is that this metadata propagates back and overwrites the metadata on the Function
-            # object itself. This is really messy. Maybe better to exclusively populate the method metadata
-            # from the function metadata we already have locally? Really a lot to clean up here...
-            for method in resp.handle_metadata.methods:
-                f_metadata = self._method_functions[method.function_name]._get_metadata()
-                method.function_handle_metadata.definition_id = f_metadata.definition_id
             self._hydrate(resp.class_id, resolver.client, resp.handle_metadata)
 
         rep = f"Cls({user_cls.__name__})"
@@ -376,7 +380,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 = functions
+        cls._method_functions = method_functions
         cls._callables = callables
         cls._from_other_workspace = False
         return cls
@@ -415,6 +419,7 @@ class _Cls(_Object, type_prefix="cs"):
                 environment_name=_environment_name,
                 lookup_published=workspace is not None,
                 workspace_name=workspace,
+                only_class_function=True,
             )
             try:
                 response = await retry_transient_errors(resolver.client.stub.ClassGet, request)

modal/cls.pyi

@@ -86,7 +86,7 @@ class Obj:
 class _Cls(modal.object._Object):
     _user_cls: typing.Optional[type]
     _class_service_function: typing.Optional[modal.functions._Function]
-    _method_functions: typing.Dict[str, modal.functions._Function]
+    _method_functions: typing.Optional[typing.Dict[str, modal.functions._Function]]
     _options: typing.Optional[modal_proto.api_pb2.FunctionOptions]
     _callables: typing.Dict[str, typing.Callable[..., typing.Any]]
     _from_other_workspace: typing.Optional[bool]
@@ -96,7 +96,6 @@ class _Cls(modal.object._Object):
     def _initialize_from_other(self, other: _Cls): ...
     def _get_partial_functions(self) -> typing.Dict[str, modal.partial_function._PartialFunction]: ...
     def _hydrate_metadata(self, metadata: google.protobuf.message.Message): ...
-    def _get_metadata(self) -> modal_proto.api_pb2.ClassHandleMetadata: ...
     @staticmethod
     def validate_construction_mechanism(user_cls): ...
     @staticmethod
@@ -139,7 +138,7 @@ class _Cls(modal.object._Object):
 class Cls(modal.object.Object):
     _user_cls: typing.Optional[type]
     _class_service_function: typing.Optional[modal.functions.Function]
-    _method_functions: typing.Dict[str, modal.functions.Function]
+    _method_functions: typing.Optional[typing.Dict[str, modal.functions.Function]]
     _options: typing.Optional[modal_proto.api_pb2.FunctionOptions]
     _callables: typing.Dict[str, typing.Callable[..., typing.Any]]
     _from_other_workspace: typing.Optional[bool]
@@ -150,7 +149,6 @@ class Cls(modal.object.Object):
     def _initialize_from_other(self, other: Cls): ...
     def _get_partial_functions(self) -> typing.Dict[str, modal.partial_function.PartialFunction]: ...
     def _hydrate_metadata(self, metadata: google.protobuf.message.Message): ...
-    def _get_metadata(self) -> modal_proto.api_pb2.ClassHandleMetadata: ...
     @staticmethod
     def validate_construction_mechanism(user_cls): ...
     @staticmethod

modal/config.py

@@ -268,7 +268,7 @@ class Config:
         return repr(self.to_dict())
 
     def to_dict(self):
-        return {key: self.get(key) for key in _SETTINGS.keys()}
+        return {key: self.get(key) for key in sorted(_SETTINGS)}
 
 
 config = Config()