modal 0.72.14__py3-none-any.whl → 0.72.16__py3-none-any.whl

modal/app.py

@@ -365,6 +365,7 @@ class _App:
         show_progress: Optional[bool] = None,
         detach: bool = False,
         interactive: bool = False,
+        environment_name: Optional[str] = None,
     ) -> AsyncGenerator["_App", None]:
         """Context manager that runs an app on Modal.
 
@@ -420,7 +421,9 @@ class _App:
         elif show_progress is False:
             deprecation_warning((2024, 11, 20), "`show_progress=False` is deprecated (and has no effect)")
 
-        async with _run_app(self, client=client, detach=detach, interactive=interactive):
+        async with _run_app(
+            self, client=client, detach=detach, interactive=interactive, environment_name=environment_name
+        ):
             yield self
 
     def _get_default_image(self):
@@ -504,7 +507,7 @@ class _App:
         return self._functions
 
     @property
-    def registered_classes(self) -> dict[str, _Function]:
+    def registered_classes(self) -> dict[str, _Cls]:
         """All modal.Cls objects registered on the app."""
         return self._classes
 

modal/app.pyi

@@ -132,6 +132,7 @@ class _App:
         show_progress: typing.Optional[bool] = None,
         detach: bool = False,
         interactive: bool = False,
+        environment_name: typing.Optional[str] = None,
     ) -> typing.AsyncContextManager[_App]: ...
     def _get_default_image(self): ...
     def _get_watch_mounts(self): ...
@@ -141,7 +142,7 @@ class _App:
     @property
     def registered_functions(self) -> dict[str, modal.functions._Function]: ...
     @property
-    def registered_classes(self) -> dict[str, modal.functions._Function]: ...
+    def registered_classes(self) -> dict[str, modal.cls._Cls]: ...
     @property
     def registered_entrypoints(self) -> dict[str, _LocalEntrypoint]: ...
     @property
@@ -352,6 +353,7 @@ class App:
             show_progress: typing.Optional[bool] = None,
             detach: bool = False,
             interactive: bool = False,
+            environment_name: typing.Optional[str] = None,
         ) -> synchronicity.combined_types.AsyncAndBlockingContextManager[App]: ...
         def aio(
             self,
@@ -359,6 +361,7 @@ class App:
             show_progress: typing.Optional[bool] = None,
             detach: bool = False,
             interactive: bool = False,
+            environment_name: typing.Optional[str] = None,
         ) -> typing.AsyncContextManager[App]: ...
 
     run: __run_spec
@@ -371,7 +374,7 @@ class App:
     @property
     def registered_functions(self) -> dict[str, modal.functions.Function]: ...
     @property
-    def registered_classes(self) -> dict[str, modal.functions.Function]: ...
+    def registered_classes(self) -> dict[str, modal.cls.Cls]: ...
     @property
     def registered_entrypoints(self) -> dict[str, LocalEntrypoint]: ...
     @property

modal/cli/import_refs.py

@@ -9,8 +9,11 @@ These functions are only called by the Modal CLI, not in tasks.
 
 import dataclasses
 import importlib
+import importlib.util
 import inspect
 import sys
+import types
+from dataclasses import dataclass
 from pathlib import Path
 from typing import Any, Optional, Union
 
@@ -19,6 +22,7 @@ from rich.console import Console
 from rich.markdown import Markdown
 
 from modal.app import App, LocalEntrypoint
+from modal.cls import Cls
 from modal.exception import InvalidError, _CliUserExecutionError
 from modal.functions import Function
 
@@ -26,6 +30,12 @@ from modal.functions import Function
 @dataclasses.dataclass
 class ImportRef:
     file_or_module: str
+
+    # object_path is a .-delimited path to the object to execute, or a parent from which to infer the object
+    # e.g.
+    # function or local_entrypoint in module scope
+    # app in module scope [+ method name]
+    # app [+ function/entrypoint on that app]
     object_path: Optional[str]
 
 
@@ -62,11 +72,14 @@ def import_file_or_module(file_or_module: str):
         sys.path.insert(0, str(full_path.parent))
 
         module_name = inspect.getmodulename(file_or_module)
+        assert module_name is not None
         # Import the module - see https://docs.python.org/3/library/importlib.html#importing-a-source-file-directly
         spec = importlib.util.spec_from_file_location(module_name, file_or_module)
+        assert spec is not None
         module = importlib.util.module_from_spec(spec)
         sys.modules[module_name] = module
         try:
+            assert spec.loader
             spec.loader.exec_module(module)
         except Exception as exc:
             raise _CliUserExecutionError(str(full_path)) from exc
@@ -79,23 +92,39 @@ def import_file_or_module(file_or_module: str):
     return module
 
 
-def get_by_object_path(obj: Any, obj_path: str) -> Optional[Any]:
+@dataclass
+class MethodReference:
+    """This helps with deferring method reference until after the class gets instantiated by the CLI"""
+
+    cls: Cls
+    method_name: str
+
+
+def get_by_object_path(obj: Any, obj_path: str) -> Union[Function, LocalEntrypoint, MethodReference, App, None]:
     # Try to evaluate a `.`-delimited object path in a Modal context
     # With the caveat that some object names can actually have `.` in their name (lifecycled methods' tags)
 
     # Note: this is eager, so no backtracking is performed in case an
     # earlier match fails at some later point in the path expansion
     prefix = ""
-    for segment in obj_path.split("."):
+    obj_path_segments = obj_path.split(".")
+    for i, segment in enumerate(obj_path_segments):
         attr = prefix + segment
+        if isinstance(obj, App):
+            if attr in obj.registered_entrypoints:
+                # local entrypoints can't be accessed via getattr
+                obj = obj.registered_entrypoints[attr]
+                continue
+        if isinstance(obj, Cls):
+            remaining_segments = obj_path_segments[i:]
+            remaining_path = ".".join(remaining_segments)
+            if len(remaining_segments) > 1:
+                raise ValueError(f"{obj._get_name()} is a class, but {remaining_path} is not a method reference")
+            # TODO: add method inference here?
+            return MethodReference(obj, remaining_path)
+
         try:
-            if isinstance(obj, App):
-                if attr in obj.registered_entrypoints:
-                    # local entrypoints are not on stub blueprint
-                    obj = obj.registered_entrypoints[attr]
-                    continue
             obj = getattr(obj, attr)
-
         except Exception:
             prefix = f"{prefix}{segment}."
         else:
@@ -109,54 +138,62 @@ 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(app.registered_functions)
-    if not accept_webhook:
-        function_choices -= set(app.registered_web_endpoints)
-    if accept_local_entrypoint:
-        function_choices |= set(app.registered_entrypoints.keys())
+) -> Union[Function, LocalEntrypoint, MethodReference]:
+    """Using only an app - automatically infer a single "runnable" for a `modal run` invocation
 
