modal 0.62.115__py3-none-any.whl → 0.72.13__py3-none-any.whl

modal/_utils/function_utils.py

@@ -2,25 +2,32 @@
 import asyncio
 import inspect
 import os
-from collections import deque
+from collections.abc import AsyncGenerator
 from enum import Enum
 from pathlib import Path, PurePosixPath
-from typing import Any, AsyncIterator, Callable, List, Literal, Optional, Set, Type
+from typing import Any, Callable, Literal, Optional
 
 from grpclib import GRPCError
 from grpclib.exceptions import StreamTerminatedError
 from synchronicity.exceptions import UserCodeException
 
+import modal_proto
 from modal_proto import api_pb2
 
 from .._serialization import deserialize, deserialize_data_format, serialize
 from .._traceback import append_modal_tb
 from ..config import config, logger
-from ..exception import ExecutionError, FunctionTimeoutError, InvalidError, RemoteError
+from ..exception import (
+    DeserializationError,
+    ExecutionError,
+    FunctionTimeoutError,
+    InternalFailure,
+    InvalidError,
+    RemoteError,
+)
 from ..mount import ROOT_DIR, _is_modal_path, _Mount
-from ..object import Object
 from .blob_utils import MAX_OBJECT_SIZE_BYTES, blob_download, blob_upload
-from .grpc_utils import RETRYABLE_GRPC_STATUS_CODES, unary_stream
+from .grpc_utils import RETRYABLE_GRPC_STATUS_CODES
 
 
 class FunctionInfoType(Enum):
@@ -30,6 +37,13 @@ class FunctionInfoType(Enum):
     NOTEBOOK = "notebook"
 
 
+# TODO(elias): Add support for quoted/str annotations
+CLASS_PARAM_TYPE_MAP: dict[type, tuple["api_pb2.ParameterType.ValueType", str]] = {
+    str: (api_pb2.PARAM_TYPE_STRING, "string_default"),
+    int: (api_pb2.PARAM_TYPE_INT, "int_default"),
+}
+
+
 class LocalFunctionError(InvalidError):
     """Raised if a function declared in a non-global scope is used in an impermissible way"""
 
@@ -49,8 +63,25 @@ def entrypoint_only_package_mount_condition(entrypoint_file):
     return inner
 
 
-def is_global_function(function_qual_name):
-    return "<locals>" not in function_qual_name.split(".")
+def is_global_object(object_qual_name: str):
+    return "<locals>" not in object_qual_name.split(".")
+
+
+def is_method_fn(object_qual_name: str):
+    # methods have names like Cls.foo.
+    if "<locals>" in object_qual_name:
+        # functions can be nested in multiple local scopes.
+        rest = object_qual_name.split("<locals>.")[-1]
+        return len(rest.split(".")) > 1
+    return len(object_qual_name.split(".")) > 1
+
+
+def is_top_level_function(f: Callable) -> bool:
+    """Returns True if this function is defined in global scope.
+
+    Returns False if this function is locally scoped (including on a class).
+    """
+    return f.__name__ == f.__qualname__
 
 
 def is_async(function):
@@ -60,6 +91,8 @@ def is_async(function):
     # coerce the type. For now let's make a determination based on inspecting the function definition.
     # This sometimes isn't correct, since a "vanilla" Python function can return a coroutine if it
     # wraps async code or similar. Let's revisit this shortly.
+    if inspect.ismethod(function):
+        function = function.__func__  # inspect the underlying function
     if inspect.iscoroutinefunction(function) or inspect.isasyncgenfunction(function):
         return True
     elif inspect.isfunction(function) or inspect.isgeneratorfunction(function):
@@ -68,51 +101,67 @@ def is_async(function):
         raise RuntimeError(f"Function {function} is a strange type {type(function)}")
 
 
+def get_function_type(is_generator: Optional[bool]) -> "api_pb2.Function.FunctionType.ValueType":
+    return api_pb2.Function.FUNCTION_TYPE_GENERATOR if is_generator else api_pb2.Function.FUNCTION_TYPE_FUNCTION
+
+
 class FunctionInfo:
-    """Class that helps us extract a bunch of information about a function."""
+    """Utility that determines serialization/deserialization mechanisms for functions
+
+    * Stored as file vs serialized
+    * If serialized: how to serialize the function
+    * If file: which module/function name should be used to retrieve
 
-    raw_f: Callable[..., Any]
+    Used for populating the definition of a remote function
+    """
+
+    raw_f: Optional[Callable[..., Any]]  # if None - this is a "class service function"
     function_name: str
