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

modal/_container_entrypoint.py

@@ -38,7 +38,7 @@ from modal.partial_function import (
     _find_callables_for_obj,
     _PartialFunctionFlags,
 )
-from modal.running_app import RunningApp
+from modal.running_app import RunningApp, running_app_from_layout
 from modal_proto import api_pb2
 
 from ._runtime.container_io_manager import (
@@ -50,8 +50,8 @@ from ._runtime.container_io_manager import (
 from ._runtime.execution_context import _set_current_context_ids
 
 if TYPE_CHECKING:
+    import modal._object
     import modal._runtime.container_io_manager
-    import modal.object
 
 
 class DaemonizedThreadPool:
@@ -468,7 +468,7 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
                 batch_wait_ms = function_def.batch_linger_ms or 0
 
         # Get ids and metadata for objects (primarily functions and classes) on the app
-        container_app: RunningApp = container_io_manager.get_app_objects(container_args.app_layout)
+        container_app: RunningApp = running_app_from_layout(container_args.app_id, container_args.app_layout)
 
         # Initialize objects on the app.
         # This is basically only functions and classes - anything else is deprecated and will be unsupported soon
@@ -591,15 +591,10 @@ if __name__ == "__main__":
     logger.debug("Container: starting")
 
     container_args = api_pb2.ContainerArguments()
-
     container_arguments_path: Optional[str] = os.environ.get("MODAL_CONTAINER_ARGUMENTS_PATH")
     if container_arguments_path is None:
-        # TODO(erikbern): this fallback is for old workers and we can remove it very soon (days)
-        import base64
-
-        container_args.ParseFromString(base64.b64decode(sys.argv[1]))
-    else:
-        container_args.ParseFromString(open(container_arguments_path, "rb").read())
+        raise RuntimeError("No path to the container arguments file provided!")
+    container_args.ParseFromString(open(container_arguments_path, "rb").read())
 
     # Note that we're creating the client in a synchronous context, but it will be running in a separate thread.
     # This is good because if the function is long running then we the client can still send heartbeats

modal/_object.py

@@ -0,0 +1,297 @@
+# Copyright Modal Labs 2022
+import typing
+import uuid
+from collections.abc import Awaitable, Hashable, Sequence
+from functools import wraps
+from typing import Callable, ClassVar, Optional
+
+from google.protobuf.message import Message
+from typing_extensions import Self
+
+from ._resolver import Resolver
+from ._utils.async_utils import aclosing
+from ._utils.deprecation import deprecation_warning
+from .client import _Client
+from .config import config, logger
+from .exception import ExecutionError, InvalidError
+
+EPHEMERAL_OBJECT_HEARTBEAT_SLEEP: int = 300
+
+
+def _get_environment_name(environment_name: Optional[str] = None, resolver: Optional[Resolver] = None) -> Optional[str]:
+    if environment_name:
+        return environment_name
+    elif resolver and resolver.environment_name:
+        return resolver.environment_name
+    else:
+        return config.get("environment")
+
+
+class _Object:
+    _type_prefix: ClassVar[Optional[str]] = None
+    _prefix_to_type: ClassVar[dict[str, type]] = {}
+
+    # For constructors
+    _load: Optional[Callable[[Self, Resolver, Optional[str]], Awaitable[None]]]
+    _preload: Optional[Callable[[Self, Resolver, Optional[str]], Awaitable[None]]]
+    _rep: str
+    _is_another_app: bool
+    _hydrate_lazily: bool
+    _deps: Optional[Callable[..., Sequence["_Object"]]]
+    _deduplication_key: Optional[Callable[[], Awaitable[Hashable]]] = None
+
+    # For hydrated objects
+    _object_id: Optional[str]
+    _client: Optional[_Client]
+    _is_hydrated: bool
+    _is_rehydrated: bool
+
+    @classmethod
+    def __init_subclass__(cls, type_prefix: Optional[str] = None):
+        super().__init_subclass__()
+        if type_prefix is not None:
+            cls._type_prefix = type_prefix
+            cls._prefix_to_type[type_prefix] = cls
+
+    def __init__(self, *args, **kwargs):
+        raise InvalidError(f"Class {type(self).__name__} has no constructor. Use class constructor methods instead.")
+
+    def _init(
+        self,
+        rep: str,
+        load: Optional[Callable[[Self, Resolver, Optional[str]], Awaitable[None]]] = None,
+        is_another_app: bool = False,
+        preload: Optional[Callable[[Self, Resolver, Optional[str]], Awaitable[None]]] = None,
+        hydrate_lazily: bool = False,
+        deps: Optional[Callable[..., Sequence["_Object"]]] = None,
+        deduplication_key: Optional[Callable[[], Awaitable[Hashable]]] = None,
+    ):
+        self._local_uuid = str(uuid.uuid4())
+        self._load = load
+        self._preload = preload
+        self._rep = rep
+        self._is_another_app = is_another_app
+        self._hydrate_lazily = hydrate_lazily
+        self._deps = deps
+        self._deduplication_key = deduplication_key
+
+        self._object_id = None
+        self._client = None
+        self._is_hydrated = False
+        self._is_rehydrated = False
+
+        self._initialize_from_empty()
+
+    def _unhydrate(self):
+        self._object_id = None
+        self._client = None
+        self._is_hydrated = False
+
+    def _initialize_from_empty(self):
+        # default implementation, can be overriden in subclasses
+        pass
+
+    def _initialize_from_other(self, other):
+        # default implementation, can be overriden in subclasses
+        self._object_id = other._object_id
+        self._is_hydrated = other._is_hydrated
+        self._client = other._client
+
+    def _hydrate(self, object_id: str, client: _Client, metadata: Optional[Message]):
+        assert isinstance(object_id, str) and self._type_prefix is not None
+        if not object_id.startswith(self._type_prefix):
+            raise ExecutionError(
+                f"Can not hydrate {type(self)}:"
+                f" it has type prefix {self._type_prefix}"
+                f" but the object_id starts with {object_id[:3]}"
+            )
+        self._object_id = object_id
+        self._client = client
+        self._hydrate_metadata(metadata)
+        self._is_hydrated = True
+
+    def _hydrate_metadata(self, metadata: Optional[Message]):
+        # override this is subclasses that need additional data (other than an object_id) for a functioning Handle
+        pass
+
+    def _get_metadata(self) -> Optional[Message]:
+        # return the necessary metadata from this handle to be able to re-hydrate in another context if one is needed
+        # used to provide a handle's handle_metadata for serializing/pickling a live handle
+        # the object_id is already provided by other means
+        return None
+
+    def _validate_is_hydrated(self):
+        if not self._is_hydrated:
+            object_type = self.__class__.__name__.strip("_")
+            if hasattr(self, "_app") and getattr(self._app, "_running_app", "") is None:  # type: ignore
+                # The most common cause of this error: e.g., user called a Function without using App.run()
+                reason = ", because the App it is defined on is not running"
+            else:
+                # Technically possible, but with an ambiguous cause.
+                reason = ""
+            raise ExecutionError(
+                f"{object_type} has not been hydrated with the metadata it needs to run on Modal{reason}."
+            )
+
+    def clone(self) -> Self:
+        """mdmd:hidden Clone a given hydrated object."""
+
+        # Object to clone must already be hydrated, otherwise from_loader is more suitable.
+        self._validate_is_hydrated()
+        obj = type(self).__new__(type(self))
+        obj._initialize_from_other(self)
+        return obj
+
+    @classmethod
+    def _from_loader(
+        cls,
+        load: Callable[[Self, Resolver, Optional[str]], Awaitable[None]],
+        rep: str,
+        is_another_app: bool = False,
+        preload: Optional[Callable[[Self, Resolver, Optional[str]], Awaitable[None]]] = None,
+        hydrate_lazily: bool = False,
+        deps: Optional[Callable[..., Sequence["_Object"]]] = None,
+        deduplication_key: Optional[Callable[[], Awaitable[Hashable]]] = None,
+    ):
+        # TODO(erikbern): flip the order of the two first arguments
+        obj = _Object.__new__(cls)
+        obj._init(rep, load, is_another_app, preload, hydrate_lazily, deps, deduplication_key)
+        return obj
+
+    @staticmethod
+    def _get_type_from_id(object_id: str) -> type["_Object"]:
+        parts = object_id.split("-")
+        if len(parts) != 2:
+            raise InvalidError(f"Object id {object_id} has no dash in it")
+        prefix = parts[0]
+        if prefix not in _Object._prefix_to_type:
+            raise InvalidError(f"Object prefix {prefix} does not correspond to a type")
+        return _Object._prefix_to_type[prefix]
+
+    @classmethod
+    def _is_id_type(cls, object_id) -> bool:
+        return cls._get_type_from_id(object_id) == cls
+
+    @classmethod
+    def _new_hydrated(
+        cls, object_id: str, client: _Client, handle_metadata: Optional[Message], is_another_app: bool = False
+    ) -> Self:
+        obj_cls: type[Self]
+        if cls._type_prefix is not None:
+            # This is called directly on a subclass, e.g. Secret.from_id
+            # validate the id matching the expected id type of the Object subclass
+            if not object_id.startswith(cls._type_prefix + "-"):
+                raise InvalidError(f"Object {object_id} does not start with {cls._type_prefix}")
+
+            obj_cls = cls
+        else:
+            # this means the method is used directly on _Object
+            # typically during deserialization of objects
+            obj_cls = typing.cast(type[Self], cls._get_type_from_id(object_id))
+
+        # Instantiate provider
+        obj = _Object.__new__(obj_cls)
+        rep = f"Object({object_id})"  # TODO(erikbern): dumb
+        obj._init(rep, is_another_app=is_another_app)
+        obj._hydrate(object_id, client, handle_metadata)
+
+        return obj
+
+    def _hydrate_from_other(self, other: Self):
+        self._hydrate(other.object_id, other.client, other._get_metadata())
+
+    def __repr__(self):
+        return self._rep
+
+    @property
+    def local_uuid(self):
+        """mdmd:hidden"""
+        return self._local_uuid
+
+    @property
+    def object_id(self) -> str:
+        """mdmd:hidden"""
+        if self._object_id is None:
+            raise AttributeError(f"Attempting to get object_id of unhydrated {self}")
+        return self._object_id
+
+    @property
+    def client(self) -> _Client:
+        """mdmd:hidden"""
+        if self._client is None:
+            raise AttributeError(f"Attempting to get client of unhydrated {self}")
+        return self._client
+
+    @property
+    def is_hydrated(self) -> bool:
+        """mdmd:hidden"""
+        return self._is_hydrated
+
+    @property
+    def deps(self) -> Callable[..., Sequence["_Object"]]:
+        """mdmd:hidden"""
+
+        def default_deps(*args, **kwargs) -> Sequence["_Object"]:
+            return []
+
+        return self._deps if self._deps is not None else default_deps
+
+    async def resolve(self, client: Optional[_Client] = None):
+        """mdmd:hidden"""
+        obj = self.__class__.__name__.strip("_")
+        deprecation_warning(
+            (2025, 1, 16),
+            f"The `{obj}.resolve` method is deprecated and will be removed in a future release."
+            f" Please use `{obj}.hydrate()` or `await {obj}.hydrate.aio()` instead."
+            "\n\nNote that it is rarely necessary to explicitly hydrate objects, as most methods"
+            " will lazily hydrate when needed.",
+            show_source=False,  # synchronicity interferes with attributing source correctly
+        )
+        await self.hydrate(client)
+
+    async def hydrate(self, client: Optional[_Client] = None) -> Self:
+        """Synchronize the local object with its identity on the Modal server.
+
+        It is rarely necessary to call this method explicitly, as most operations
+        will lazily hydrate when needed. The main use case is when you need to
+        access object metadata, such as its ID.
+        """
+        if self._is_hydrated:
+            if self.client._snapshotted and not self._is_rehydrated:
+                # memory snapshots capture references which must be rehydrated
+                # on restore to handle staleness.
+                logger.debug(f"rehydrating {self} after snapshot")
+                self._is_hydrated = False  # un-hydrate and re-resolve
+                c = client if client is not None else await _Client.from_env()
+                resolver = Resolver(c)
+                await resolver.load(typing.cast(_Object, self))
+                self._is_rehydrated = True
+                logger.debug(f"rehydrated {self} with client {id(c)}")
+        elif not self._hydrate_lazily:
+            # TODO(michael) can remove _hydrate lazily? I think all objects support it now?
+            self._validate_is_hydrated()
+        else:
+            c = client if client is not None else await _Client.from_env()
+            resolver = Resolver(c)
+            await resolver.load(self)
+        return self
+
+
+def live_method(method):
+    @wraps(method)
+    async def wrapped(self, *args, **kwargs):
+        await self.hydrate()
+        return await method(self, *args, **kwargs)
+
+    return wrapped
+
+
+def live_method_gen(method):
+    @wraps(method)
+    async def wrapped(self, *args, **kwargs):
+        await self.hydrate()
+        async with aclosing(method(self, *args, **kwargs)) as stream:
+            async for item in stream:
+                yield item
+
+    return wrapped

modal/_resolver.py

@@ -15,7 +15,7 @@ from .exception import NotFoundError
 if TYPE_CHECKING:
     from rich.tree import Tree
 
-    from modal.object import _Object
+    import modal._object
 
 
 class StatusRow:
@@ -33,7 +33,7 @@ class StatusRow:
             self._spinner.update(text=message)
 
     def finish(self, message):
-        if self._step_node is not None:
+        if self._step_node is not None and self._spinner is not None:
             from ._output import OutputManager
 
             self._spinner.update(text=message)
@@ -89,7 +89,7 @@ class Resolver:
         if obj._preload is not None:
             await obj._preload(obj, self, existing_object_id)
 
-    async def load(self, obj: "_Object", existing_object_id: Optional[str] = None):
+    async def load(self, obj: "modal._object._Object", existing_object_id: Optional[str] = None):
         if obj._is_hydrated and obj._is_another_app:
             # No need to reload this, it won't typically change
             if obj.local_uuid not in self._local_uuid_to_future:
@@ -124,6 +124,8 @@ class Resolver:
                 await TaskContext.gather(*[self.load(dep) for dep in obj.deps()])
 
                 # Load the object itself
+                if not obj._load:
+                    raise Exception(f"Object {obj} has no loader function")
                 try:
                     await obj._load(obj, self, existing_object_id)
                 except GRPCError as exc:
@@ -154,8 +156,8 @@ class Resolver:
         # TODO(elias): print original exception/trace rather than the Resolver-internal trace
         return await cached_future
 
-    def objects(self) -> list["_Object"]:
-        unique_objects: dict[str, "_Object"] = {}
+    def objects(self) -> list["modal._object._Object"]:
+        unique_objects: dict[str, "modal._object._Object"] = {}
         for fut in self._local_uuid_to_future.values():
             if not fut.done():
                 # this will raise an exception if not all loads have been awaited, but that *should* never happen

modal/_runtime/container_io_manager.py

@@ -35,7 +35,6 @@ from modal._utils.package_utils import parse_major_minor_version
 from modal.client import HEARTBEAT_INTERVAL, HEARTBEAT_TIMEOUT, _Client
 from modal.config import config, logger
 from modal.exception import ClientClosed, InputCancellation, InvalidError, SerializationError
-from modal.running_app import RunningApp, running_app_from_layout
 from modal_proto import api_pb2
 
 if TYPE_CHECKING:
@@ -449,16 +448,6 @@ class _ContainerIOManager:
 
             await asyncio.sleep(DYNAMIC_CONCURRENCY_INTERVAL_SECS)
 
-    async def get_app_objects(self, app_layout: api_pb2.AppLayout) -> RunningApp:
-        if len(app_layout.objects) == 0:
-            # TODO(erikbern): this should never happen! let's keep it in here for a short second
-            # until we've sanity checked that this is, in fact, dead code.
-            req = api_pb2.AppGetLayoutRequest(app_id=self.app_id)
-            resp = await retry_transient_errors(self._client.stub.AppGetLayout, req)
-            app_layout = resp.app_layout
-
-        return running_app_from_layout(self.app_id, app_layout)
-
     async def get_serialized_function(self) -> tuple[Optional[Any], Optional[Callable[..., Any]]]:
         # Fetch the serialized function definition
         request = api_pb2.FunctionGetSerializedRequest(function_id=self.function_id)

modal/_runtime/user_code_imports.py

@@ -3,11 +3,11 @@ import importlib
 import typing
 from abc import ABCMeta, abstractmethod
 from dataclasses import dataclass
-from typing import Any, Callable, Optional
+from typing import Any, Callable, Optional, Sequence
 
+import modal._object
 import modal._runtime.container_io_manager
 import modal.cls
-import modal.object
 from modal import Function
 from modal._utils.async_utils import synchronizer
 from modal._utils.function_utils import LocalFunctionError, is_async as get_is_async, is_global_object
@@ -41,7 +41,7 @@ class Service(metaclass=ABCMeta):
 
     user_cls_instance: Any
     app: Optional["modal.app._App"]
-    code_deps: Optional[list["modal.object._Object"]]
+    code_deps: Optional[Sequence["modal._object._Object"]]
 
     @abstractmethod
     def get_finalized_functions(
@@ -94,7 +94,7 @@ def construct_webhook_callable(
 class ImportedFunction(Service):
     user_cls_instance: Any
     app: Optional["modal.app._App"]
-    code_deps: Optional[list["modal.object._Object"]]
+    code_deps: Optional[Sequence["modal._object._Object"]]
 
     _user_defined_callable: Callable[..., Any]
 
@@ -137,7 +137,7 @@ class ImportedFunction(Service):
 class ImportedClass(Service):
     user_cls_instance: Any
     app: Optional["modal.app._App"]
-    code_deps: Optional[list["modal.object._Object"]]
+    code_deps: Optional[Sequence["modal._object._Object"]]
 
     _partial_functions: dict[str, "modal.partial_function._PartialFunction"]
 
@@ -229,7 +229,7 @@ def import_single_function_service(
     """
     user_defined_callable: Callable
     function: Optional[_Function] = None
-    code_deps: Optional[list["modal.object._Object"]] = None
+    code_deps: Optional[Sequence["modal._object._Object"]] = None
     active_app: Optional[modal.app._App] = None
 
     if ser_fun is not None:
@@ -306,7 +306,7 @@ def import_class_service(
     See import_function.
     """
     active_app: Optional["modal.app._App"]
-    code_deps: Optional[list["modal.object._Object"]]
+    code_deps: Optional[Sequence["modal._object._Object"]]
     cls: typing.Union[type, modal.cls.Cls]
 
     if function_def.definition_type == api_pb2.Function.DEFINITION_TYPE_SERIALIZED:

modal/_serialization.py

@@ -8,10 +8,11 @@ from typing import Any
 from modal._utils.async_utils import synchronizer
 from modal_proto import api_pb2
 
+from ._object import _Object
 from ._vendor import cloudpickle
 from .config import logger
 from .exception import DeserializationError, ExecutionError, InvalidError
-from .object import Object, _Object
+from .object import Object
 
 PICKLE_PROTOCOL = 4  # Support older Python versions.
 
@@ -48,8 +49,8 @@ class Pickler(cloudpickle.Pickler):
             return ("sync", (impl_object.__class__, attributes))
         else:
             return
-        if not obj.object_id:
-            raise InvalidError(f"Can't serialize object {obj} which hasn't been created.")
+        if not obj.is_hydrated:
+            raise InvalidError(f"Can't serialize object {obj} which hasn't been hydrated.")
         return (obj.object_id, flag, obj._get_metadata())
 
 

modal/_tunnel.py

@@ -145,7 +145,7 @@ async def _forward(port: int, *, unencrypted: bool = False, client: Optional[_Cl
         modal.Image.debian_slim()
         .apt_install("openssh-server")
         .run_commands("mkdir /run/sshd")
-        .copy_local_file("~/.ssh/id_rsa.pub", "/root/.ssh/authorized_keys")
+        .add_local_file("~/.ssh/id_rsa.pub", "/root/.ssh/authorized_keys", copy=True)
     )
 
 

modal/app.py

@@ -21,6 +21,7 @@ from synchronicity.async_wrap import asynccontextmanager
 from modal_proto import api_pb2
 
 from ._ipython import is_notebook
+from ._object import _get_environment_name, _Object
 from ._utils.async_utils import synchronize_api
 from ._utils.deprecation import deprecation_error, deprecation_warning, renamed_parameter
 from ._utils.function_utils import FunctionInfo, is_global_object, is_method_fn
@@ -36,7 +37,6 @@ from .gpu import GPU_T
 from .image import _Image
 from .mount import _Mount
 from .network_file_system import _NetworkFileSystem
-from .object import _get_environment_name, _Object
 from .partial_function import (
     PartialFunction,
     _find_partial_methods_for_user_cls,
@@ -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.
 
@@ -211,12 +194,12 @@ class _App:
         self._name = name
         self._description = name
 
-        check_sequence(mounts, _Mount, "`mounts=` has to be a list or tuple of Mount objects")
-        check_sequence(secrets, _Secret, "`secrets=` has to be a list or tuple of Secret objects")
+        check_sequence(mounts, _Mount, "`mounts=` has to be a list or tuple of `modal.Mount` objects")
+        check_sequence(secrets, _Secret, "`secrets=` has to be a list or tuple of `modal.Secret` objects")
         validate_volumes(volumes)
 
         if image is not None and not isinstance(image, _Image):
-            raise InvalidError("image has to be a modal Image or AioImage object")
+            raise InvalidError("`image=` has to be a `modal.Image` object")
 
         self._functions = {}
         self._classes = {}
@@ -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
@@ -365,6 +320,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 +376,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):
@@ -442,11 +400,13 @@ class _App:
         return [m for m in all_mounts if m.is_local()]
 
     def _add_function(self, function: _Function, is_web_endpoint: bool):
-        if function.tag in self._functions:
+        if old_function := self._functions.get(function.tag, None):
+            if old_function is function:
+                return  # already added the same exact instance, ignore
+
             if not is_notebook():
-                old_function: _Function = self._functions[function.tag]
                 logger.warning(
-                    f"Warning: Tag '{function.tag}' collision!"
+                    f"Warning: function name '{function.tag}' collision!"
                     " Overriding existing function "
                     f"[{old_function._info.module_name}].{old_function._info.function_name}"
                     f" with new function [{function._info.module_name}].{function._info.function_name}"
@@ -504,7 +464,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
 
@@ -995,13 +955,6 @@ class _App:
         ```
         """
         for tag, function in other_app._functions.items():
-            existing_function = self._functions.get(tag)
-            if existing_function and existing_function != function:
-                logger.warning(
-                    f"Named app function {tag} with existing value {existing_function} is being "
-                    f"overwritten by a different function {function}"
-                )
-
             self._add_function(function, False)  # TODO(erikbern): webhook config?
 
         for tag, cls in other_app._classes.items():