-    sorted_function_choices = sorted(function_choices)
-    registered_functions_str = "\n".join(sorted_function_choices)
+    If a single runnable can't be determined, show CLI help indicating valid choices.
+    """
     filtered_local_entrypoints = [
-        name
-        for name, entrypoint in app.registered_entrypoints.items()
+        entrypoint
+        for entrypoint in app.registered_entrypoints.values()
         if entrypoint.info.module_name == module.__name__
     ]
 
-    if accept_local_entrypoint and len(filtered_local_entrypoints) == 1:
-        # If there is just a single local entrypoint in the target module, use
-        # that regardless of other functions.
-        function_name = list(filtered_local_entrypoints)[0]
-    elif accept_local_entrypoint and len(app.registered_entrypoints) == 1:
-        # Otherwise, if there is just a single local entrypoint in the stub as a whole,
-        # use that one.
-        function_name = list(app.registered_entrypoints.keys())[0]
-    elif len(function_choices) == 1:
-        function_name = sorted_function_choices[0]
-    elif len(function_choices) == 0:
+    if accept_local_entrypoint:
+        if len(filtered_local_entrypoints) == 1:
+            # If there is just a single local entrypoint in the target module, use
+            # that regardless of other functions.
+            return filtered_local_entrypoints[0]
+        elif len(app.registered_entrypoints) == 1:
+            # Otherwise, if there is just a single local entrypoint in the app as a whole,
+            # use that one.
+            return list(app.registered_entrypoints.values())[0]
+
+    # TODO: refactor registered_functions to only contain function services, not class services
+    function_choices: dict[str, Union[Function, LocalEntrypoint, MethodReference]] = {
+        name: f for name, f in app.registered_functions.items() if not name.endswith(".*")
+    }
+    for cls_name, cls in app.registered_classes.items():
+        for method_name in cls._get_method_names():
+            function_choices[f"{cls_name}.{method_name}"] = MethodReference(cls, method_name)
+
+    if not accept_webhook:
+        for web_endpoint_name in app.registered_web_endpoints:
+            function_choices.pop(web_endpoint_name, None)
+
+    if accept_local_entrypoint:
+        function_choices.update(app.registered_entrypoints)
+
+    if len(function_choices) == 1:
+        return list(function_choices.values())[0]
+
+    if len(function_choices) == 0:
         if app.registered_web_endpoints:
             err_msg = "Modal app has only web endpoints. Use `modal serve` instead of `modal run`."
         else:
             err_msg = "Modal app has no registered functions. Nothing to run."
         raise click.UsageError(err_msg)
-    else:
-        help_text = f"""You need to specify a Modal function or local entrypoint to run, e.g.
+
+    # there are multiple choices - we can't determine which one to use:
+    registered_functions_str = "\n".join(sorted(function_choices))
+    help_text = f"""You need to specify a Modal function or local entrypoint to run, e.g.
 
 modal run app.py::my_function [...args]
 
 Registered functions and local entrypoints on the selected app are:
 {registered_functions_str}
 """