-    cls: Optional[Type[Any]]
-    definition_type: "api_pb2.Function.DefinitionType.ValueType"
+    user_cls: Optional[type[Any]]
     module_name: Optional[str]
 
     _type: FunctionInfoType
-    _signature: Optional[inspect.Signature]
     _file: Optional[str]
     _base_dir: str
     _remote_dir: Optional[PurePosixPath] = None
 
+    def get_definition_type(self) -> "modal_proto.api_pb2.Function.DefinitionType.ValueType":
+        if self.is_serialized():
+            return modal_proto.api_pb2.Function.DEFINITION_TYPE_SERIALIZED
+        else:
+            return modal_proto.api_pb2.Function.DEFINITION_TYPE_FILE
+
+    def is_service_class(self):
+        if self.raw_f is None:
+            assert self.user_cls
+            return True
+        return False
+
     # TODO: we should have a bunch of unit tests for this
     def __init__(
         self,
-        f: Callable[..., Any],
+        f: Optional[Callable[..., Any]],
         serialized=False,
         name_override: Optional[str] = None,
-        cls: Optional[Type] = None,
+        user_cls: Optional[type] = None,
     ):
         self.raw_f = f
-        self.cls = cls
+        self.user_cls = user_cls
 
         if name_override is not None:
             self.function_name = name_override
-        elif f.__qualname__ != f.__name__ and not serialized:
-            # Class function.
-            if len(f.__qualname__.split(".")) > 2:
-                raise InvalidError(
-                    f"Cannot wrap `{f.__qualname__}`:"
-                    " functions and classes used in Modal must be defined in global scope."
-                    " If trying to apply additional decorators, they may need to use `functools.wraps`."
-                )
-            self.function_name = f"{cls.__name__}.{f.__name__}"
+        elif f is None and user_cls:
+            # "service function" for running all methods of a class
+            self.function_name = f"{user_cls.__name__}.*"
+        elif f and user_cls:
+            # Method may be defined on superclass of the wrapped class
+            self.function_name = f"{user_cls.__name__}.{f.__name__}"
         else:
             self.function_name = f.__qualname__
 
-        self._signature = inspect.signature(f)
-
         # If it's a cls, the @method could be defined in a base class in a different file.
-        if cls is not None:
-            module = inspect.getmodule(cls)
+        if user_cls is not None:
+            module = inspect.getmodule(user_cls)
         else:
             module = inspect.getmodule(f)
 
@@ -121,7 +170,7 @@ class FunctionInfo:
             # Get the package path
             # Note: __import__ always returns the top-level package.
             self._file = os.path.abspath(module.__file__)
