modal 0.72.5__py3-none-any.whl → 0.72.48__py3-none-any.whl

modal/cli/run.py

@@ -7,15 +7,14 @@ import re
 import shlex
 import sys
 import time
-import typing
 from functools import partial
 from typing import Any, Callable, Optional, get_type_hints
 
 import click
 import typer
+from click import ClickException
 from typing_extensions import TypedDict
 
-from .. import Cls
 from ..app import App, LocalEntrypoint
 from ..config import config
 from ..environments import ensure_env
@@ -26,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 import_app, import_function
+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
 
 
@@ -145,39 +144,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 +155,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)
 
@@ -242,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
@@ -249,16 +269,39 @@ 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
+
+        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(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(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:
+            # This should be unreachable...
+            raise ValueError(f"{runnable} is neither function, local entrypoint or class/method")
         return click_command
 
 
@@ -409,36 +452,36 @@ def shell(
 ):
     """Run a command or interactive shell inside a Modal container.
 
-    \b**Examples:**
+    **Examples:**
 
-    \bStart an interactive shell inside the default Debian-based image:
+    Start an interactive shell inside the default Debian-based image:
 
-    \b```
+    ```
     modal shell
     ```
 
-    \bStart an interactive shell with the spec for `my_function` in your App
+    Start an interactive shell with the spec for `my_function` in your App
     (uses the same image, volumes, mounts, etc.):
 
-    \b```
+    ```
     modal shell hello_world.py::my_function
     ```
 
-    \bOr, if you're using a [modal.Cls](/docs/reference/modal.Cls), you can refer to a `@modal.method` directly:
+    Or, if you're using a [modal.Cls](/docs/reference/modal.Cls), you can refer to a `@modal.method` directly:
 
-    \b```
+    ```
     modal shell hello_world.py::MyClass.my_method
     ```
 
     Start a `python` shell:
 
-    \b```
+    ```
     modal shell hello_world.py --cmd=python
     ```
 
-    \bRun a command with your function's spec and pipe the output to a file:
+    Run a command with your function's spec and pipe the output to a file:
 
-    \b```
+    ```
     modal shell hello_world.py -c 'uv pip list' > env.txt
     ```
     """
@@ -464,11 +507,34 @@ def shell(
             exec(container_id=container_or_function, command=shlex.split(cmd), pty=pty)
             return
 
-        function = import_function(
-            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
         )
-        assert isinstance(function, Function)
-        function_spec: _FunctionSpec = function.spec
+        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(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(runnable, Function):
+            function_spec = runnable.spec
+        else:
+            raise ValueError("Referenced entity is not a Modal function or class")
+
         start_shell = partial(
             interactive_shell,
             image=function_spec.image,

modal/client.py

@@ -73,6 +73,7 @@ class _Client:
     _cancellation_context: TaskContext
     _cancellation_context_event_loop: asyncio.AbstractEventLoop = None
     _stub: Optional[api_grpc.ModalClientStub]
+    _snapshotted: bool
 
     def __init__(
         self,

modal/client.pyi

@@ -24,9 +24,10 @@ class _Client:
     _cancellation_context: modal._utils.async_utils.TaskContext
     _cancellation_context_event_loop: asyncio.events.AbstractEventLoop
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
+    _snapshotted: bool
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.72.5"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.72.48"
     ): ...
     def is_closed(self) -> bool: ...
     @property
@@ -73,37 +74,40 @@ class _Client:
         ],
     ) -> collections.abc.AsyncGenerator[typing.Any, None]: ...
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 class Client:
     _client_from_env: typing.ClassVar[typing.Optional[Client]]
     _client_from_env_lock: typing.ClassVar[typing.Optional[asyncio.locks.Lock]]
     _cancellation_context: modal._utils.async_utils.TaskContext
     _cancellation_context_event_loop: asyncio.events.AbstractEventLoop
     _stub: typing.Optional[modal_proto.api_grpc.ModalClientStub]
+    _snapshotted: bool
 
     def __init__(
-        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.72.5"
+        self, server_url: str, client_type: int, credentials: typing.Optional[tuple[str, str]], version: str = "0.72.48"
     ): ...
     def is_closed(self) -> bool: ...
     @property
     def stub(self) -> modal_proto.modal_api_grpc.ModalClientModal: ...
 
-    class ___open_spec(typing_extensions.Protocol):
+    class ___open_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self): ...
         async def aio(self): ...
 
-    _open: ___open_spec
+    _open: ___open_spec[typing_extensions.Self]
 
-    class ___close_spec(typing_extensions.Protocol):
+    class ___close_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, prep_for_restore: bool = False): ...
         async def aio(self, prep_for_restore: bool = False): ...
 
-    _close: ___close_spec
+    _close: ___close_spec[typing_extensions.Self]
 
-    class __hello_spec(typing_extensions.Protocol):
+    class __hello_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self): ...
         async def aio(self): ...
 
-    hello: __hello_spec
+    hello: __hello_spec[typing_extensions.Self]
 
     def __enter__(self): ...
     async def __aenter__(self): ...