-        raise click.UsageError(help_text)
-
-    if function_name in app.registered_entrypoints:
-        # entrypoint is in entrypoint registry, for now
-        return app.registered_entrypoints[function_name]
-
-    function = app.registered_functions[function_name]
-    assert isinstance(function, Function)
-    return function
+    raise click.UsageError(help_text)
 
 
 def _show_no_auto_detectable_app(app_ref: ImportRef) -> None:
@@ -223,30 +260,60 @@ You would run foo as [bold green]{base_cmd} app.py::foo[/bold green]"""
     error_console.print(guidance_msg)
 
 
-def import_function(
-    func_ref: str, base_cmd: str, accept_local_entrypoint=True, accept_webhook=False
-) -> Union[Function, LocalEntrypoint]:
+def _import_object(func_ref, base_cmd):
     import_ref = parse_import_ref(func_ref)
-
     module = import_file_or_module(import_ref.file_or_module)
-    app_or_function = get_by_object_path(module, import_ref.object_path or DEFAULT_APP_NAME)
+    app_function_or_method_ref = get_by_object_path(module, import_ref.object_path or DEFAULT_APP_NAME)
 
-    if app_or_function is None:
+    if app_function_or_method_ref is None:
         _show_function_ref_help(import_ref, base_cmd)
-        sys.exit(1)
+        raise SystemExit(1)
+
+    return app_function_or_method_ref, module
+
 
-    if isinstance(app_or_function, App):
+def _infer_runnable(
+    partial_obj: Union[App, Function, MethodReference, LocalEntrypoint],
+    module: types.ModuleType,
+    accept_local_entrypoint: bool = True,
+    accept_webhook: bool = False,
+) -> tuple[App, Union[Function, MethodReference, LocalEntrypoint]]:
+    if isinstance(partial_obj, App):
         # infer function or display help for how to select one
-        app = app_or_function
+        app = partial_obj
         function_handle = _infer_function_or_help(app, module, accept_local_entrypoint, accept_webhook)
-        return function_handle
-    elif isinstance(app_or_function, Function):
-        return app_or_function
-    elif isinstance(app_or_function, LocalEntrypoint):
+        return app, function_handle
+    elif isinstance(partial_obj, Function):
+        return partial_obj.app, partial_obj
+    elif isinstance(partial_obj, MethodReference):
+        return partial_obj.cls._get_app(), partial_obj
+    elif isinstance(partial_obj, LocalEntrypoint):
         if not accept_local_entrypoint:
             raise click.UsageError(
-                f"{func_ref} is not a Modal Function (a Modal local_entrypoint can't be used in this context)"
+                f"{partial_obj.info.function_name} is not a Modal Function "
+                f"(a Modal local_entrypoint can't be used in this context)"
             )
-        return app_or_function
+        return partial_obj.app, partial_obj
     else:
-        raise click.UsageError(f"{app_or_function} is not a Modal entity (should be an App or Function)")
+        raise click.UsageError(
+            f"{partial_obj} is not a Modal entity (should be an App, Local entrypoint, " "Function or Class/Method)"
+        )
+
+
+def import_and_infer(
+    func_ref: str, base_cmd: str, accept_local_entrypoint=True, accept_webhook=False
+) -> tuple[App, Union[Function, LocalEntrypoint, MethodReference]]:
+    """Takes a function ref string and returns something "runnable"
+
+    The function ref can leave out partial information (apart from the file name) as
+    long as the runnable is uniquely identifiable by the provided information.
+
+    When there are multiple runnables within the provided ref, the following rules should
+    be followed:
+
+    1. if there is a single local_entrypoint, that one is used
+    2. if there is a single {function, class} that one is used
+    3. if there is a single method (within a class) that one is used
+    """
+    app_function_or_method_ref, module = _import_object(func_ref, base_cmd)
+    return _infer_runnable(app_function_or_method_ref, module, accept_local_entrypoint, accept_webhook)

modal/cli/launch.py

@@ -8,11 +8,11 @@ from typing import Any, Optional
 
 from typer import Typer
 
-from ..app import App
+from ..app import LocalEntrypoint
 from ..exception import _CliUserExecutionError
 from ..output import enable_output
 from ..runner import run_app
-from .import_refs import import_function
+from .import_refs import import_and_infer
 
 launch_cli = Typer(
     name="launch",
@@ -29,8 +29,10 @@ def _launch_program(name: str, filename: str, detach: bool, args: dict[str, Any]
     os.environ["MODAL_LAUNCH_ARGS"] = json.dumps(args)
 
     program_path = str(Path(__file__).parent / "programs" / filename)
-    entrypoint = import_function(program_path, "modal launch")
-    app: App = entrypoint.app
+    app, entrypoint = import_and_infer(program_path, "modal launch")
+    if not isinstance(entrypoint, LocalEntrypoint):
+        raise ValueError(f"{program_path} has no single local_entrypoint")
+
     app.set_description(f"modal launch {name}")
 
     # `launch/` scripts must have a `local_entrypoint()` with no args, for simplicity here.

modal/cli/run.py

@@ -7,7 +7,6 @@ import re
 import shlex
 import sys
 import time
-import typing
 from functools import partial
 from typing import Any, Callable, Optional, get_type_hints
 
@@ -15,7 +14,6 @@ import click
 import typer
 from typing_extensions import TypedDict
 
-from .. import Cls
 from ..app import App, LocalEntrypoint
 from ..config import config
 from ..environments import ensure_env
@@ -26,7 +24,7 @@ from ..output import enable_output
 from ..runner import deploy_app, interactive_shell, run_app
 from ..serving import serve_app
 from ..volume import Volume
-from .import_refs import import_app, import_function
+from .import_refs import MethodReference, import_and_infer, import_app
 from .utils import ENV_OPTION, ENV_OPTION_HELP, is_tty, stream_app_logs
 
 
@@ -145,39 +143,7 @@ def _write_local_result(result_path: str, res: Any):
         fid.write(res)
 
 
-def _get_click_command_for_function(app: App, 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:
-        raise InvalidError("`modal run` is not supported for generator functions")
-
-    signature: dict[str, ParameterMetadata]
-    cls: Optional[Cls] = None
-    if function.info.user_cls is not None:
-        cls = typing.cast(Cls, app.registered_classes[class_name])
-        cls_signature = _get_signature(function.info.user_cls)
-        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:
-        signature = _get_signature(function.info.raw_f)
-
+def _make_click_function(app, inner: Callable[[dict[str, Any]], Any]):
     @click.pass_context
     def f(ctx, **kwargs):
         show_progress: bool = ctx.obj["show_progress"]
@@ -188,21 +154,65 @@ def _get_click_command_for_function(app: App, function_tag):
                 environment_name=ctx.obj["env"],
                 interactive=ctx.obj["interactive"],
             ):
-                if cls is None:
-                    res = function.remote(**kwargs)
-                else:
-                    # unpool class and method arguments
-                    # TODO(erikbern): this code is a bit hacky
-                    cls_kwargs = {k: kwargs[k] for k in cls_signature}
-                    fun_kwargs = {k: kwargs[k] for k in fun_signature}
-
-                    instance = cls(**cls_kwargs)
-                    method: Function = getattr(instance, method_name)
-                    res = method.remote(**fun_kwargs)
+                res = inner(kwargs)
 
             if result_path := ctx.obj["result_path"]:
                 _write_local_result(result_path, res)
 
+    return f
+
+
+def _get_click_command_for_function(app: App, function: Function):
+    if function.is_generator:
+        raise InvalidError("`modal run` is not supported for generator functions")
+
+    signature: dict[str, ParameterMetadata] = _get_signature(function.info.raw_f)
+
+    def _inner(click_kwargs):
+        return function.remote(**click_kwargs)
+
+    f = _make_click_function(app, _inner)
+
+    with_click_options = _add_click_options(f, signature)
+    return click.command(with_click_options)
+
+
+def _get_click_command_for_cls(app: App, method_ref: MethodReference):
+    signature: dict[str, ParameterMetadata]
+    cls = method_ref.cls
+    method_name = method_ref.method_name
+
+    cls_signature = _get_signature(cls._get_user_cls())
+    partial_functions = cls._get_partial_functions()
+
+    if method_name in ("*", ""):
+        # auto infer method name - not sure if we have to support this...
+        method_names = list(partial_functions.keys())
+        if len(method_names) == 1:
+            method_name = method_names[0]
+        else:
+            raise click.UsageError(
+                f"Please specify a specific method of {cls._get_name()} to run, "
+                f"e.g. `modal run foo.py::MyClass.bar`"  # noqa: E501
+            )
+
+    partial_function = partial_functions[method_name]
+    fun_signature = _get_signature(partial_function._get_raw_f(), is_method=True)
+
+    # TODO(erikbern): assert there's no overlap?
+    signature = dict(**cls_signature, **fun_signature)  # Pool all arguments
+
+    def _inner(click_kwargs):
+        # unpool class and method arguments
+        # TODO(erikbern): this code is a bit hacky
+        cls_kwargs = {k: click_kwargs[k] for k in cls_signature}
+        fun_kwargs = {k: click_kwargs[k] for k in fun_signature}
+
+        instance = cls(**cls_kwargs)
+        method: Function = getattr(instance, method_name)
+        return method.remote(**fun_kwargs)
+
+    f = _make_click_function(app, _inner)
     with_click_options = _add_click_options(f, signature)
     return click.command(with_click_options)
 
@@ -249,16 +259,20 @@ class RunGroup(click.Group):
         # needs to be handled here, and not in the `run` logic below
         ctx.ensure_object(dict)
         ctx.obj["env"] = ensure_env(ctx.params["env"])
-        function_or_entrypoint = import_function(func_ref, accept_local_entrypoint=True, base_cmd="modal run")
-        app: App = function_or_entrypoint.app
+
+        app, imported_object = import_and_infer(func_ref, accept_local_entrypoint=True, base_cmd="modal run")
+
         if app.description is None:
             app.set_description(_get_clean_app_description(func_ref))
-        if isinstance(function_or_entrypoint, LocalEntrypoint):
-            click_command = _get_click_command_for_local_entrypoint(app, function_or_entrypoint)
-        else:
-            tag = function_or_entrypoint.info.get_tag()
-            click_command = _get_click_command_for_function(app, tag)
 
+        if isinstance(imported_object, LocalEntrypoint):
+            click_command = _get_click_command_for_local_entrypoint(app, imported_object)
+        elif isinstance(imported_object, Function):
+            click_command = _get_click_command_for_function(app, imported_object)
+        elif isinstance(imported_object, MethodReference):
+            click_command = _get_click_command_for_cls(app, imported_object)
+        else:
+            raise ValueError(f"{imported_object} is neither function, local entrypoint or class/method")
         return click_command
 
 
@@ -464,11 +478,18 @@ def shell(
             exec(container_id=container_or_function, command=shlex.split(cmd), pty=pty)
             return
 
-        function = import_function(
+        original_app, function_or_method_ref = import_and_infer(
             container_or_function, accept_local_entrypoint=False, accept_webhook=True, base_cmd="modal shell"
         )
-        assert isinstance(function, Function)
-        function_spec: _FunctionSpec = function.spec
+        function_spec: _FunctionSpec
+        if isinstance(function_or_method_ref, MethodReference):
+            class_service_function = function_or_method_ref.cls._get_class_service_function()
+            function_spec = class_service_function.spec
+        elif isinstance(function_or_method_ref, Function):
+            function_spec = function_or_method_ref.spec
+        else:
+            raise ValueError("Referenced entity is neither a function nor a class/method.")
+
         start_shell = partial(
             interactive_shell,
             image=function_spec.image,

modal/client.pyi

@@ -26,7 +26,7 @@ class _Client:
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.72.14"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.72.16"
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -81,7 +81,7 @@ class Client:
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.72.14"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.72.16"
     ): ...
     def is_closed(self) -> bool: ...
     @property

modal/cls.py

@@ -397,6 +397,22 @@ class _Cls(_Object, type_prefix="cs"):
             raise AttributeError("You can only get the partial functions of a local Cls instance")
         return _find_partial_methods_for_user_cls(self._user_cls, _PartialFunctionFlags.all())
 
+    def _get_app(self) -> "modal.app._App":
+        return self._app
+
+    def _get_user_cls(self) -> type:
+        return self._user_cls
+
+    def _get_name(self) -> str:
+        return self._name
+
+    def _get_class_service_function(self) -> "modal.functions._Function":
+        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()
+
     def _hydrate_metadata(self, metadata: Message):
         assert isinstance(metadata, api_pb2.ClassHandleMetadata)
         if (

modal/cls.pyi

@@ -103,6 +103,11 @@ class _Cls(modal.object._Object):
     def _initialize_from_empty(self): ...
     def _initialize_from_other(self, other: _Cls): ...
     def _get_partial_functions(self) -> dict[str, modal.partial_function._PartialFunction]: ...
+    def _get_app(self) -> modal.app._App: ...
+    def _get_user_cls(self) -> type: ...
+    def _get_name(self) -> str: ...
+    def _get_class_service_function(self) -> modal.functions._Function: ...
+    def _get_method_names(self) -> collections.abc.Collection[str]: ...
     def _hydrate_metadata(self, metadata: google.protobuf.message.Message): ...
     @staticmethod
     def validate_construction_mechanism(user_cls): ...
@@ -156,6 +161,11 @@ class Cls(modal.object.Object):
     def _initialize_from_empty(self): ...
     def _initialize_from_other(self, other: Cls): ...
     def _get_partial_functions(self) -> dict[str, modal.partial_function.PartialFunction]: ...
+    def _get_app(self) -> modal.app.App: ...
+    def _get_user_cls(self) -> type: ...
+    def _get_name(self) -> str: ...
+    def _get_class_service_function(self) -> modal.functions.Function: ...
+    def _get_method_names(self) -> collections.abc.Collection[str]: ...
     def _hydrate_metadata(self, metadata: google.protobuf.message.Message): ...
     @staticmethod
     def validate_construction_mechanism(user_cls): ...

modal/partial_function.py

@@ -89,6 +89,9 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
         self.force_build = force_build
         self.build_timeout = build_timeout
 
+    def _get_raw_f(self) -> Callable[P, ReturnType]:
+        return self.raw_f
+
     def __get__(self, obj, objtype=None) -> _Function[P, ReturnType, OriginalReturnType]:
         k = self.raw_f.__name__
         if obj:  # accessing the method on an instance of a class, e.g. `MyClass().fun``

modal/partial_function.pyi

@@ -49,6 +49,7 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
         force_build: bool = False,
         build_timeout: typing.Optional[int] = None,
     ): ...
+    def _get_raw_f(self) -> typing.Callable[P, ReturnType]: ...
     def __get__(self, obj, objtype=None) -> modal.functions._Function[P, ReturnType, OriginalReturnType]: ...
     def __del__(self): ...
     def add_flags(self, flags) -> _PartialFunction: ...
@@ -78,6 +79,7 @@ class PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
         force_build: bool = False,
         build_timeout: typing.Optional[int] = None,
     ): ...
+    def _get_raw_f(self) -> typing.Callable[P, ReturnType]: ...
     def __get__(self, obj, objtype=None) -> modal.functions.Function[P, ReturnType, OriginalReturnType]: ...
     def __del__(self): ...
     def add_flags(self, flags) -> PartialFunction: ...

{modal-0.72.14.dist-info → modal-0.72.16.dist-info}/METADATA

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

{modal-0.72.14.dist-info → modal-0.72.16.dist-info}/RECORD

@@ -15,15 +15,15 @@ modal/_traceback.py,sha256=IZQzB3fVlUfMHOSyKUgw0H6qv4yHnpyq-XVCNZKfUdA,5023
 modal/_tunnel.py,sha256=o-jJhS4vQ6-XswDhHcJWGMZZmD03SC0e9i8fEu1JTjo,6310
 modal/_tunnel.pyi,sha256=JmmDYAy9F1FpgJ_hWx0xkom2nTOFQjn4mTPYlU3PFo4,1245
 modal/_watcher.py,sha256=K6LYnlmSGQB4tWWI9JADv-tvSvQ1j522FwT71B51CX8,3584
-modal/app.py,sha256=1h8v96KuIg_SAdWDK9gNWVOYYFciBIerhldRPjvDgxs,45511
-modal/app.pyi,sha256=Gx7gxjfQ70sxhbwfpx1VjvzEON-ZEMTJ_Vy8qt0oQvo,25302
+modal/app.py,sha256=t-INVjEAhSXppcu8m_rhaa1r5tzZmEPCS3lhAZg7xkc,45611
+modal/app.pyi,sha256=279Tf7Jmwq_SvAm_BKRnollAqefYI22g7wQqP94Er1Y,25453
 modal/call_graph.py,sha256=1g2DGcMIJvRy-xKicuf63IVE98gJSnQsr8R_NVMptNc,2581
 modal/client.py,sha256=JAnd4-GCN093BwkvOFAK5a6iy5ycxofjpUncMxlrIMw,15253
-modal/client.pyi,sha256=GQWztWiyEIfPTabqLPkp7W-UD1k0TP2V3Fz18FzHYIw,7280
+modal/client.pyi,sha256=dsk-vjYklfH7e4hbBBHShdm5T1HTPusZc6sIHmyRKRs,7280
 modal/cloud_bucket_mount.py,sha256=G7T7jWLD0QkmrfKR75mSTwdUZ2xNfj7pkVqb4ipmxmI,5735
 modal/cloud_bucket_mount.pyi,sha256=CEi7vrH3kDUF4LAy4qP6tfImy2UJuFRcRbsgRNM1wo8,1403
-modal/cls.py,sha256=iKDSd8cDTH-txXygdV8q1m8XPnflDieDHemMEIqSSkg,31666
-modal/cls.pyi,sha256=JUR3GOEER3AdQ8mW_s8VG90FZPCf_R1beTXK4L_PehY,8294
+modal/cls.py,sha256=jbGYPMM1AhS3Uj8Wh2lk0YARDCul_imUDiJmbyrfSSc,32158
+modal/cls.pyi,sha256=P-BAQZsx8fM7Vchd8xy3Mp0RZkwkCONSZzVyn2lNNtc,8834
 modal/config.py,sha256=BzhZYUUwOmvVwf6x5kf0ywMC257s648dmuhsnB6g3gk,11041
 modal/container_process.py,sha256=WTqLn01dJPVkPpwR_0w_JH96ceN5mV4TGtiu1ZR2RRA,6108
 modal/container_process.pyi,sha256=dqtqBmyRpXXpRrDooESL6WBVU_1Rh6OG-66P2Hk9E5U,2666
@@ -52,8 +52,8 @@ modal/object.pyi,sha256=MO78H9yFSE5i1gExPEwyyQzLdlshkcGHN1aQ0ylyvq0,8802
 modal/output.py,sha256=N0xf4qeudEaYrslzdAl35VKV8rapstgIM2e9wO8_iy0,1967
 modal/parallel_map.py,sha256=4aoMXIrlG3wl5Ifk2YDNOQkXsGRsm6Xbfm6WtJ2t3WY,16002
 modal/parallel_map.pyi,sha256=pOhT0P3DDYlwLx0fR3PTsecA7DI8uOdXC1N8i-ZkyOY,2328
-modal/partial_function.py,sha256=KSpHhu7Gsbe4h-5mcJjxnE4328biKOB7yVouHZbObA8,27798
-modal/partial_function.pyi,sha256=pO6kf8i5HVsZ7CF0z_KkzLk4Aeq7NJhFJ_VNIycRXaU,9260
+modal/partial_function.py,sha256=x7GuUrzwru-2WmLACIMFT6JnCfhyT6HAHiAgKWZMOTE,27878
+modal/partial_function.pyi,sha256=osYgJWVKmtz_noJ8OzBjcp7oH46PuIpURD_M7B2tXPs,9388
 modal/proxy.py,sha256=ZrOsuQP7dSZFq1OrIxalNnt0Zvsnp1h86Th679sSL40,1417
 modal/proxy.pyi,sha256=UvygdOYneLTuoDY6hVaMNCyZ947Tmx93IdLjErUqkvM,368
 modal/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
@@ -114,12 +114,12 @@ modal/cli/container.py,sha256=nCySVD10VJPzmX3ghTsGmpxdYeVYYMW6ofjsyt2gQcM,3667
 modal/cli/dict.py,sha256=HaEcjfll7i3Uj3Fg56aj4407if5UljsYfr6fIq-D2W8,4589
 modal/cli/entry_point.py,sha256=aaNxFAqZcmtSjwzkYIA_Ba9CkL4cL4_i2gy5VjoXxkM,4228
 modal/cli/environment.py,sha256=Ayddkiq9jdj3XYDJ8ZmUqFpPPH8xajYlbexRkzGtUcg,4334
-modal/cli/import_refs.py,sha256=wnqE5AMeyAN3IZmQvJCp54KRnJh8Nq_5fMqB6u6GEL8,9147
-modal/cli/launch.py,sha256=XdUOYXWbldcgc-n5SXs7Og4M6Gps-BbRmMb5f6L2DwY,2980
+modal/cli/import_refs.py,sha256=W-jU9AsUkaseUDduAmENQCkEE5mmVKWlJFAgEvulwuI,12023
+modal/cli/launch.py,sha256=HgaVXJq0KbVCNUSaU3lq1zP9eCksq6jbSBYBNcMUaoA,3097
 modal/cli/network_file_system.py,sha256=o6VLTgN4xn5XUiNPBfxYec-5uWCgYrDmfFFLM1ZW_eE,8180
 modal/cli/profile.py,sha256=rLXfjJObfPNjaZvNfHGIKqs7y9bGYyGe-K7V0w-Ni0M,3110
 modal/cli/queues.py,sha256=MIh2OsliNE2QeL1erubfsRsNuG4fxqcqWA2vgIfQ4Mg,4494
-modal/cli/run.py,sha256=6_Jjmpbzs76dnPKPVpE1RjWh9fVHlFnUAfegxnr7PnI,17859
+modal/cli/run.py,sha256=7WSJ7PSF6IrVWhTBmdC8ywEvdJcx-NS6YXYKTrgMV7w,18231
 modal/cli/secret.py,sha256=uQpwYrMY98iMCWeZOQTcktOYhPTZ8IHnyealDc2CZqo,4206
 modal/cli/token.py,sha256=mxSgOWakXG6N71hQb1ko61XAR9ZGkTMZD-Txn7gmTac,1924
 modal/cli/utils.py,sha256=hZmjyzcPjDnQSkLvycZD2LhGdcsfdZshs_rOU78EpvI,3717
@@ -165,10 +165,10 @@ modal_proto/options_pb2_grpc.pyi,sha256=CImmhxHsYnF09iENPoe8S4J-n93jtgUYD2JPAc0y
 modal_proto/py.typed,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 modal_version/__init__.py,sha256=kGya2ZlItX2zB7oHORs-wvP4PG8lg_mtbi1QIK3G6SQ,470
 modal_version/__main__.py,sha256=2FO0yYQQwDTh6udt1h-cBnGd1c4ZyHnHSI4BksxzVac,105
-modal_version/_version_generated.py,sha256=akfNCe9ewTF8ZA9Rqpqg5WBGCylfEOseJrnKAd1MYKs,149
-modal-0.72.14.dist-info/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
-modal-0.72.14.dist-info/METADATA,sha256=9QVZVvT7IvNfwSEaIq2WacjZI3QBQwGfnGXzMyJkUdU,2329
-modal-0.72.14.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
-modal-0.72.14.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
-modal-0.72.14.dist-info/top_level.txt,sha256=1nvYbOSIKcmU50fNrpnQnrrOpj269ei3LzgB6j9xGqg,64
-modal-0.72.14.dist-info/RECORD,,
+modal_version/_version_generated.py,sha256=IZpf7XDCb2SQQv7KTBBmxzW6Cn7w1wnGHmKHn-926Nc,149
+modal-0.72.16.dist-info/LICENSE,sha256=psuoW8kuDP96RQsdhzwOqi6fyWv0ct8CR6Jr7He_P_k,10173
+modal-0.72.16.dist-info/METADATA,sha256=4tN0qlbqVcUP3RldeH6Ix8p_83bdR64v1AKQ6v1MiJs,2329
+modal-0.72.16.dist-info/WHEEL,sha256=G16H4A3IeoQmnOrYV4ueZGKSjhipXx8zc8nu9FGlvMA,92
+modal-0.72.16.dist-info/entry_points.txt,sha256=An-wYgeEUnm6xzrAP9_NTSTSciYvvEWsMZILtYrvpAI,46
+modal-0.72.16.dist-info/top_level.txt,sha256=1nvYbOSIKcmU50fNrpnQnrrOpj269ei3LzgB6j9xGqg,64
+modal-0.72.16.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 = 14  # git: 6e1e498
+build_number = 16  # git: de1d885