modal 0.67.1__py3-none-any.whl → 0.67.33__py3-none-any.whl

modal/_vendor/a2wsgi_wsgi.py

@@ -35,10 +35,8 @@ from concurrent.futures import ThreadPoolExecutor
 from types import TracebackType
 from typing import (
     Any,
-    Awaitable,
     Callable,
     Dict,
-    Iterable,
     List,
     Literal,
     Optional,
@@ -48,6 +46,7 @@ from typing import (
     TypedDict,
     Union,
 )
+from collections.abc import Awaitable, Iterable
 
 
 ## BEGIN a2wsgi/asgi_typing.py
@@ -73,11 +72,11 @@ class HTTPScope(TypedDict):
     raw_path: NotRequired[bytes]
     query_string: bytes
     root_path: str
-    headers: Iterable[Tuple[bytes, bytes]]
-    client: NotRequired[Tuple[str, int]]
-    server: NotRequired[Tuple[str, Optional[int]]]
-    state: NotRequired[Dict[str, Any]]
-    extensions: NotRequired[Dict[str, Dict[object, object]]]
+    headers: Iterable[tuple[bytes, bytes]]
+    client: NotRequired[tuple[str, int]]
+    server: NotRequired[tuple[str, Optional[int]]]
+    state: NotRequired[dict[str, Any]]
+    extensions: NotRequired[dict[str, dict[object, object]]]
 
 
 class WebSocketScope(TypedDict):
@@ -89,18 +88,18 @@ class WebSocketScope(TypedDict):
     raw_path: bytes
     query_string: bytes
     root_path: str
-    headers: Iterable[Tuple[bytes, bytes]]
-    client: NotRequired[Tuple[str, int]]
-    server: NotRequired[Tuple[str, Optional[int]]]
+    headers: Iterable[tuple[bytes, bytes]]
+    client: NotRequired[tuple[str, int]]
+    server: NotRequired[tuple[str, Optional[int]]]
     subprotocols: Iterable[str]
-    state: NotRequired[Dict[str, Any]]
-    extensions: NotRequired[Dict[str, Dict[object, object]]]
+    state: NotRequired[dict[str, Any]]
+    extensions: NotRequired[dict[str, dict[object, object]]]
 
 
 class LifespanScope(TypedDict):
     type: Literal["lifespan"]
     asgi: ASGIVersions
-    state: NotRequired[Dict[str, Any]]
+    state: NotRequired[dict[str, Any]]
 
 
 WWWScope = Union[HTTPScope, WebSocketScope]
@@ -116,7 +115,7 @@ class HTTPRequestEvent(TypedDict):
 class HTTPResponseStartEvent(TypedDict):
     type: Literal["http.response.start"]
     status: int
-    headers: NotRequired[Iterable[Tuple[bytes, bytes]]]
+    headers: NotRequired[Iterable[tuple[bytes, bytes]]]
     trailers: NotRequired[bool]
 
 
@@ -137,7 +136,7 @@ class WebSocketConnectEvent(TypedDict):
 class WebSocketAcceptEvent(TypedDict):
     type: Literal["websocket.accept"]
     subprotocol: NotRequired[str]
-    headers: NotRequired[Iterable[Tuple[bytes, bytes]]]
+    headers: NotRequired[Iterable[tuple[bytes, bytes]]]
 
 
 class WebSocketReceiveEvent(TypedDict):
@@ -223,56 +222,47 @@ ASGIApp = Callable[[Scope, Receive, Send], Awaitable[None]]
 
 ## BEGIN a2wsgi/wsgi_typing.py
 
-CGIRequiredDefined = TypedDict(
-    "CGIRequiredDefined",
-    {
-        # The HTTP request method, such as GET or POST. This cannot ever be an
-        # empty string, and so is always required.
-        "REQUEST_METHOD": str,
-        # When HTTP_HOST is not set, these variables can be combined to determine
-        # a default.
-        # SERVER_NAME and SERVER_PORT are required strings and must never be empty.
-        "SERVER_NAME": str,
-        "SERVER_PORT": str,
-        # The version of the protocol the client used to send the request.
-        # Typically this will be something like "HTTP/1.0" or "HTTP/1.1" and
-        # may be used by the application to determine how to treat any HTTP
-        # request headers. (This variable should probably be called REQUEST_PROTOCOL,
-        # since it denotes the protocol used in the request, and is not necessarily
-        # the protocol that will be used in the server's response. However, for
-        # compatibility with CGI we have to keep the existing name.)
-        "SERVER_PROTOCOL": str,
-    },
-)
-
-CGIOptionalDefined = TypedDict(
-    "CGIOptionalDefined",
-    {
-        "REQUEST_URI": str,
-        "REMOTE_ADDR": str,
-        "REMOTE_PORT": str,
-        # The initial portion of the request URL’s “path” that corresponds to the
-        # application object, so that the application knows its virtual “location”.
-        # This may be an empty string, if the application corresponds to the “root”
-        # of the server.
-        "SCRIPT_NAME": str,
-        # The remainder of the request URL’s “path”, designating the virtual
-        # “location” of the request’s target within the application. This may be an
-        # empty string, if the request URL targets the application root and does
-        # not have a trailing slash.
-        "PATH_INFO": str,
-        # The portion of the request URL that follows the “?”, if any. May be empty
-        # or absent.
-        "QUERY_STRING": str,
-        # The contents of any Content-Type fields in the HTTP request. May be empty
-        # or absent.
-        "CONTENT_TYPE": str,
-        # The contents of any Content-Length fields in the HTTP request. May be empty
-        # or absent.
-        "CONTENT_LENGTH": str,
-    },
-    total=False,
-)
+class CGIRequiredDefined(TypedDict):
+    # The HTTP request method, such as GET or POST. This cannot ever be an
+    # empty string, and so is always required.
+    REQUEST_METHOD: str
+    # When HTTP_HOST is not set, these variables can be combined to determine
+    # a default.
+    # SERVER_NAME and SERVER_PORT are required strings and must never be empty.
+    SERVER_NAME: str
+    SERVER_PORT: str
+    # The version of the protocol the client used to send the request.
+    # Typically this will be something like "HTTP/1.0" or "HTTP/1.1" and
+    # may be used by the application to determine how to treat any HTTP
+    # request headers. (This variable should probably be called REQUEST_PROTOCOL,
+    # since it denotes the protocol used in the request, and is not necessarily
+    # the protocol that will be used in the server's response. However, for
+    # compatibility with CGI we have to keep the existing name.)
+    SERVER_PROTOCOL: str
+
+class CGIOptionalDefined(TypedDict, total=False):
+    REQUEST_URI: str
+    REMOTE_ADDR: str
+    REMOTE_PORT: str
+    # The initial portion of the request URL’s “path” that corresponds to the
+    # application object, so that the application knows its virtual “location”.
+    # This may be an empty string, if the application corresponds to the “root”
+    # of the server.
+    SCRIPT_NAME: str
+    # The remainder of the request URL’s “path”, designating the virtual
+    # “location” of the request’s target within the application. This may be an
+    # empty string, if the request URL targets the application root and does
+    # not have a trailing slash.
+    PATH_INFO: str
+    # The portion of the request URL that follows the “?”, if any. May be empty
+    # or absent.
+    QUERY_STRING: str
+    # The contents of any Content-Type fields in the HTTP request. May be empty
+    # or absent.
+    CONTENT_TYPE: str
+    # The contents of any Content-Length fields in the HTTP request. May be empty
+    # or absent.
+    CONTENT_LENGTH: str
 
 
 class InputStream(Protocol):
@@ -308,7 +298,7 @@ class InputStream(Protocol):
         """
         raise NotImplementedError
 
-    def readlines(self, hint: int = -1, /) -> List[bytes]:
+    def readlines(self, hint: int = -1, /) -> list[bytes]:
         """
         Note that the hint argument to readlines() is optional for both caller and
         implementer. The application is free not to supply it, and the server or gateway
@@ -349,14 +339,14 @@ class ErrorStream(Protocol):
     def write(self, s: str, /) -> Any:
         raise NotImplementedError
 
-    def writelines(self, seq: List[str], /) -> Any:
+    def writelines(self, seq: list[str], /) -> Any:
         raise NotImplementedError
 
 
 WSGIDefined = TypedDict(
     "WSGIDefined",
     {
-        "wsgi.version": Tuple[int, int],  # e.g. (1, 0)
+        "wsgi.version": tuple[int, int],  # e.g. (1, 0)
         "wsgi.url_scheme": str,  # e.g. "http" or "https"
         "wsgi.input": InputStream,
         "wsgi.errors": ErrorStream,
@@ -381,7 +371,7 @@ class Environ(CGIRequiredDefined, CGIOptionalDefined, WSGIDefined):
     """
 
 
-ExceptionInfo = Tuple[Type[BaseException], BaseException, Optional[TracebackType]]
+ExceptionInfo = tuple[type[BaseException], BaseException, Optional[TracebackType]]
 
 # https://peps.python.org/pep-3333/#the-write-callable
 WriteCallable = Callable[[bytes], None]
@@ -391,7 +381,7 @@ class StartResponse(Protocol):
     def __call__(
         self,
         status: str,
-        response_headers: List[Tuple[str, str]],
+        response_headers: list[tuple[str, str]],
         exc_info: Optional[ExceptionInfo] = None,
         /,
     ) -> WriteCallable:
@@ -460,7 +450,7 @@ class Body:
         self.buffer.clear()
         return result
 
-    def readlines(self, hint: int = -1) -> typing.List[bytes]:
+    def readlines(self, hint: int = -1) -> list[bytes]:
         if not self.has_more:
             return []
         if hint == -1:
@@ -626,7 +616,7 @@ class WSGIResponder:
     def start_response(
         self,
         status: str,
-        response_headers: typing.List[typing.Tuple[str, str]],
+        response_headers: list[tuple[str, str]],
         exc_info: typing.Optional[ExceptionInfo] = None,
     ) -> WriteCallable:
         self.exc_info = exc_info

modal/_vendor/cloudpickle.py

@@ -256,7 +256,7 @@ def _should_pickle_by_reference(obj, name=None):
             return False
         return obj.__name__ in sys.modules
     else:
-        raise TypeError("cannot check importability of {} instances".format(type(obj).__name__))
+        raise TypeError(f"cannot check importability of {type(obj).__name__} instances")
 
 
 def _lookup_module_and_qualname(obj, name=None):

modal/_watcher.py

@@ -1,7 +1,8 @@
 # Copyright Modal Labs 2022
 from collections import defaultdict
+from collections.abc import AsyncGenerator
 from pathlib import Path
-from typing import AsyncGenerator, Dict, List, Optional, Set, Tuple
+from typing import Optional
 
 from rich.tree import Tree
 from watchfiles import Change, DefaultFilter, awatch
@@ -21,7 +22,7 @@ class AppFilesFilter(DefaultFilter):
         # Watching specific files is discouraged on Linux, so to watch a file we watch its
         # containing directory and then filter that directory's changes for relevant files.
         # https://github.com/notify-rs/notify/issues/394
-        dir_filters: Dict[Path, Optional[Set[Path]]],
+        dir_filters: dict[Path, Optional[set[Path]]],
     ) -> None:
         self.dir_filters = dir_filters
         super().__init__()
@@ -54,7 +55,7 @@ class AppFilesFilter(DefaultFilter):
         return super().__call__(change, path)
 
 
-async def _watch_paths(paths: Set[Path], watch_filter: AppFilesFilter) -> AsyncGenerator[Set[str], None]:
+async def _watch_paths(paths: set[Path], watch_filter: AppFilesFilter) -> AsyncGenerator[set[str], None]:
     try:
         async for changes in awatch(*paths, step=500, watch_filter=watch_filter):
             changed_paths = {stringpath for _, stringpath in changes}
@@ -64,7 +65,7 @@ async def _watch_paths(paths: Set[Path], watch_filter: AppFilesFilter) -> AsyncG
         pass
 
 
-def _print_watched_paths(paths: Set[Path]):
+def _print_watched_paths(paths: set[Path]):
     msg = "️️⚡️ Serving... hit Ctrl-C to stop!"
 
     output_tree = Tree(msg, guide_style="gray50")
@@ -76,9 +77,9 @@ def _print_watched_paths(paths: Set[Path]):
         output_mgr.print(output_tree)
 
 
-def _watch_args_from_mounts(mounts: List[_Mount]) -> Tuple[Set[Path], AppFilesFilter]:
+def _watch_args_from_mounts(mounts: list[_Mount]) -> tuple[set[Path], AppFilesFilter]:
     paths = set()
-    dir_filters: Dict[Path, Optional[Set[Path]]] = defaultdict(set)
+    dir_filters: dict[Path, Optional[set[Path]]] = defaultdict(set)
     for mount in mounts:
         # TODO(elias): Make this part of the mount class instead, since it uses so much internals
         for entry in mount._entries:
@@ -94,7 +95,7 @@ def _watch_args_from_mounts(mounts: List[_Mount]) -> Tuple[Set[Path], AppFilesFi
     return paths, watch_filter
 
 
-async def watch(mounts: List[_Mount]) -> AsyncGenerator[Set[str], None]:
+async def watch(mounts: list[_Mount]) -> AsyncGenerator[set[str], None]:
     paths, watch_filter = _watch_args_from_mounts(mounts)
 
     _print_watched_paths(paths)

modal/app.py

@@ -2,19 +2,14 @@
 import inspect
 import typing
 import warnings
+from collections.abc import AsyncGenerator, Coroutine, Sequence
 from pathlib import PurePosixPath
 from textwrap import dedent
 from typing import (
     Any,
-    AsyncGenerator,
     Callable,
     ClassVar,
-    Coroutine,
-    Dict,
-    List,
     Optional,
-    Sequence,
-    Tuple,
     Union,
     overload,
 )
@@ -87,14 +82,14 @@ class _LocalEntrypoint:
 LocalEntrypoint = synchronize_api(_LocalEntrypoint)
 
 
-def check_sequence(items: typing.Sequence[typing.Any], item_type: typing.Type[typing.Any], error_msg: str) -> None:
+def check_sequence(items: typing.Sequence[typing.Any], item_type: type[typing.Any], error_msg: str) -> None:
     if not isinstance(items, (list, tuple)):
         raise InvalidError(error_msg)
     if not all(isinstance(v, item_type) for v in items):
         raise InvalidError(error_msg)
 
 
-CLS_T = typing.TypeVar("CLS_T", bound=typing.Type[Any])
+CLS_T = typing.TypeVar("CLS_T", bound=type[Any])
 
 
 P = typing_extensions.ParamSpec("P")
@@ -172,20 +167,20 @@ class _App:
     In this example, the secret and schedule are registered with the app.
     """
 
-    _all_apps: ClassVar[Dict[Optional[str], List["_App"]]] = {}
+    _all_apps: ClassVar[dict[Optional[str], list["_App"]]] = {}
     _container_app: ClassVar[Optional[RunningApp]] = None
 
     _name: Optional[str]
     _description: Optional[str]
-    _functions: Dict[str, _Function]
-    _classes: Dict[str, _Cls]
+    _functions: dict[str, _Function]
+    _classes: dict[str, _Cls]
 
     _image: Optional[_Image]
     _mounts: Sequence[_Mount]
     _secrets: Sequence[_Secret]
-    _volumes: Dict[Union[str, PurePosixPath], _Volume]
-    _web_endpoints: List[str]  # Used by the CLI
-    _local_entrypoints: Dict[str, _LocalEntrypoint]
+    _volumes: dict[Union[str, PurePosixPath], _Volume]
+    _web_endpoints: list[str]  # Used by the CLI
+    _local_entrypoints: dict[str, _LocalEntrypoint]
 
     # Running apps only (container apps or running local)
     _app_id: Optional[str]  # Kept after app finishes
@@ -199,7 +194,7 @@ class _App:
         image: Optional[_Image] = None,  # default image for all functions (default is `modal.Image.debian_slim()`)
         mounts: Sequence[_Mount] = [],  # default mounts for all functions
         secrets: Sequence[_Secret] = [],  # default secrets for all functions
-        volumes: Dict[Union[str, PurePosixPath], _Volume] = {},  # default volumes for all functions
+        volumes: dict[Union[str, PurePosixPath], _Volume] = {},  # default volumes for all functions
     ) -> None:
         """Construct a new app, optionally with default image, mounts, secrets, or volumes.
 
@@ -313,23 +308,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 _add_object(self, tag, obj):
-        # TODO(erikbern): replace this with _add_function and _add_class
-        if self._running_app:
-            # If this is inside a container, then objects can be defined after app initialization.
-            # So we may have to initialize objects once they get bound to the app.
-            if tag in self._running_app.tag_to_object_id:
-                object_id: str = self._running_app.tag_to_object_id[tag]
-                metadata: Message = self._running_app.object_handle_metadata[object_id]
-                obj._hydrate(object_id, self._client, metadata)
-
-        if isinstance(obj, _Function):
-            self._functions[tag] = obj
-        elif isinstance(obj, _Cls):
-            self._classes[tag] = obj
-        else:
-            raise RuntimeError(f"Expected `obj` to be a _Function or _Cls (got {type(obj)}")
-
     def __getitem__(self, tag: str):
         deprecation_error((2024, 3, 25), _app_attr_error)
 
@@ -401,14 +379,14 @@ class _App:
 
         **Example**
 
-        ```python
+        ```python notest
         with app.run():
             some_modal_function.remote()
         ```
 
         To enable output printing, use `modal.enable_output()`:
 
-        ```python
+        ```python notest
         with modal.enable_output():
             with app.run():
                 some_modal_function.remote()
@@ -481,10 +459,29 @@ class _App:
         if function.tag in self._classes:
             logger.warning(f"Warning: tag {function.tag} exists but is overridden by function")
 
-        self._add_object(function.tag, function)
+        if self._running_app:
+            # If this is inside a container, then objects can be defined after app initialization.
+            # So we may have to initialize objects once they get bound to the app.
+            if function.tag in self._running_app.tag_to_object_id:
+                object_id: str = self._running_app.tag_to_object_id[function.tag]
+                metadata: Message = self._running_app.object_handle_metadata[object_id]
+                function._hydrate(object_id, self._client, metadata)
+
+        self._functions[function.tag] = function
         if is_web_endpoint:
             self._web_endpoints.append(function.tag)
 
+    def _add_class(self, tag: str, cls: _Cls):
+        if self._running_app:
+            # If this is inside a container, then objects can be defined after app initialization.
+            # So we may have to initialize objects once they get bound to the app.
+            if tag in self._running_app.tag_to_object_id:
+                object_id: str = self._running_app.tag_to_object_id[tag]
+                metadata: Message = self._running_app.object_handle_metadata[object_id]
+                cls._hydrate(object_id, self._client, metadata)
+
+        self._classes[tag] = cls
+
     def _init_container(self, client: _Client, running_app: RunningApp):
         self._app_id = running_app.app_id
         self._running_app = running_app
@@ -507,22 +504,22 @@ class _App:
         hydrate_objects(self._classes)
 
     @property
-    def registered_functions(self) -> Dict[str, _Function]:
+    def registered_functions(self) -> dict[str, _Function]:
         """All modal.Function objects registered on the app."""
         return self._functions
 
     @property
-    def registered_classes(self) -> Dict[str, _Function]:
+    def registered_classes(self) -> dict[str, _Function]:
         """All modal.Cls objects registered on the app."""
         return self._classes
 
     @property
-    def registered_entrypoints(self) -> Dict[str, _LocalEntrypoint]:
+    def registered_entrypoints(self) -> dict[str, _LocalEntrypoint]:
         """All local CLI entrypoints registered on the app."""
         return self._local_entrypoints
 
     @property
-    def indexed_objects(self) -> Dict[str, _Object]:
+    def indexed_objects(self) -> dict[str, _Object]:
         deprecation_warning(
             (2024, 11, 25),
             "`app.indexed_objects` is deprecated! Use `app.registered_functions` or `app.registered_classes` instead.",
@@ -530,7 +527,7 @@ class _App:
         return dict(**self._functions, **self._classes)
 
     @property
-    def registered_web_endpoints(self) -> List[str]:
+    def registered_web_endpoints(self) -> list[str]:
         """Names of web endpoint (ie. webhook) functions registered on the app."""
         return self._web_endpoints
 
@@ -609,24 +606,24 @@ class _App:
         schedule: Optional[Schedule] = None,  # An optional Modal Schedule for the function
         secrets: Sequence[_Secret] = (),  # Optional Modal Secret objects with environment variables for the container
         gpu: Union[
-            GPU_T, List[GPU_T]
+            GPU_T, list[GPU_T]
         ] = None,  # GPU request as string ("any", "T4", ...), object (`modal.GPU.A100()`, ...), or a list of either
         serialized: bool = False,  # Whether to send the function over using cloudpickle.
         mounts: Sequence[_Mount] = (),  # Modal Mounts added to the container
-        network_file_systems: Dict[
+        network_file_systems: dict[
             Union[str, PurePosixPath], _NetworkFileSystem
         ] = {},  # Mountpoints for Modal NetworkFileSystems
-        volumes: Dict[
+        volumes: dict[
             Union[str, PurePosixPath], Union[_Volume, _CloudBucketMount]
         ] = {},  # Mount points for Modal Volumes & CloudBucketMounts
         allow_cross_region_volumes: bool = False,  # Whether using network file systems from other regions is allowed.
         # Specify, in fractional CPU cores, how many CPU cores to request.
         # Or, pass (request, limit) to additionally specify a hard limit in fractional CPU cores.
         # CPU throttling will prevent a container from exceeding its specified limit.
-        cpu: Optional[Union[float, Tuple[float, float]]] = None,
+        cpu: Optional[Union[float, tuple[float, float]]] = None,
         # Specify, in MiB, a memory request which is the minimum memory required.
         # Or, pass (request, limit) to additionally specify a hard limit in MiB.
-        memory: Optional[Union[int, Tuple[int, int]]] = None,
+        memory: Optional[Union[int, tuple[int, int]]] = None,
         ephemeral_disk: Optional[int] = None,  # Specify, in MiB, the ephemeral disk size for the Function.
         proxy: Optional[_Proxy] = None,  # Reference to a Modal Proxy to use in front of this function.
         retries: Optional[Union[int, Retries]] = None,  # Number of times to retry each input in case of failure.
@@ -815,24 +812,24 @@ class _App:
         image: Optional[_Image] = None,  # The image to run as the container for the function
         secrets: Sequence[_Secret] = (),  # Optional Modal Secret objects with environment variables for the container
         gpu: Union[
-            GPU_T, List[GPU_T]
+            GPU_T, list[GPU_T]
         ] = None,  # GPU request as string ("any", "T4", ...), object (`modal.GPU.A100()`, ...), or a list of either
         serialized: bool = False,  # Whether to send the function over using cloudpickle.
         mounts: Sequence[_Mount] = (),
-        network_file_systems: Dict[
+        network_file_systems: dict[
             Union[str, PurePosixPath], _NetworkFileSystem
         ] = {},  # Mountpoints for Modal NetworkFileSystems
-        volumes: Dict[
+        volumes: dict[
             Union[str, PurePosixPath], Union[_Volume, _CloudBucketMount]
         ] = {},  # Mount points for Modal Volumes & CloudBucketMounts
         allow_cross_region_volumes: bool = False,  # Whether using network file systems from other regions is allowed.
         # Specify, in fractional CPU cores, how many CPU cores to request.
         # Or, pass (request, limit) to additionally specify a hard limit in fractional CPU cores.
         # CPU throttling will prevent a container from exceeding its specified limit.
-        cpu: Optional[Union[float, Tuple[float, float]]] = None,
+        cpu: Optional[Union[float, tuple[float, float]]] = None,
         # Specify, in MiB, a memory request which is the minimum memory required.
         # Or, pass (request, limit) to additionally specify a hard limit in MiB.
-        memory: Optional[Union[int, Tuple[int, int]]] = None,
+        memory: Optional[Union[int, tuple[int, int]]] = None,
         ephemeral_disk: Optional[int] = None,  # Specify, in MiB, the ephemeral disk size for the Function.
         proxy: Optional[_Proxy] = None,  # Reference to a Modal Proxy to use in front of this function.
         retries: Optional[Union[int, Retries]] = None,  # Number of times to retry each input in case of failure.
@@ -935,7 +932,7 @@ class _App:
             cls: _Cls = _Cls.from_local(user_cls, self, cls_func)
 
             tag: str = user_cls.__name__
-            self._add_object(tag, cls)
+            self._add_class(tag, cls)
             return cls  # type: ignore  # a _Cls instance "simulates" being the user provided class
 
         return wrapper
@@ -946,7 +943,7 @@ class _App:
         image: Optional[_Image] = None,  # The image to run as the container for the sandbox.
         mounts: Sequence[_Mount] = (),  # Mounts to attach to the sandbox.
         secrets: Sequence[_Secret] = (),  # Environment variables to inject into the sandbox.
-        network_file_systems: Dict[Union[str, PurePosixPath], _NetworkFileSystem] = {},
+        network_file_systems: dict[Union[str, PurePosixPath], _NetworkFileSystem] = {},
         timeout: Optional[int] = None,  # Maximum execution time of the sandbox in seconds.
         workdir: Optional[str] = None,  # Working directory of the sandbox.
         gpu: GPU_T = None,
@@ -955,12 +952,12 @@ class _App:
         # Specify, in fractional CPU cores, how many CPU cores to request.
         # Or, pass (request, limit) to additionally specify a hard limit in fractional CPU cores.
         # CPU throttling will prevent a container from exceeding its specified limit.
-        cpu: Optional[Union[float, Tuple[float, float]]] = None,
+        cpu: Optional[Union[float, tuple[float, float]]] = None,
         # Specify, in MiB, a memory request which is the minimum memory required.
         # Or, pass (request, limit) to additionally specify a hard limit in MiB.
-        memory: Optional[Union[int, Tuple[int, int]]] = None,
+        memory: Optional[Union[int, tuple[int, int]]] = None,
         block_network: bool = False,  # Whether to block network access
-        volumes: Dict[
+        volumes: dict[
             Union[str, PurePosixPath], Union[_Volume, _CloudBucketMount]
         ] = {},  # Mount points for Modal Volumes and CloudBucketMounts
         pty_info: Optional[api_pb2.PTYInfo] = None,
@@ -1022,16 +1019,25 @@ class _App:
             bar.remote()
         ```
         """
-        indexed_objects = dict(**other_app._functions, **other_app._classes)
-        for tag, object in indexed_objects.items():
-            existing_object = indexed_objects.get(tag)
-            if existing_object and existing_object != object:
+        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():
+            existing_cls = self._classes.get(tag)
+            if existing_cls and existing_cls != cls:
                 logger.warning(
-                    f"Named app object {tag} with existing value {existing_object} is being "
-                    f"overwritten by a different object {object}"
+                    f"Named app class {tag} with existing value {existing_cls} is being "
+                    f"overwritten by a different class {cls}"
                 )
 
-            self._add_object(tag, object)
+            self._add_class(tag, cls)
 
     async def _logs(self, client: Optional[_Client] = None) -> AsyncGenerator[str, None]:
         """Stream logs from the app.