@@ -120,23 +124,23 @@ class Client:
     @classmethod
     def set_env_client(cls, client: typing.Optional[Client]): ...
 
-    class ___call_safely_spec(typing_extensions.Protocol):
+    class ___call_safely_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, coro, readable_method: str): ...
         async def aio(self, coro, readable_method: str): ...
 
-    _call_safely: ___call_safely_spec
+    _call_safely: ___call_safely_spec[typing_extensions.Self]
 
-    class ___reset_on_pid_change_spec(typing_extensions.Protocol):
+    class ___reset_on_pid_change_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self): ...
         async def aio(self): ...
 
-    _reset_on_pid_change: ___reset_on_pid_change_spec
+    _reset_on_pid_change: ___reset_on_pid_change_spec[typing_extensions.Self]
 
-    class ___get_grpclib_method_spec(typing_extensions.Protocol):
+    class ___get_grpclib_method_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, method_name: str) -> typing.Any: ...
         async def aio(self, method_name: str) -> typing.Any: ...
 
-    _get_grpclib_method: ___get_grpclib_method_spec
+    _get_grpclib_method: ___get_grpclib_method_spec[typing_extensions.Self]
 
     async def _call_unary(
         self,

modal/cloud_bucket_mount.py

@@ -112,6 +112,9 @@ class _CloudBucketMount:
     # If the bucket is publicly accessible, the secret is unnecessary and can be omitted.
     secret: Optional[_Secret] = None
 
+    # Role ARN used for using OIDC authentication to access a cloud bucket.
+    oidc_auth_role_arn: Optional[str] = None
+
     read_only: bool = False
     requester_pays: bool = False
 
@@ -155,6 +158,7 @@ def cloud_bucket_mounts_to_proto(mounts: list[tuple[str, _CloudBucketMount]]) ->
             bucket_type=bucket_type,
             requester_pays=mount.requester_pays,
             key_prefix=key_prefix,
+            oidc_auth_role_arn=mount.oidc_auth_role_arn,
         )
         cloud_bucket_mounts.append(cloud_bucket_mount)
 

modal/cloud_bucket_mount.pyi

@@ -7,6 +7,7 @@ class _CloudBucketMount:
     bucket_endpoint_url: typing.Optional[str]
     key_prefix: typing.Optional[str]
     secret: typing.Optional[modal.secret._Secret]
+    oidc_auth_role_arn: typing.Optional[str]
     read_only: bool
     requester_pays: bool
 
@@ -16,6 +17,7 @@ class _CloudBucketMount:
         bucket_endpoint_url: typing.Optional[str] = None,
         key_prefix: typing.Optional[str] = None,
         secret: typing.Optional[modal.secret._Secret] = None,
+        oidc_auth_role_arn: typing.Optional[str] = None,
         read_only: bool = False,
         requester_pays: bool = False,
     ) -> None: ...
@@ -31,6 +33,7 @@ class CloudBucketMount:
     bucket_endpoint_url: typing.Optional[str]
     key_prefix: typing.Optional[str]
     secret: typing.Optional[modal.secret.Secret]
+    oidc_auth_role_arn: typing.Optional[str]
     read_only: bool
     requester_pays: bool
 
@@ -40,6 +43,7 @@ class CloudBucketMount:
         bucket_endpoint_url: typing.Optional[str] = None,
         key_prefix: typing.Optional[str] = None,
         secret: typing.Optional[modal.secret.Secret] = None,
+        oidc_auth_role_arn: typing.Optional[str] = None,
         read_only: bool = False,
         requester_pays: bool = False,
     ) -> None: ...

modal/cls.py

@@ -11,19 +11,19 @@ from grpclib import GRPCError, Status
 from modal._utils.function_utils import CLASS_PARAM_TYPE_MAP
 from modal_proto import api_pb2
 
+from ._object import _get_environment_name, _Object
 from ._resolver import Resolver
 from ._resources import convert_fn_config_to_resources_config
 from ._serialization import check_valid_cls_constructor_arg
 from ._traceback import print_server_warnings
 from ._utils.async_utils import synchronize_api, synchronizer
-from ._utils.deprecation import renamed_parameter
+from ._utils.deprecation import deprecation_warning, renamed_parameter
 from ._utils.grpc_utils import retry_transient_errors
 from ._utils.mount_utils import validate_volumes
 from .client import _Client
 from .exception import ExecutionError, InvalidError, NotFoundError, VersionError
 from .functions import _Function, _parse_retries
 from .gpu import GPU_T
