modal 0.72.47__py3-none-any.whl → 0.72.49__py3-none-any.whl

modal/app.py

@@ -118,23 +118,6 @@ class _FunctionDecoratorType:
         ...
 
 
-_app_attr_error = """\
-App assignments of the form `app.x` or `app["x"]` are deprecated!
-
-The only use cases for these assignments is in conjunction with `.new()`, which is now
-in itself deprecated. If you are constructing objects with `.from_name(...)`, there is no
-need to assign those objects to the app. Example:
-
-```python
-d = modal.Dict.from_name("my-dict", create_if_missing=True)
-
-@app.function()
-def f(x, y):
-    d[x] = y  # Refer to d in global scope
-```
-"""
-
-
 class _App:
     """A Modal App is a group of functions and classes that are deployed together.
 
@@ -303,34 +286,6 @@ class _App:
         if not isinstance(value, _Object):
             raise InvalidError(f"App attribute `{key}` with value {value!r} is not a valid Modal object")
 
-    def __getitem__(self, tag: str):
-        deprecation_error((2024, 3, 25), _app_attr_error)
-
-    def __setitem__(self, tag: str, obj: _Object):
-        deprecation_error((2024, 3, 25), _app_attr_error)
-
-    def __getattr__(self, tag: str):
-        # TODO(erikbern): remove this method later
-        assert isinstance(tag, str)
-        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._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)
-
-    def __setattr__(self, tag: str, obj: _Object):
-        # TODO(erikbern): remove this method later
-        # Note that only attributes defined in __annotations__ are set on the object itself,
-        # everything else is registered on the indexed_objects
-        if tag in self.__annotations__:
-            object.__setattr__(self, tag, obj)
-        elif tag == "image":
-            self._image = obj
-        else:
-            deprecation_error((2024, 3, 25), _app_attr_error)
-
     @property
     def image(self) -> _Image:
         return self._image

modal/app.pyi

@@ -117,10 +117,6 @@ class _App:
     ) -> _App: ...
     def set_description(self, description: str): ...
     def _validate_blueprint_value(self, key: str, value: typing.Any): ...
-    def __getitem__(self, tag: str): ...
-    def __setitem__(self, tag: str, obj: modal._object._Object): ...
-    def __getattr__(self, tag: str): ...
-    def __setattr__(self, tag: str, obj: modal._object._Object): ...
     @property
     def image(self) -> modal.image._Image: ...
     @image.setter
@@ -331,10 +327,6 @@ class App:
 
     def set_description(self, description: str): ...
     def _validate_blueprint_value(self, key: str, value: typing.Any): ...
-    def __getitem__(self, tag: str): ...
-    def __setitem__(self, tag: str, obj: modal.object.Object): ...
-    def __getattr__(self, tag: str): ...
-    def __setattr__(self, tag: str, obj: modal.object.Object): ...
     @property
     def image(self) -> modal.image.Image: ...
     @image.setter

modal/cli/import_refs.py

@@ -13,9 +13,10 @@ import importlib.util
 import inspect
 import sys
 import types
+from collections import defaultdict
 from dataclasses import dataclass
 from pathlib import Path
-from typing import Any, Optional, Union
+from typing import Optional, Union, cast
 
 import click
 from rich.console import Console
@@ -36,7 +37,7 @@ class ImportRef:
     # function or local_entrypoint in module scope
     # app in module scope [+ method name]
     # app [+ function/entrypoint on that app]
-    object_path: Optional[str]
+    object_path: str
 
 
 def parse_import_ref(object_ref: str) -> ImportRef:
@@ -45,7 +46,7 @@ def parse_import_ref(object_ref: str) -> ImportRef:
     elif object_ref.find(":") > 1:
         raise InvalidError(f"Invalid object reference: {object_ref}. Did you mean '::' instead of ':'?")
     else:
-        file_or_module, object_path = object_ref, None
+        file_or_module, object_path = object_ref, ""
 
     return ImportRef(file_or_module, object_path)
 
@@ -92,7 +93,7 @@ def import_file_or_module(file_or_module: str):
     return module
 
 
-@dataclass
+@dataclass(frozen=True)
 class MethodReference:
     """This helps with deferring method reference until after the class gets instantiated by the CLI"""
 
@@ -100,128 +101,141 @@ class MethodReference:
     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 = ""
-    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)
+Runnable = Union[Function, MethodReference, LocalEntrypoint]
 
-        try:
-            obj = getattr(obj, attr)
-        except Exception:
-            prefix = f"{prefix}{segment}."
-        else:
-            prefix = ""
 
-    if prefix:
-        return None
+@dataclass(frozen=True)
+class CLICommand:
+    names: list[str]
+    runnable: Runnable
+    is_web_endpoint: bool
 
-    return obj
 
+def list_cli_commands(
+    module: types.ModuleType,
+) -> list[CLICommand]:
+    """
+    Extracts all runnables found either directly in the input module, or in any of the Apps listed in that module
+
+    Runnables includes all Functions, (class) Methods and Local Entrypoints, including web endpoints.
 