-            package_paths = set([os.path.abspath(p) for p in __import__(module.__package__).__path__])
+            package_paths = {os.path.abspath(p) for p in __import__(module.__package__).__path__}
             # There might be multiple package paths in some weird cases
             base_dirs = [
                 base_dir for base_dir in package_paths if os.path.commonpath((base_dir, self._file)) == base_dir
@@ -138,7 +187,7 @@ class FunctionInfo:
             self._base_dir = base_dirs[0]
             self.module_name = module.__spec__.name
             self._remote_dir = ROOT_DIR / PurePosixPath(module.__package__.split(".")[0])
-            self.definition_type = api_pb2.Function.DEFINITION_TYPE_FILE
+            self._is_serialized = False
             self._type = FunctionInfoType.PACKAGE
         elif hasattr(module, "__file__") and not serialized:
             # This generally covers the case where it's invoked with
@@ -148,46 +197,117 @@ class FunctionInfo:
             self._file = os.path.abspath(inspect.getfile(module))
             self.module_name = inspect.getmodulename(self._file)
             self._base_dir = os.path.dirname(self._file)
-            self.definition_type = api_pb2.Function.DEFINITION_TYPE_FILE
+            self._is_serialized = False
             self._type = FunctionInfoType.FILE
         else:
             self.module_name = None
             self._base_dir = os.path.abspath("")  # get current dir
-            self.definition_type = api_pb2.Function.DEFINITION_TYPE_SERIALIZED
-            if serialized:
+            self._is_serialized = True  # either explicitly, or by being in a notebook
+            if serialized:  # if explicit
                 self._type = FunctionInfoType.SERIALIZED
             else:
                 self._type = FunctionInfoType.NOTEBOOK
 
-        if self.definition_type == api_pb2.Function.DEFINITION_TYPE_FILE:
+        if not self.is_serialized():
             # Sanity check that this function is defined in global scope
             # Unfortunately, there's no "clean" way to do this in Python
-            if not is_global_function(f.__qualname__):
+            qualname = f.__qualname__ if f else user_cls.__qualname__
+            if not is_global_object(qualname):
                 raise LocalFunctionError(
                     "Modal can only import functions defined in global scope unless they are `serialized=True`"
                 )
 
     def is_serialized(self) -> bool:
-        return self.definition_type == api_pb2.Function.DEFINITION_TYPE_SERIALIZED
+        return self._is_serialized
 
     def serialized_function(self) -> bytes:
         # Note: this should only be called from .load() and not at function decoration time
         #       otherwise the serialized function won't have access to variables/side effect
         #        defined after it in the same file
         assert self.is_serialized()
-        serialized_bytes = serialize(self.raw_f)
-        logger.debug(f"Serializing {self.raw_f.__qualname__}, size is {len(serialized_bytes)}")
-        return serialized_bytes
+        if self.raw_f:
+            serialized_bytes = serialize(self.raw_f)
+            logger.debug(f"Serializing {self.raw_f.__qualname__}, size is {len(serialized_bytes)}")
+            return serialized_bytes
+        else:
+            logger.debug(f"Serializing function for class service function {self.user_cls.__qualname__} as empty")
+            return b""
 
-    def get_globals(self):
+    def get_cls_vars(self) -> dict[str, Any]:
+        if self.user_cls is not None:
+            cls_vars = {
+                attr: getattr(self.user_cls, attr)
+                for attr in dir(self.user_cls)
+                if not callable(getattr(self.user_cls, attr)) and not attr.startswith("__")
+            }
+            return cls_vars
+        return {}
+
+    def get_cls_var_attrs(self) -> dict[str, Any]:
+        import dis
+
+        import opcode
+
+        LOAD_ATTR = opcode.opmap["LOAD_ATTR"]
+        STORE_ATTR = opcode.opmap["STORE_ATTR"]
+
+        func = self.raw_f
+        code = func.__code__
+        f_attr_ops = set()
+        for instr in dis.get_instructions(code):
+            if instr.opcode == LOAD_ATTR:
+                f_attr_ops.add(instr.argval)
+            elif instr.opcode == STORE_ATTR:
+                f_attr_ops.add(instr.argval)
+
+        cls_vars = self.get_cls_vars()
+        f_attrs = {k: cls_vars[k] for k in cls_vars if k in f_attr_ops}
+        return f_attrs
+
+    def get_globals(self) -> dict[str, Any]:
         from .._vendor.cloudpickle import _extract_code_globals
 
+        if self.raw_f is None:
+            return {}
+
         func = self.raw_f
+        while hasattr(func, "__wrapped__") and func is not func.__wrapped__:
+            # Unwrap functions decorated using functools.wrapped (potentially multiple times)
+            func = func.__wrapped__
         f_globals_ref = _extract_code_globals(func.__code__)
         f_globals = {k: func.__globals__[k] for k in f_globals_ref if k in func.__globals__}
         return f_globals
 
-    def get_entrypoint_mount(self) -> List[_Mount]:
+    def class_parameter_info(self) -> api_pb2.ClassParameterInfo:
+        if not self.user_cls:
+            return api_pb2.ClassParameterInfo()
+
+        # TODO(elias): Resolve circular dependencies... maybe we'll need some cls_utils module
+        from modal.cls import _get_class_constructor_signature, _use_annotation_parameters
+
+        if not _use_annotation_parameters(self.user_cls):
+            return api_pb2.ClassParameterInfo(format=api_pb2.ClassParameterInfo.PARAM_SERIALIZATION_FORMAT_PICKLE)
+
+        # annotation parameters trigger strictly typed parameterization
+        # which enables web endpoint for parameterized classes
+
+        modal_parameters: list[api_pb2.ClassParameterSpec] = []
+        signature = _get_class_constructor_signature(self.user_cls)
+        for param in signature.parameters.values():
+            has_default = param.default is not param.empty
+            if param.annotation not in CLASS_PARAM_TYPE_MAP:
+                raise InvalidError("modal.parameter() currently only support str or int types")
+            param_type, default_field = CLASS_PARAM_TYPE_MAP[param.annotation]
+            class_param_spec = api_pb2.ClassParameterSpec(name=param.name, has_default=has_default, type=param_type)
+            if has_default:
+                setattr(class_param_spec, default_field, param.default)
+            modal_parameters.append(class_param_spec)
+
+        return api_pb2.ClassParameterInfo(
+            format=api_pb2.ClassParameterInfo.PARAM_SERIALIZATION_FORMAT_PROTO, schema=modal_parameters
+        )
+
+    def get_entrypoint_mount(self) -> list[_Mount]:
         """
         Includes:
         * Implicit mount of the function itself (the module or package that the function is part of)
@@ -206,22 +326,22 @@ class FunctionInfo:
         # make sure the function's own entrypoint is included:
         if self._type == FunctionInfoType.PACKAGE:
             if config.get("automount"):
-                return [_Mount.from_local_python_packages(self.module_name)]
-            elif self.definition_type == api_pb2.Function.DEFINITION_TYPE_FILE:
+                return [_Mount._from_local_python_packages(self.module_name)]
+            elif not self.is_serialized():
                 # mount only relevant file and __init__.py:s
                 return [
-                    _Mount.from_local_dir(
+                    _Mount._from_local_dir(
                         self._base_dir,
                         remote_path=self._remote_dir,
                         recursive=True,
                         condition=entrypoint_only_package_mount_condition(self._file),
                     )
                 ]
-        elif self.definition_type == api_pb2.Function.DEFINITION_TYPE_FILE:
+        elif not self.is_serialized():
             remote_path = ROOT_DIR / Path(self._file).name
             if not _is_modal_path(remote_path):
                 return [
-                    _Mount.from_local_file(
+                    _Mount._from_local_file(
                         self._file,
                         remote_path=remote_path,
                     )
@@ -232,7 +352,8 @@ class FunctionInfo:
         return self.function_name
 
     def is_nullary(self):
-        for param in self._signature.parameters.values():
+        signature = inspect.signature(self.raw_f)
+        for param in signature.parameters.values():
             if param.kind in (inspect.Parameter.VAR_POSITIONAL, inspect.Parameter.VAR_KEYWORD):
                 # variadic parameters are nullary
                 continue
@@ -241,59 +362,39 @@ class FunctionInfo:
         return True
 
 
-def get_referred_objects(f: Callable) -> List[Object]:
-    """Takes a function and returns any Modal Objects in global scope that it refers to.
+def callable_has_non_self_params(f: Callable[..., Any]) -> bool:
+    """Return True if a callable (function, bound method, or unbound method) has parameters other than self.
 
-    TODO: this does not yet support Object contained by another object,
-    e.g. a list of Objects in global scope.
+    Used to ensure that @exit(), @asgi_app, and @wsgi_app functions don't have parameters.
     """
-    from ..cls import Cls
-    from ..functions import Function
-
-    ret: List[Object] = []
-    obj_queue: deque[Callable] = deque([f])
-    objs_seen: Set[int] = set([id(f)])
-    while obj_queue:
-        obj = obj_queue.popleft()
-        if isinstance(obj, (Function, Cls)):
-            # These are always attached to stubs, so we shouldn't do anything
-            pass
-        elif isinstance(obj, Object):
-            ret.append(obj)
-        elif inspect.isfunction(obj):
-            try:
-                closure_vars = inspect.getclosurevars(obj)
-            except ValueError:
-                logger.warning(
-                    f"Could not inspect closure vars of {f} - referenced global Modal objects may or may not work in that function"
-                )
-                continue
+    return any(param.name != "self" for param in inspect.signature(f).parameters.values())
 
-            for dep_obj in closure_vars.globals.values():
-                if id(dep_obj) not in objs_seen:
-                    objs_seen.add(id(dep_obj))
-                    obj_queue.append(dep_obj)
-    return ret
 
+def callable_has_non_self_non_default_params(f: Callable[..., Any]) -> bool:
+    """Return True if a callable (function, bound method, or unbound method) has non-default parameters other than self.
 
-def method_has_params(f: Callable) -> bool:
-    """Return True if a method (bound or unbound) has parameters other than self.
-
-    Used for deprecation of @exit() parameters.
+    Used for deprecation of default parameters in @asgi_app and @wsgi_app functions.
     """
-    num_params = len(inspect.signature(f).parameters)
-    if hasattr(f, "__self__"):
-        return num_params > 0
-    else:
-        return num_params > 1
+    for param in inspect.signature(f).parameters.values():
+        if param.name == "self":
+            continue
+
+        if param.default != inspect.Parameter.empty:
+            continue
+
+        return True
+    return False
 
 
 async def _stream_function_call_data(
     client, function_call_id: str, variant: Literal["data_in", "data_out"]
-) -> AsyncIterator[Any]:
+) -> AsyncGenerator[Any, None]:
     """Read from the `data_in` or `data_out` stream of a function call."""
     last_index = 0
+
+    # TODO(gongy): generalize this logic as util for unary streams
     retries_remaining = 10
+    delay_ms = 1
 
     if variant == "data_in":
         stub_fn = client.stub.FunctionCallGetDataIn
@@ -305,26 +406,31 @@ async def _stream_function_call_data(
     while True:
         req = api_pb2.FunctionCallGetDataRequest(function_call_id=function_call_id, last_index=last_index)
         try:
-            async for chunk in unary_stream(stub_fn, req):
+            async for chunk in stub_fn.unary_stream(req):
                 if chunk.index <= last_index:
                     continue
-                last_index = chunk.index
                 if chunk.data_blob_id:
                     message_bytes = await blob_download(chunk.data_blob_id, client.stub)
                 else:
                     message_bytes = chunk.data
                 message = deserialize_data_format(message_bytes, chunk.data_format, client)
+
+                last_index = chunk.index
                 yield message
         except (GRPCError, StreamTerminatedError) as exc:
             if retries_remaining > 0:
                 retries_remaining -= 1
                 if isinstance(exc, GRPCError):
                     if exc.status in RETRYABLE_GRPC_STATUS_CODES:
-                        await asyncio.sleep(1.0)
+                        logger.debug(f"{variant} stream retrying with delay {delay_ms}ms due to {exc}")
+                        await asyncio.sleep(delay_ms / 1000)
+                        delay_ms = min(1000, delay_ms * 10)
                         continue
                 elif isinstance(exc, StreamTerminatedError):
                     continue
             raise
+        else:
+            delay_ms = 1
 
 
 OUTPUTS_TIMEOUT = 55.0  # seconds
@@ -364,18 +470,27 @@ async def _process_result(result: api_pb2.GenericResult, data_format: int, stub,
 
     if result.status == api_pb2.GenericResult.GENERIC_STATUS_TIMEOUT:
         raise FunctionTimeoutError(result.exception)
+    elif result.status == api_pb2.GenericResult.GENERIC_STATUS_INTERNAL_FAILURE:
+        raise InternalFailure(result.exception)
     elif result.status != api_pb2.GenericResult.GENERIC_STATUS_SUCCESS:
         if data:
             try:
                 exc = deserialize(data, client)
-            except Exception as deser_exc:
+            except DeserializationError as deser_exc:
                 raise ExecutionError(
                     "Could not deserialize remote exception due to local error:\n"
                     + f"{deser_exc}\n"
                     + "This can happen if your local environment does not have the remote exception definitions.\n"
                     + "Here is the remote traceback:\n"
                     + f"{result.traceback}"
-                )
+                ) from deser_exc.__cause__
+            except Exception as deser_exc:
+                raise ExecutionError(
+                    "Could not deserialize remote exception due to local error:\n"
+                    + f"{deser_exc}\n"
+                    + "Here is the remote traceback:\n"
+                    + f"{result.traceback}"
+                ) from deser_exc
             if not isinstance(exc, BaseException):
                 raise ExecutionError(f"Got remote exception of incorrect type {type(exc)}")
 
@@ -395,17 +510,21 @@ async def _process_result(result: api_pb2.GenericResult, data_format: int, stub,
     except ModuleNotFoundError as deser_exc:
         raise ExecutionError(
             "Could not deserialize result due to error:\n"
-            + f"{deser_exc}\n"
-            + "This can happen if your local environment does not have a module that was used to construct the result. \n"
-        )
+            f"{deser_exc}\n"
+            "This can happen if your local environment does not have a module that was used to construct the result. \n"
+        ) from deser_exc
 
 
-async def _create_input(args, kwargs, client, idx: Optional[int] = None) -> api_pb2.FunctionPutInputsItem:
+async def _create_input(
+    args, kwargs, client, *, idx: Optional[int] = None, method_name: Optional[str] = None
+) -> api_pb2.FunctionPutInputsItem:
     """Serialize function arguments and create a FunctionInput protobuf,
     uploading to blob storage if needed.
     """
     if idx is None:
         idx = 0
+    if method_name is None:
+        method_name = ""  # proto compatible
 
     args_serialized = serialize((args, kwargs))
 
@@ -413,11 +532,93 @@ async def _create_input(args, kwargs, client, idx: Optional[int] = None) -> api_
         args_blob_id = await blob_upload(args_serialized, client.stub)
 
         return api_pb2.FunctionPutInputsItem(
-            input=api_pb2.FunctionInput(args_blob_id=args_blob_id, data_format=api_pb2.DATA_FORMAT_PICKLE),
+            input=api_pb2.FunctionInput(
+                args_blob_id=args_blob_id,
+                data_format=api_pb2.DATA_FORMAT_PICKLE,
+                method_name=method_name,
+            ),
             idx=idx,
         )
     else:
         return api_pb2.FunctionPutInputsItem(
-            input=api_pb2.FunctionInput(args=args_serialized, data_format=api_pb2.DATA_FORMAT_PICKLE),
+            input=api_pb2.FunctionInput(
+                args=args_serialized,
+                data_format=api_pb2.DATA_FORMAT_PICKLE,
+                method_name=method_name,
+            ),
             idx=idx,
         )
+
+
+def _get_suffix_from_web_url_info(url_info: api_pb2.WebUrlInfo) -> str:
+    if url_info.truncated:
+        suffix = " [grey70](label truncated)[/grey70]"
+    elif url_info.label_stolen:
+        suffix = " [grey70](label stolen)[/grey70]"
+    else:
+        suffix = ""
+    return suffix
+
+
+class FunctionCreationStatus:
+    # TODO(michael) this really belongs with other output-related code
+    # but moving it here so we can use it when loading a function with output disabled
+    tag: str
+    response: Optional[api_pb2.FunctionCreateResponse] = None
+
+    def __init__(self, resolver, tag):
+        self.resolver = resolver
+        self.tag = tag
+
+    def __enter__(self):
+        self.status_row = self.resolver.add_status_row()
+        self.status_row.message(f"Creating function {self.tag}...")
+        return self
+
+    def set_response(self, resp: api_pb2.FunctionCreateResponse):
+        self.response = resp
+
+    def __exit__(self, exc_type, exc_val, exc_tb):
+        if exc_type:
+            raise exc_val
+
+        if not self.response:
+            self.status_row.finish(f"Unknown error when creating function {self.tag}")
+
+        elif self.response.function.web_url:
+            url_info = self.response.function.web_url_info
+            requires_proxy_auth = self.response.function.webhook_config.requires_proxy_auth
+            proxy_auth_suffix = " 🔑" if requires_proxy_auth else ""
+            # Ensure terms used here match terms used in modal.com/docs/guide/webhook-urls doc.
+            suffix = _get_suffix_from_web_url_info(url_info)
+            # TODO: this is only printed when we're showing progress. Maybe move this somewhere else.
+            web_url = self.response.handle_metadata.web_url
+            self.status_row.finish(
+                f"Created web function {self.tag} => [magenta underline]{web_url}[/magenta underline]"
+                f"{proxy_auth_suffix}{suffix}"
+            )
+
+            # Print custom domain in terminal
+            for custom_domain in self.response.function.custom_domain_info:
+                custom_domain_status_row = self.resolver.add_status_row()
+                custom_domain_status_row.finish(
+                    f"Custom domain for {self.tag} => [magenta underline]" f"{custom_domain.url}[/magenta underline]"
+                )
+        else:
+            self.status_row.finish(f"Created function {self.tag}.")
+            if self.response.function.method_definitions_set:
+                for method_definition in self.response.function.method_definitions.values():
+                    if method_definition.web_url:
+                        url_info = method_definition.web_url_info
+                        suffix = _get_suffix_from_web_url_info(url_info)
+                        class_web_endpoint_method_status_row = self.resolver.add_status_row()
+                        class_web_endpoint_method_status_row.finish(
+                            f"Created web endpoint for {method_definition.function_name} => [magenta underline]"
+                            f"{method_definition.web_url}[/magenta underline]{suffix}"
+                        )
+                        for custom_domain in method_definition.custom_domain_info:
+                            custom_domain_status_row = self.resolver.add_status_row()
+                            custom_domain_status_row.finish(
+                                f"Custom domain for {method_definition.function_name} => [magenta underline]"
+                                f"{custom_domain.url}[/magenta underline]"
+                            )