-from .object import _get_environment_name, _Object
 from .partial_function import (
     _find_callables_for_obj,
     _find_partial_methods_for_user_cls,
@@ -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
 
 
@@ -374,12 +373,14 @@ class _Cls(_Object, type_prefix="cs"):
     _options: Optional[api_pb2.FunctionOptions]
     _callables: dict[str, Callable[..., Any]]
     _app: Optional["modal.app._App"] = None  # not set for lookups
+    _name: Optional[str]
 
     def _initialize_from_empty(self):
         self._user_cls = None
         self._class_service_function = None
         self._options = None
         self._callables = {}
+        self._name = None
 
     def _initialize_from_other(self, other: "_Cls"):
         super()._initialize_from_other(other)
@@ -388,12 +389,29 @@ class _Cls(_Object, type_prefix="cs"):
         self._method_functions = other._method_functions
         self._options = other._options
         self._callables = other._callables
+        self._name = other._name
 
     def _get_partial_functions(self) -> dict[str, _PartialFunction]:
         if not self._user_cls:
             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 (
@@ -412,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 = {}
@@ -506,6 +525,7 @@ class _Cls(_Object, type_prefix="cs"):
         cls._class_service_function = class_service_function
         cls._method_functions = method_functions
         cls._callables = callables
+        cls._name = user_cls.__name__
         return cls
 
     def _uses_common_service_function(self):
@@ -576,6 +596,7 @@ class _Cls(_Object, type_prefix="cs"):
         rep = f"Ref({app_name})"
         cls = cls._from_loader(_load_remote, rep, is_another_app=True, hydrate_lazily=True)
         # TODO: when pre 0.63 is phased out, we can set class_service_function here instead
+        cls._name = name
         return cls
 
     def with_options(
@@ -681,6 +702,13 @@ class _Cls(_Object, type_prefix="cs"):
         # Used by CLI and container entrypoint
         # TODO: remove this method - access to attributes on classes should be discouraged
         if k in self._method_functions:
+            deprecation_warning(
+                (2025, 1, 13),
+                "Usage of methods directly on the class will soon be deprecated, "
+                "instantiate classes before using methods, e.g.:\n"
+                f"{self._name}().{k} instead of {self._name}.{k}",
+                pending=True,
+            )
             return self._method_functions[k]
         return getattr(self._user_cls, k)
 

modal/cls.pyi

@@ -1,6 +1,7 @@
 import collections.abc
 import google.protobuf.message
 import inspect
+import modal._object
 import modal.app
 import modal.client
 import modal.functions
@@ -54,6 +55,8 @@ class _Obj:
     async def _aenter(self): ...
     def __getattr__(self, k): ...
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 class Obj:
     _cls: Cls
     _functions: dict[str, modal.functions.Function]
@@ -76,11 +79,11 @@ class Obj:
     def _get_parameter_values(self) -> dict[str, typing.Any]: ...
     def _new_user_cls_instance(self): ...
 
-    class __keep_warm_spec(typing_extensions.Protocol):
+    class __keep_warm_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, warm_pool_size: int) -> None: ...
         async def aio(self, warm_pool_size: int) -> None: ...
 
-    keep_warm: __keep_warm_spec
+    keep_warm: __keep_warm_spec[typing_extensions.Self]
 
     def _cached_user_cls_instance(self): ...
     def _enter(self): ...
@@ -91,17 +94,23 @@ class Obj:
     async def _aenter(self): ...
     def __getattr__(self, k): ...
 
-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.Optional[dict[str, modal.functions._Function]]
     _options: typing.Optional[modal_proto.api_pb2.FunctionOptions]
-    _callables: dict[str, typing.Callable[..., typing.Any]]
+    _callables: dict[str, collections.abc.Callable[..., typing.Any]]
     _app: typing.Optional[modal.app._App]
+    _name: typing.Optional[str]
 
     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): ...
@@ -147,13 +156,19 @@ class Cls(modal.object.Object):
     _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, typing.Callable[..., typing.Any]]
+    _callables: dict[str, collections.abc.Callable[..., typing.Any]]
     _app: typing.Optional[modal.app.App]
+    _name: typing.Optional[str]
 
     def __init__(self, *args, **kwargs): ...
     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/container_process.pyi

@@ -36,6 +36,8 @@ class _ContainerProcess(typing.Generic[T]):
     async def wait(self) -> int: ...
     async def attach(self, *, pty: typing.Optional[bool] = None): ...
 
+SUPERSELF = typing.TypeVar("SUPERSELF", covariant=True)
+
 class ContainerProcess(typing.Generic[T]):
     _process_id: typing.Optional[str]
     _stdout: modal.io_streams.StreamReader[T]
@@ -63,20 +65,20 @@ class ContainerProcess(typing.Generic[T]):
     @property
     def returncode(self) -> int: ...
 
-    class __poll_spec(typing_extensions.Protocol):
+    class __poll_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> typing.Optional[int]: ...
         async def aio(self) -> typing.Optional[int]: ...
 
-    poll: __poll_spec
+    poll: __poll_spec[typing_extensions.Self]
 
-    class __wait_spec(typing_extensions.Protocol):
+    class __wait_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self) -> int: ...
         async def aio(self) -> int: ...
 
-    wait: __wait_spec
+    wait: __wait_spec[typing_extensions.Self]
 
-    class __attach_spec(typing_extensions.Protocol):
+    class __attach_spec(typing_extensions.Protocol[SUPERSELF]):
         def __call__(self, *, pty: typing.Optional[bool] = None): ...
         async def aio(self, *, pty: typing.Optional[bool] = None): ...
 
-    attach: __attach_spec
+    attach: __attach_spec[typing_extensions.Self]