-def _infer_function_or_help(
-    app: App, module, accept_local_entrypoint: bool, accept_webhook: bool
-) -> Union[Function, LocalEntrypoint, MethodReference]:
-    """Using only an app - automatically infer a single "runnable" for a `modal run` invocation
+    The returned list consists of tuples:
+    ([name1, name2...], Runnable)
 
-    If a single runnable can't be determined, show CLI help indicating valid choices.
+    Where the first name is always the module level name if such a name exists
     """
-    filtered_local_entrypoints = [
-        entrypoint
-        for entrypoint in app.registered_entrypoints.values()
-        if entrypoint.info.module_name == module.__name__
-    ]
+    apps = cast(list[tuple[str, App]], inspect.getmembers(module, lambda x: isinstance(x, App)))
+
+    all_runnables: dict[Runnable, list[str]] = defaultdict(list)
+    for app_name, app in apps:
+        for name, local_entrypoint in app.registered_entrypoints.items():
+            all_runnables[local_entrypoint].append(f"{app_name}.{name}")
+        for name, function in app.registered_functions.items():
+            if name.endswith(".*"):
+                continue
+            all_runnables[function].append(f"{app_name}.{name}")
+        for cls_name, cls in app.registered_classes.items():
+            for method_name in cls._get_method_names():
+                method_ref = MethodReference(cls, method_name)
+                all_runnables[method_ref].append(f"{app_name}.{cls_name}.{method_name}")
+
+    # If any class or function is exported as a module level object, use that
+    # as the preferred name by putting it first in the list
+    module_level_entities = cast(
+        list[tuple[str, Runnable]],
+        inspect.getmembers(module, lambda x: isinstance(x, (Function, Cls, LocalEntrypoint))),
+    )
+    for name, entity in module_level_entities:
+        if isinstance(entity, Cls):
+            for method_name in entity._get_method_names():
+                method_ref = MethodReference(entity, method_name)
+                all_runnables.setdefault(method_ref, []).insert(0, f"{name}.{method_name}")
+        else:
+            all_runnables.setdefault(entity, []).insert(0, name)
 
-    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)
+    def _is_web_endpoint(runnable: Runnable) -> bool:
+        if isinstance(runnable, Function) and runnable._is_web_endpoint():
+            return True
+        elif isinstance(runnable, MethodReference):
+            # this is a bit yucky but can hopefully get cleaned up with Cls cleanup:
+            method_partial = runnable.cls._get_partial_functions()[runnable.method_name]
+            if method_partial._is_web_endpoint():
+                return True
 
-    if accept_local_entrypoint:
-        function_choices.update(app.registered_entrypoints)
+        return False
 
-    if len(function_choices) == 1:
-        return list(function_choices.values())[0]
+    return [CLICommand(names, runnable, _is_web_endpoint(runnable)) for runnable, names in all_runnables.items()]
 
-    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)
 
-    # 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.
+def filter_cli_commands(
+    cli_commands: list[CLICommand],
+    name_prefix: str,
+    accept_local_entrypoints: bool = True,
+    accept_web_endpoints: bool = True,
+) -> list[CLICommand]:
+    """Filters by name and type of runnable
 
-modal run app.py::my_function [...args]
+    Returns generator of (matching names list, CLICommand)
+    """
 
-Registered functions and local entrypoints on the selected app are:
-{registered_functions_str}
-"""
-    raise click.UsageError(help_text)
+    def _is_accepted_type(cli_command: CLICommand) -> bool:
+        if not accept_local_entrypoints and isinstance(cli_command.runnable, LocalEntrypoint):
+            return False
+        if not accept_web_endpoints and cli_command.is_web_endpoint:
+            return False
+        return True
 
+    res = []
+    for cli_command in cli_commands:
+        if not _is_accepted_type(cli_command):
+            continue
 
-def _show_no_auto_detectable_app(app_ref: ImportRef) -> None:
-    object_path = app_ref.object_path
-    import_path = app_ref.file_or_module
-    error_console = Console(stderr=True)
-    error_console.print(f"[bold red]Could not find Modal app '{object_path}' in {import_path}.[/bold red]")
-
-    if object_path is None:
-        guidance_msg = (
-            f"Expected to find an app variable named **`{DEFAULT_APP_NAME}`** (the default app name). "
-            "If your `modal.App` is named differently, "
-            "you must specify it in the app ref argument. "
-            f"For example an App variable `app_2 = modal.App()` in `{import_path}` would "
-            f"be specified as `{import_path}::app_2`."
-        )
-        md = Markdown(guidance_msg)
-        error_console.print(md)
+        if name_prefix in cli_command.names:
+            # exact name match
+            res.append(cli_command)
+            continue
+
+        if not name_prefix:
+            # no name specified, return all reachable runnables
+            res.append(cli_command)
+            continue
+
+        # partial matches e.g. app or class name - should we even allow this?
+        prefix_matches = [x for x in cli_command.names if x.startswith(f"{name_prefix}.")]
+        if prefix_matches:
+            res.append(cli_command)
+    return res
 
 
 def import_app(app_ref: str) -> App:
     import_ref = parse_import_ref(app_ref)
 
+    # TODO: default could be to just pick up any app regardless if it's called DEFAULT_APP_NAME
+    #  as long as there is a single app in the module?
+    import_path = import_ref.file_or_module
+    object_path = import_ref.object_path or DEFAULT_APP_NAME
+
     module = import_file_or_module(import_ref.file_or_module)
-    app = get_by_object_path(module, import_ref.object_path or DEFAULT_APP_NAME)
+
+    if "." in object_path:
+        raise click.UsageError(f"{object_path} is not a Modal App")
+
+    app = getattr(module, object_path)
 
     if app is None:
-        _show_no_auto_detectable_app(import_ref)
+        error_console = Console(stderr=True)
+        error_console.print(f"[bold red]Could not find Modal app '{object_path}' in {import_path}.[/bold red]")
+
+        if object_path is None:
+            guidance_msg = Markdown(
+                f"Expected to find an app variable named **`{DEFAULT_APP_NAME}`** (the default app name). "
+                "If your `modal.App` is assigned to a different variable name, "
+                "you must specify it in the app ref argument. "
+                f"For example an App variable `app_2 = modal.App()` in `{import_path}` would "
+                f"be specified as `{import_path}::app_2`."
+            )
+            error_console.print(guidance_msg)
+
         sys.exit(1)
 
     if not isinstance(app, App):
@@ -260,53 +274,24 @@ You would run foo as [bold green]{base_cmd} app.py::foo[/bold green]"""
     error_console.print(guidance_msg)
 
 
-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_function_or_method_ref = get_by_object_path(module, import_ref.object_path or DEFAULT_APP_NAME)
-
-    if app_function_or_method_ref is None:
-        _show_function_ref_help(import_ref, base_cmd)
-        raise SystemExit(1)
-
-    return app_function_or_method_ref, module
-
-
-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 = partial_obj
-        function_handle = _infer_function_or_help(app, module, accept_local_entrypoint, accept_webhook)
-        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"{partial_obj.info.function_name} is not a Modal Function "
-                f"(a Modal local_entrypoint can't be used in this context)"
-            )
-        return partial_obj.app, partial_obj
+def _get_runnable_app(runnable: Runnable) -> App:
+    if isinstance(runnable, Function):
+        return runnable.app
+    elif isinstance(runnable, MethodReference):
+        return runnable.cls._get_app()
     else:
-        raise click.UsageError(
-            f"{partial_obj} is not a Modal entity (should be an App, Local entrypoint, " "Function or Class/Method)"
-        )
+        assert isinstance(runnable, LocalEntrypoint)
+        return runnable.app
 
 
-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"
+def import_and_filter(
+    import_ref: ImportRef, accept_local_entrypoint=True, accept_webhook=False
+) -> tuple[Optional[Runnable], list[CLICommand]]:
+    """Takes a function ref string and returns a single determined "runnable" to use, and a list of all available
+    runnables.
 
-    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.
+    The function ref can leave out partial information (apart from the file name/module)
+    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:
@@ -315,5 +300,25 @@ def import_and_infer(
     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)
+    # all commands:
+    module = import_file_or_module(import_ref.file_or_module)
+    cli_commands = list_cli_commands(module)
+
+    # all commands that satisfy local entrypoint/accept webhook limitations AND object path prefix
+    filtered_commands = filter_cli_commands(
+        cli_commands, import_ref.object_path, accept_local_entrypoint, accept_webhook
+    )
+    all_usable_commands = filter_cli_commands(cli_commands, "", accept_local_entrypoint, accept_webhook)
+
+    if len(filtered_commands) == 1:
+        cli_command = filtered_commands[0]
+        return cli_command.runnable, all_usable_commands
+
+    # we are here if there is more than one matching function
+    if accept_local_entrypoint:
+        local_entrypoint_cmds = [cmd for cmd in filtered_commands if isinstance(cmd.runnable, LocalEntrypoint)]
+        if len(local_entrypoint_cmds) == 1:
+            # if there is a single local entrypoint - use that
+            return local_entrypoint_cmds[0].runnable, all_usable_commands
+
+    return None, all_usable_commands

modal/cli/launch.py

@@ -12,7 +12,7 @@ from ..app import LocalEntrypoint
 from ..exception import _CliUserExecutionError
 from ..output import enable_output
 from ..runner import run_app
-from .import_refs import import_and_infer
+from .import_refs import _get_runnable_app, import_and_filter, parse_import_ref
 
 launch_cli = Typer(
     name="launch",
@@ -29,10 +29,13 @@ 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)
-    app, entrypoint = import_and_infer(program_path, "modal launch")
+    entrypoint, _ = import_and_filter(
+        parse_import_ref(program_path), accept_local_entrypoint=True, accept_webhook=False
+    )
     if not isinstance(entrypoint, LocalEntrypoint):
         raise ValueError(f"{program_path} has no single local_entrypoint")
 
+    app = _get_runnable_app(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

@@ -12,6 +12,7 @@ from typing import Any, Callable, Optional, get_type_hints
 
 import click
 import typer
+from click import ClickException
 from typing_extensions import TypedDict
 
 from ..app import App, LocalEntrypoint
@@ -24,7 +25,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 MethodReference, import_and_infer, import_app
+from .import_refs import CLICommand, MethodReference, _get_runnable_app, import_and_filter, import_app, parse_import_ref
 from .utils import ENV_OPTION, ENV_OPTION_HELP, is_tty, stream_app_logs
 
 
@@ -252,6 +253,15 @@ def _get_click_command_for_local_entrypoint(app: App, entrypoint: LocalEntrypoin
     return click.command(with_click_options)
 
 
+def _get_runnable_list(all_usable_commands: list[CLICommand]) -> str:
+    usable_command_lines = []
+    for cmd in all_usable_commands:
+        cmd_names = " / ".join(cmd.names)
+        usable_command_lines.append(cmd_names)
+
+    return "\n".join(usable_command_lines)
+
+
 class RunGroup(click.Group):
     def get_command(self, ctx, func_ref):
         # note: get_command here is run before the "group logic" in the `run` logic below
@@ -260,19 +270,38 @@ class RunGroup(click.Group):
         ctx.ensure_object(dict)
         ctx.obj["env"] = ensure_env(ctx.params["env"])
 
-        app, imported_object = import_and_infer(func_ref, accept_local_entrypoint=True, base_cmd="modal run")
+        import_ref = parse_import_ref(func_ref)
+        runnable, all_usable_commands = import_and_filter(
+            import_ref, accept_local_entrypoint=True, accept_webhook=False
+        )
+        if not runnable:
+            help_header = (
+                "Specify a Modal Function or local entrypoint to run. E.g.\n"
+                f"> modal run {import_ref.file_or_module}::my_function [..args]"
+            )
+
+            if all_usable_commands:
+                help_footer = f"'{import_ref.file_or_module}' has the following functions and local entrypoints:\n"
+                help_footer += _get_runnable_list(all_usable_commands)
+            else:
+                help_footer = f"'{import_ref.file_or_module}' has no functions or local entrypoints."
+
+            raise ClickException(f"{help_header}\n\n{help_footer}")
+
+        app = _get_runnable_app(runnable)
 
         if app.description is None:
             app.set_description(_get_clean_app_description(func_ref))
 
-        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)
+        if isinstance(runnable, LocalEntrypoint):
+            click_command = _get_click_command_for_local_entrypoint(app, runnable)
+        elif isinstance(runnable, Function):
+            click_command = _get_click_command_for_function(app, runnable)
+        elif isinstance(runnable, MethodReference):
+            click_command = _get_click_command_for_cls(app, runnable)
         else:
-            raise ValueError(f"{imported_object} is neither function, local entrypoint or class/method")
+            # This should be unreachable...
+            raise ValueError(f"{runnable} is neither function, local entrypoint or class/method")
         return click_command
 
 
@@ -478,17 +507,33 @@ def shell(
             exec(container_id=container_or_function, command=shlex.split(cmd), pty=pty)
             return
 
-        original_app, function_or_method_ref = import_and_infer(
-            container_or_function, accept_local_entrypoint=False, accept_webhook=True, base_cmd="modal shell"
+        import_ref = parse_import_ref(container_or_function)
+        runnable, all_usable_commands = import_and_filter(
+            import_ref, accept_local_entrypoint=False, accept_webhook=True
         )
+        if not runnable:
+            help_header = (
+                "Specify a Modal function to start a shell session for. E.g.\n"
+                f"> modal shell {import_ref.file_or_module}::my_function"
+            )
+
+            if all_usable_commands:
+                help_footer = f"The selected module '{import_ref.file_or_module}' has the following choices:\n\n"
+                help_footer += _get_runnable_list(all_usable_commands)
+            else:
+                help_footer = f"The selected module '{import_ref.file_or_module}' has no Modal functions or classes."
+
+            raise ClickException(f"{help_header}\n\n{help_footer}")
+
         function_spec: _FunctionSpec
-        if isinstance(function_or_method_ref, MethodReference):
-            class_service_function = function_or_method_ref.cls._get_class_service_function()
+        if isinstance(runnable, MethodReference):
+            # TODO: let users specify a class instead of a method, since they use the same environment
+            class_service_function = runnable.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
+        elif isinstance(runnable, Function):
+            function_spec = runnable.spec
         else:
-            raise ValueError("Referenced entity is neither a function nor a class/method.")
+            raise ValueError("Referenced entity is not a Modal function or class")
 
         start_shell = partial(
             interactive_shell,

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.72.47"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.72.49"
     ): ...
     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.72.47"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.72.49"
     ): ...
     def is_closed(self) -> bool: ...
     @property

modal/cls.py

@@ -72,9 +72,7 @@ def _get_class_constructor_signature(user_cls: type) -> inspect.Signature:
 
 
 def _bind_instance_method(service_function: _Function, class_bound_method: _Function):
-    """mdmd:hidden
-
-    Binds an "instance service function" to a specific method name.
+    """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 parameterized methods at the moment.
@@ -129,6 +127,7 @@ def _bind_instance_method(service_function: _Function, class_bound_method: _Func
     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
     return fun
 
 
@@ -431,6 +430,7 @@ class _Cls(_Object, type_prefix="cs"):
                     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 = {}