modal 1.0.3.dev10__py3-none-any.whl → 1.2.3.dev7__py3-none-any.whl

modal/app.py

@@ -1,7 +1,8 @@
 # Copyright Modal Labs 2022
 import inspect
 import typing
-from collections.abc import AsyncGenerator, Coroutine, Sequence
+from collections.abc import AsyncGenerator, Collection, Coroutine, Mapping, Sequence
+from dataclasses import dataclass
 from pathlib import PurePosixPath
 from textwrap import dedent
 from typing import (
@@ -21,21 +22,22 @@ from modal_proto import api_pb2
 
 from ._functions import _Function
 from ._ipython import is_notebook
+from ._load_context import LoadContext
 from ._object import _get_environment_name, _Object
 from ._partial_function import (
     _find_partial_methods_for_user_cls,
     _PartialFunction,
     _PartialFunctionFlags,
+    verify_concurrent_params,
 )
 from ._utils.async_utils import synchronize_api
 from ._utils.deprecation import (
     deprecation_warning,
     warn_on_renamed_autoscaler_settings,
 )
-from ._utils.function_utils import FunctionInfo, is_global_object, is_method_fn
-from ._utils.grpc_utils import retry_transient_errors
+from ._utils.function_utils import FunctionInfo, is_flash_object, is_global_object, is_method_fn
 from ._utils.mount_utils import validate_volumes
-from ._utils.name_utils import check_object_name
+from ._utils.name_utils import check_object_name, check_tag_dict
 from .client import _Client
 from .cloud_bucket_mount import _CloudBucketMount
 from .cls import _Cls, parameter
@@ -114,6 +116,22 @@ class _FunctionDecoratorType:
     def __call__(self, func): ...
 
 
+@dataclass()
+class _LocalAppState:
+    """All state for apps that's part of the local/definition state"""
+
+    functions: dict[str, _Function]
+    classes: dict[str, _Cls]
+    image_default: Optional[_Image]
+    web_endpoints: list[str]  # Used by the CLI
+    local_entrypoints: dict[str, _LocalEntrypoint]
+    tags: dict[str, str]
+
+    include_source_default: bool
+    secrets_default: Sequence[_Secret]
+    volumes_default: dict[Union[str, PurePosixPath], _Volume]
+
+
 class _App:
     """A Modal App is a group of functions and classes that are deployed together.
 
@@ -151,30 +169,35 @@ class _App:
 
     _name: Optional[str]
     _description: Optional[str]
-    _functions: dict[str, _Function]
-    _classes: dict[str, _Cls]
 
-    _image: Optional[_Image]
-    _secrets: Sequence[_Secret]
-    _volumes: dict[Union[str, PurePosixPath], _Volume]
-    _web_endpoints: list[str]  # Used by the CLI
-    _local_entrypoints: dict[str, _LocalEntrypoint]
+    _local_state_attr: Optional[_LocalAppState] = None
 
     # Running apps only (container apps or running local)
     _app_id: Optional[str]  # Kept after app finishes
     _running_app: Optional[RunningApp]  # Various app info
     _client: Optional[_Client]
 
-    _include_source_default: Optional[bool] = None
+    # Metadata for loading objects within this app
+    # passed by reference to functions and classes so it can be updated by run()/deploy()
+    _root_load_context: LoadContext
+
+    @property
+    def _local_state(self) -> _LocalAppState:
+        """For internal use only. Do not use this property directly."""
+
+        if self._local_state_attr is None:
+            raise AttributeError("Local state is not initialized - app is not locally available")
+        return self._local_state_attr
 
     def __init__(
         self,
         name: Optional[str] = None,
         *,
-        image: Optional[_Image] = None,  # default image for all functions (default is `modal.Image.debian_slim()`)
-        secrets: Sequence[_Secret] = [],  # default secrets for all functions
-        volumes: dict[Union[str, PurePosixPath], _Volume] = {},  # default volumes for all functions
-        include_source: Optional[bool] = None,
+        tags: Optional[dict[str, str]] = None,  # Additional metadata to set on the App
+        image: Optional[_Image] = None,  # Default Image for the App (otherwise default to `modal.Image.debian_slim()`)
+        secrets: Sequence[_Secret] = [],  # Secrets to add for all Functions in the App
+        volumes: dict[Union[str, PurePosixPath], _Volume] = {},  # Volume mounts to use for all Functions
+        include_source: bool = True,  # Default configuration for adding Function source file(s) to the Modal container
     ) -> None:
         """Construct a new app, optionally with default image, mounts, secrets, or volumes.
 
@@ -188,9 +211,11 @@ class _App:
         if name is not None and not isinstance(name, str):
             raise InvalidError("Invalid value for `name`: Must be string.")
 
+        if tags is not None:
+            check_tag_dict(tags)
+
         self._name = name
         self._description = name
-        self._include_source_default = include_source
 
         check_sequence(secrets, _Secret, "`secrets=` has to be a list or tuple of `modal.Secret` objects")
         validate_volumes(volumes)
@@ -198,17 +223,26 @@ class _App:
         if image is not None and not isinstance(image, _Image):
             raise InvalidError("`image=` has to be a `modal.Image` object")
 
-        self._functions = {}
-        self._classes = {}
-        self._image = image
-        self._secrets = secrets
-        self._volumes = volumes
-        self._local_entrypoints = {}
-        self._web_endpoints = []
+        self._local_state_attr = _LocalAppState(
+            functions={},
+            classes={},
+            image_default=image,
+            secrets_default=secrets,
+            volumes_default=volumes,
+            include_source_default=include_source,
+            web_endpoints=[],
+            local_entrypoints={},
+            tags=tags or {},
+        )
 
+        # Running apps only
         self._app_id = None
         self._running_app = None  # Set inside container, OR during the time an app is running locally
+
+        # Client is special - needed to be set just before the app is "hydrated" or running at the latest
+        # Guaranteed to be set for running apps, but also needed to actually *hydrate* the app and make it running
         self._client = None
+        self._root_load_context = LoadContext.empty()
 
         # Register this app. This is used to look up the app in the container, when we can't get it from the function
         _App._all_apps.setdefault(self._name, []).append(self)
@@ -220,7 +254,12 @@ class _App:
 
     @property
     def is_interactive(self) -> bool:
-        """Whether the current app for the app is running in interactive mode."""
+        """mdmd:hidden
+        Whether the current app for the app is running in interactive mode.
+
+        Note: this method will likely be deprecated in the future.
+
+        """
         # return self._name
         if self._running_app:
             return self._running_app.interactive
@@ -269,15 +308,22 @@ class _App:
             object_creation_type=(api_pb2.OBJECT_CREATION_TYPE_CREATE_IF_MISSING if create_if_missing else None),
         )
 
-        response = await retry_transient_errors(client.stub.AppGetOrCreate, request)
+        response = await client.stub.AppGetOrCreate(request)
 
-        app = _App(name)
+        app = _App(name)  # TODO: this should probably be a distinct constructor, possibly even a distinct type
+        app._local_state_attr = None  # this is not a locally defined App, so no local state
         app._app_id = response.app_id
         app._client = client
+        app._root_load_context = LoadContext(client=client, environment_name=environment_name, app_id=response.app_id)
         app._running_app = RunningApp(response.app_id, interactive=False)
         return app
 
     def set_description(self, description: str):
+        """mdmd:hidden
+        Set the description of the App before it starts running.
+
+        Note: we don't recommend using the method and may deprecate it in the future.
+        """
         self._description = description
 
     def _validate_blueprint_value(self, key: str, value: Any):
@@ -286,17 +332,26 @@ class _App:
 
     @property
     def image(self) -> _Image:
-        return self._image
+        """mdmd:hidden
+        Retrieve the Image that will be used as the default for any Functions registered to the App.
+
+        Note: This property is only relevant in the build phase and won't be populated on a deployed
+        App that is retrieved via `modal.App.lookup`. It is likely to be deprecated in the future.
+
+        """
+        return self._local_state.image_default
 
     @image.setter
     def image(self, value):
-        self._image = value
+        """mdmd:hidden"""
+        self._local_state.image_default = value
 
     def _uncreate_all_objects(self):
         # TODO(erikbern): this doesn't unhydrate objects that aren't tagged
-        for obj in self._functions.values():
+        local_state = self._local_state
+        for obj in local_state.functions.values():
             obj._unhydrate()
-        for obj in self._classes.values():
+        for obj in local_state.classes.values():
             obj._unhydrate()
 
     @asynccontextmanager
@@ -371,8 +426,8 @@ class _App:
         *,
         name: Optional[str] = None,  # Name for the deployment, overriding any set on the App
         environment_name: Optional[str] = None,  # Environment to deploy the App in
-        tag: str = "",  # Optional metadata that will be visible in the deployment history
-        client: Optional[_Client] = None,  # Alternate client to use for RPCs
+        tag: str = "",  # Optional metadata that is specific to this deployment
+        client: Optional[_Client] = None,  # Alternate client to use for communication with the server
     ) -> typing_extensions.Self:
         """Deploy the App so that it is available persistently.
 
@@ -432,8 +487,9 @@ class _App:
         return self
 
     def _get_default_image(self):
-        if self._image:
-            return self._image
+        local_state = self._local_state
+        if local_state.image_default:
+            return local_state.image_default
         else:
             return _default_image
 
@@ -448,7 +504,8 @@ class _App:
         return [m for m in all_mounts if m.is_local()]
 
     def _add_function(self, function: _Function, is_web_endpoint: bool):
-        if old_function := self._functions.get(function.tag, None):
+        local_state = self._local_state
+        if old_function := local_state.functions.get(function.tag, None):
             if old_function is function:
                 return  # already added the same exact instance, ignore
 
@@ -459,7 +516,7 @@ class _App:
                     f"[{old_function._info.module_name}].{old_function._info.function_name}"
                     f" with new function [{function._info.module_name}].{function._info.function_name}"
                 )
-        if function.tag in self._classes:
+        if function.tag in local_state.classes:
             logger.warning(f"Warning: tag {function.tag} exists but is overridden by function")
 
         if self._running_app:
@@ -470,9 +527,9 @@ class _App:
                 metadata: Message = self._running_app.object_handle_metadata[object_id]
                 function._hydrate(object_id, self._client, metadata)
 
-        self._functions[function.tag] = function
+        local_state.functions[function.tag] = function
         if is_web_endpoint:
-            self._web_endpoints.append(function.tag)
+            local_state.web_endpoints.append(function.tag)
 
     def _add_class(self, tag: str, cls: _Cls):
         if self._running_app:
@@ -483,7 +540,7 @@ class _App:
                 metadata: Message = self._running_app.object_handle_metadata[object_id]
                 cls._hydrate(object_id, self._client, metadata)
 
-        self._classes[tag] = cls
+        self._local_state.classes[tag] = cls
 
     def _init_container(self, client: _Client, running_app: RunningApp):
         self._app_id = running_app.app_id
@@ -491,40 +548,67 @@ class _App:
         self._client = client
 
         _App._container_app = self
-
+        local_state = self._local_state
         # Hydrate function objects
         for tag, object_id in running_app.function_ids.items():
-            if tag in self._functions:
-                obj = self._functions[tag]
+            if tag in local_state.functions:
+                obj = local_state.functions[tag]
                 handle_metadata = running_app.object_handle_metadata[object_id]
                 obj._hydrate(object_id, client, handle_metadata)
 
         # Hydrate class objects
         for tag, object_id in running_app.class_ids.items():
-            if tag in self._classes:
-                obj = self._classes[tag]
+            if tag in local_state.classes:
+                obj = local_state.classes[tag]
                 handle_metadata = running_app.object_handle_metadata[object_id]
                 obj._hydrate(object_id, client, handle_metadata)
 
     @property
     def registered_functions(self) -> dict[str, _Function]:
-        """All modal.Function objects registered on the app."""
-        return self._functions
+        """mdmd:hidden
+        All modal.Function objects registered on the app.
+
+        Note: this property is populated only during the build phase, and it is not
+        expected to work when a deplyoed App has been retrieved via `modal.App.lookup`.
+        This method is likely to be deprecated in the future in favor of a different
+        approach for retrieving the layout of a deployed App.
+        """
+        return self._local_state.functions
 
     @property
     def registered_classes(self) -> dict[str, _Cls]:
-        """All modal.Cls objects registered on the app."""
-        return self._classes
+        """mdmd:hidden
+        All modal.Cls objects registered on the app.
+
+        Note: this property is populated only during the build phase, and it is not
+        expected to work when a deplyoed App has been retrieved via `modal.App.lookup`.
+        This method is likely to be deprecated in the future in favor of a different
+        approach for retrieving the layout of a deployed App.
+        """
+        return self._local_state.classes
 
     @property
     def registered_entrypoints(self) -> dict[str, _LocalEntrypoint]:
-        """All local CLI entrypoints registered on the app."""
-        return self._local_entrypoints
+        """mdmd:hidden
+        All local CLI entrypoints registered on the app.
+
+        Note: this property is populated only during the build phase, and it is not
+        expected to work when a deplyoed App has been retrieved via `modal.App.lookup`.
+        This method is likely to be deprecated in the future.
+        """
+        return self._local_state.local_entrypoints
 
     @property
     def registered_web_endpoints(self) -> list[str]:
-        """Names of web endpoint (ie. webhook) functions registered on the app."""
-        return self._web_endpoints
+        """mdmd:hidden
+        Names of web endpoint (ie. webhook) functions registered on the app.
+
+        Note: this property is populated only during the build phase, and it is not
+        expected to work when a deplyoed App has been retrieved via `modal.App.lookup`.
+        This method is likely to be deprecated in the future in favor of a different
+        approach for retrieving the layout of a deployed App.
+        """
+        return self._local_state.web_endpoints
 
     def local_entrypoint(
         self, _warn_parentheses_missing: Any = None, *, name: Optional[str] = None
@@ -550,8 +634,8 @@ class _App:
         modal run app_module.py
         ```
 
-        Note that an explicit [`app.run()`](/docs/reference/modal.App#run) is not needed, as an
-        [app](/docs/guide/apps) is automatically created for you.
+        Note that an explicit [`app.run()`](https://modal.com/docs/reference/modal.App#run) is not needed, as an
+        [app](https://modal.com/docs/guide/apps) is automatically created for you.
 
         **Multiple Entrypoints**
 
@@ -585,10 +669,11 @@ class _App:
         def wrapped(raw_f: Callable[..., Any]) -> _LocalEntrypoint:
             info = FunctionInfo(raw_f)
             tag = name if name is not None else raw_f.__qualname__
-            if tag in self._local_entrypoints:
+            local_state = self._local_state
+            if tag in local_state.local_entrypoints:
                 # TODO: get rid of this limitation.
                 raise InvalidError(f"Duplicate local entrypoint name: {tag}. Local entrypoint names must be unique.")
-            entrypoint = self._local_entrypoints[tag] = _LocalEntrypoint(info, self)
+            entrypoint = local_state.local_entrypoints[tag] = _LocalEntrypoint(info, self)
             return entrypoint
 
         return wrapped
@@ -596,11 +681,12 @@ class _App:
     @warn_on_renamed_autoscaler_settings
     def function(
         self,
-        _warn_parentheses_missing: Any = None,
+        _warn_parentheses_missing=None,  # mdmd:line-hidden
         *,
         image: Optional[_Image] = None,  # The image to run as the container for the function
         schedule: Optional[Schedule] = None,  # An optional Modal Schedule for the function
-        secrets: Sequence[_Secret] = (),  # Optional Modal Secret objects with environment variables for the container
+        env: Optional[dict[str, Optional[str]]] = None,  # Environment variables to set in the container
+        secrets: Optional[Collection[_Secret]] = None,  # Secrets to inject into the container as environment variables
         gpu: Union[
             GPU_T, list[GPU_T]
         ] = None,  # GPU request as string ("any", "T4", ...), object (`modal.GPU.A100()`, ...), or a list of either
@@ -625,7 +711,8 @@ class _App:
         scaledown_window: Optional[int] = None,  # Max time (in seconds) a container can remain idle while scaling down.
         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.
-        timeout: Optional[int] = None,  # Maximum execution time of the function in seconds.
+        timeout: int = 300,  # Maximum execution time for inputs and startup time in seconds.
+        startup_timeout: Optional[int] = None,  # Maximum startup time in seconds with higher precedence than `timeout`.
         name: Optional[str] = None,  # Sets the Modal name of the function within the app
         is_generator: Optional[
             bool
@@ -639,8 +726,9 @@ class _App:
         # With `max_inputs = 1`, containers will be single-use.
         max_inputs: Optional[int] = None,
         i6pn: Optional[bool] = None,  # Whether to enable IPv6 container networking within the region.
-        # Whether the function's home package should be included in the image - defaults to True
-        include_source: Optional[bool] = None,  # When `False`, don't automatically add the App source to the container.
+        # Whether the file or directory containing the Function's source should automatically be included
+        # in the container. When unset, falls back to the App-level configuration, or is otherwise True by default.
+        include_source: Optional[bool] = None,
         experimental_options: Optional[dict[str, Any]] = None,
         # Parameters below here are experimental. Use with caution!
         _experimental_scheduler_placement: Optional[
@@ -648,16 +736,15 @@ class _App:
         ] = None,  # Experimental controls over fine-grained scheduling (alpha).
         _experimental_proxy_ip: Optional[str] = None,  # IP address of proxy
         _experimental_custom_scaling_factor: Optional[float] = None,  # Custom scaling factor
-        _experimental_enable_gpu_snapshot: bool = False,  # Experimentally enable GPU memory snapshots.
+        _experimental_restrict_output: bool = False,  # Don't use pickle for return values
         # Parameters below here are deprecated. Please update your code as suggested
         keep_warm: Optional[int] = None,  # Replaced with `min_containers`
         concurrency_limit: Optional[int] = None,  # Replaced with `max_containers`
         container_idle_timeout: Optional[int] = None,  # Replaced with `scaledown_window`
         allow_concurrent_inputs: Optional[int] = None,  # Replaced with the `@modal.concurrent` decorator
         _experimental_buffer_containers: Optional[int] = None,  # Now stable API with `buffer_containers`
-        allow_cross_region_volumes: Optional[bool] = None,  # Always True on the Modal backend now
     ) -> _FunctionDecoratorType:
-        """Decorator to register a new Modal [Function](/docs/reference/modal.Function) with this App."""
+        """Decorator to register a new Modal Function with this App."""
         if isinstance(_warn_parentheses_missing, _Image):
             # Handle edge case where maybe (?) some users passed image as a positional arg
             raise InvalidError("`image` needs to be a keyword argument: `@app.function(image=image)`.")
@@ -674,10 +761,12 @@ class _App:
                 " Please use the `@modal.concurrent` decorator instead."
                 "\n\nSee https://modal.com/docs/guide/modal-1-0-migration for more information.",
             )
-        if allow_cross_region_volumes is not None:
-            deprecation_warning((2025, 4, 23), "The `allow_cross_region_volumes` parameter no longer has any effect.")
 
-        secrets = [*self._secrets, *secrets]
+        secrets = secrets or []
+        if env:
+            secrets = [*secrets, _Secret.from_dict(env)]
+        local_state = self._local_state
+        secrets = [*local_state.secrets_default, *secrets]
 
         def wrapped(
             f: Union[_PartialFunction, Callable[..., Any], None],
@@ -720,6 +809,7 @@ class _App:
                 batch_max_size = f.params.batch_max_size
                 batch_wait_ms = f.params.batch_wait_ms
                 if f.flags & _PartialFunctionFlags.CONCURRENT:
+                    verify_concurrent_params(params=f.params, is_flash=is_flash_object(experimental_options))
                     max_concurrent_inputs = f.params.max_concurrent_inputs
                     target_concurrent_inputs = f.params.target_concurrent_inputs
                 else:
@@ -731,7 +821,7 @@ class _App:
                         dedent(
                             """
                             The `@app.function` decorator must apply to functions in global scope,
-                            unless `serialize=True` is set.
+                            unless `serialized=True` is set.
                             If trying to apply additional decorators, they may need to use `functools.wraps`.
                             """
                         )
@@ -785,7 +875,7 @@ class _App:
                 is_generator=is_generator,
                 gpu=gpu,
                 network_file_systems=network_file_systems,
-                volumes={**self._volumes, **volumes},
+                volumes={**local_state.volumes_default, **volumes},
                 cpu=cpu,
                 memory=memory,
                 ephemeral_disk=ephemeral_disk,
@@ -800,6 +890,7 @@ class _App:
                 batch_max_size=batch_max_size,
                 batch_wait_ms=batch_wait_ms,
                 timeout=timeout,
+                startup_timeout=startup_timeout or timeout,
                 cloud=cloud,
                 webhook_config=webhook_config,
                 enable_memory_snapshot=enable_memory_snapshot,
@@ -810,10 +901,10 @@ class _App:
                 i6pn_enabled=i6pn_enabled,
                 cluster_size=cluster_size,  # Experimental: Clustered functions
                 rdma=rdma,
-                include_source=include_source if include_source is not None else self._include_source_default,
+                include_source=include_source if include_source is not None else local_state.include_source_default,
                 experimental_options={k: str(v) for k, v in (experimental_options or {}).items()},
                 _experimental_proxy_ip=_experimental_proxy_ip,
-                _experimental_enable_gpu_snapshot=_experimental_enable_gpu_snapshot,
+                restrict_output=_experimental_restrict_output,
             )
 
             self._add_function(function, webhook_config is not None)
@@ -826,10 +917,11 @@ class _App:
     @warn_on_renamed_autoscaler_settings
     def cls(
         self,
-        _warn_parentheses_missing: Optional[bool] = None,
+        _warn_parentheses_missing=None,  # mdmd:line-hidden
         *,
         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
+        env: Optional[dict[str, Optional[str]]] = None,  # Environment variables to set in the container
+        secrets: Optional[Collection[_Secret]] = None,  # Secrets to inject into the container as environment variables
         gpu: Union[
             GPU_T, list[GPU_T]
         ] = None,  # GPU request as string ("any", "T4", ...), object (`modal.GPU.A100()`, ...), or a list of either
@@ -854,7 +946,8 @@ class _App:
         scaledown_window: Optional[int] = None,  # Max time (in seconds) a container can remain idle while scaling down.
         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.
-        timeout: Optional[int] = None,  # Maximum execution time of the function in seconds.
+        timeout: int = 300,  # Maximum execution time for inputs and startup time in seconds.
+        startup_timeout: Optional[int] = None,  # Maximum startup time in seconds with higher precedence than `timeout`.
         cloud: Optional[str] = None,  # Cloud provider to run the function on. Possible values are aws, gcp, oci, auto.
         region: Optional[Union[str, Sequence[str]]] = None,  # Region or regions to run the function on.
         enable_memory_snapshot: bool = False,  # Enable memory checkpointing for faster cold starts.
@@ -863,6 +956,7 @@ class _App:
         # Limits the number of inputs a container handles before shutting down.
         # Use `max_inputs = 1` for single-use containers.
         max_inputs: Optional[int] = None,
+        i6pn: Optional[bool] = None,  # Whether to enable IPv6 container networking within the region.
         include_source: Optional[bool] = None,  # When `False`, don't automatically add the App source to the container.
         experimental_options: Optional[dict[str, Any]] = None,
         # Parameters below here are experimental. Use with caution!
@@ -871,17 +965,16 @@ class _App:
         ] = None,  # Experimental controls over fine-grained scheduling (alpha).
         _experimental_proxy_ip: Optional[str] = None,  # IP address of proxy
         _experimental_custom_scaling_factor: Optional[float] = None,  # Custom scaling factor
-        _experimental_enable_gpu_snapshot: bool = False,  # Experimentally enable GPU memory snapshots.
+        _experimental_restrict_output: bool = False,  # Don't use pickle for return values
         # Parameters below here are deprecated. Please update your code as suggested
         keep_warm: Optional[int] = None,  # Replaced with `min_containers`
         concurrency_limit: Optional[int] = None,  # Replaced with `max_containers`
         container_idle_timeout: Optional[int] = None,  # Replaced with `scaledown_window`
         allow_concurrent_inputs: Optional[int] = None,  # Replaced with the `@modal.concurrent` decorator
         _experimental_buffer_containers: Optional[int] = None,  # Now stable API with `buffer_containers`
-        allow_cross_region_volumes: Optional[bool] = None,  # Always True on the Modal backend now
     ) -> Callable[[Union[CLS_T, _PartialFunction]], CLS_T]:
         """
-        Decorator to register a new Modal [Cls](/docs/reference/modal.Cls) with this App.
+        Decorator to register a new Modal [Cls](https://modal.com/docs/reference/modal.Cls) with this App.
         """
         if _warn_parentheses_missing:
             raise InvalidError("Did you forget parentheses? Suggestion: `@app.cls()`.")
@@ -899,27 +992,45 @@ class _App:
                 " Please use the `@modal.concurrent` decorator instead."
                 "\n\nSee https://modal.com/docs/guide/modal-1-0-migration for more information.",
             )
-        if allow_cross_region_volumes is not None:
-            deprecation_warning((2025, 4, 23), "The `allow_cross_region_volumes` parameter no longer has any effect.")
+
+        secrets = secrets or []
+        if env:
+            secrets = [*secrets, _Secret.from_dict(env)]
 
         def wrapper(wrapped_cls: Union[CLS_T, _PartialFunction]) -> CLS_T:
+            local_state = self._local_state
             # Check if the decorated object is a class
             if isinstance(wrapped_cls, _PartialFunction):
                 wrapped_cls.registered = True
                 user_cls = wrapped_cls.user_cls
                 if wrapped_cls.flags & _PartialFunctionFlags.CONCURRENT:
+                    verify_concurrent_params(params=wrapped_cls.params, is_flash=is_flash_object(experimental_options))
                     max_concurrent_inputs = wrapped_cls.params.max_concurrent_inputs
                     target_concurrent_inputs = wrapped_cls.params.target_concurrent_inputs
                 else:
                     max_concurrent_inputs = allow_concurrent_inputs
                     target_concurrent_inputs = None
+
+                if wrapped_cls.flags & _PartialFunctionFlags.CLUSTERED:
+                    cluster_size = wrapped_cls.params.cluster_size
+                    rdma = wrapped_cls.params.rdma
+                else:
+                    cluster_size = None
+                    rdma = None
             else:
                 user_cls = wrapped_cls
                 max_concurrent_inputs = allow_concurrent_inputs
                 target_concurrent_inputs = None
+                cluster_size = None
+                rdma = None
             if not inspect.isclass(user_cls):
                 raise TypeError("The @app.cls decorator must be used on a class.")
 
+            interface_methods = _find_partial_methods_for_user_cls(user_cls, _PartialFunctionFlags.interface_flags())
+            if cluster_size:
+                if len(interface_methods) > 1:
+                    raise InvalidError(f"Modal class {user_cls.__name__} cannot have multiple methods when clustered.")
+
             batch_functions = _find_partial_methods_for_user_cls(user_cls, _PartialFunctionFlags.BATCHED)
             if batch_functions:
                 if len(batch_functions) > 1:
@@ -949,14 +1060,16 @@ class _App:
 
             info = FunctionInfo(None, serialized=serialized, user_cls=user_cls)
 
+            i6pn_enabled = i6pn or cluster_size is not None
+
             cls_func = _Function.from_local(
                 info,
                 app=self,
                 image=image or self._get_default_image(),
-                secrets=[*self._secrets, *secrets],
+                secrets=[*local_state.secrets_default, *secrets],
                 gpu=gpu,
                 network_file_systems=network_file_systems,
-                volumes={**self._volumes, **volumes},
+                volumes={**local_state.volumes_default, **volumes},
                 cpu=cpu,
                 memory=memory,
                 ephemeral_disk=ephemeral_disk,
@@ -971,22 +1084,31 @@ class _App:
                 batch_max_size=batch_max_size,
                 batch_wait_ms=batch_wait_ms,
                 timeout=timeout,
+                startup_timeout=startup_timeout or timeout,
                 cloud=cloud,
                 enable_memory_snapshot=enable_memory_snapshot,
                 block_network=block_network,
                 restrict_modal_access=restrict_modal_access,
                 max_inputs=max_inputs,
                 scheduler_placement=scheduler_placement,
-                include_source=include_source if include_source is not None else self._include_source_default,
+                i6pn_enabled=i6pn_enabled,
+                cluster_size=cluster_size,
+                rdma=rdma,
+                include_source=include_source if include_source is not None else local_state.include_source_default,
                 experimental_options={k: str(v) for k, v in (experimental_options or {}).items()},
                 _experimental_proxy_ip=_experimental_proxy_ip,
                 _experimental_custom_scaling_factor=_experimental_custom_scaling_factor,
-                _experimental_enable_gpu_snapshot=_experimental_enable_gpu_snapshot,
+                restrict_output=_experimental_restrict_output,
             )
 
             self._add_function(cls_func, is_web_endpoint=False)
 
             cls: _Cls = _Cls.from_local(user_cls, self, cls_func)
+            for method_name, partial_function in cls._method_partials.items():
+                if partial_function.params.webhook_config is not None:
+                    full_name = f"{user_cls.__name__}.{method_name}"
+                    local_state.web_endpoints.append(full_name)
+                partial_function.registered = True
 
             tag: str = user_cls.__name__
             self._add_class(tag, cls)
@@ -994,7 +1116,7 @@ class _App:
 
         return wrapper
 
-    def include(self, /, other_app: "_App") -> typing_extensions.Self:
+    def include(self, /, other_app: "_App", inherit_tags: bool = True) -> typing_extensions.Self:
         """Include another App's objects in this one.
 
         Useful for splitting up Modal Apps across different self-contained files.
@@ -1017,12 +1139,19 @@ class _App:
             # use function declared on the included app
             bar.remote()
         ```
+
+        When `inherit_tags=True` any tags set on the other App will be inherited by this App
+        (with this App's tags taking precedence in the case of conflicts).
+
         """
-        for tag, function in other_app._functions.items():
+        other_app_local_state = other_app._local_state
+        this_local_state = self._local_state
+
+        for tag, function in other_app_local_state.functions.items():
             self._add_function(function, False)  # TODO(erikbern): webhook config?
 
-        for tag, cls in other_app._classes.items():
-            existing_cls = self._classes.get(tag)
+        for tag, cls in other_app_local_state.classes.items():
+            existing_cls = this_local_state.classes.get(tag)
             if existing_cls and existing_cls != cls:
                 logger.warning(
                     f"Named app class {tag} with existing value {existing_cls} is being "
@@ -1030,8 +1159,47 @@ class _App:
                 )
 
             self._add_class(tag, cls)
+
+        if inherit_tags:
+            this_local_state.tags = {**other_app_local_state.tags, **this_local_state.tags}
+
         return self
 
+    async def set_tags(self, tags: Mapping[str, str], *, client: Optional[_Client] = None) -> None:
+        """Attach key-value metadata to the App.
+
+        Tag metadata can be used to add organization-specific context to the App and can be
+        included in billing reports and other informational APIs. Tags can also be set in
+        the App constructor.
+
+        Any tags set on the App before calling this method will be removed if they are not
+        included in the argument (i.e., this method does not have `.update()` semantics).
+
+        """
+        # Note that we are requiring the App to be "running" before we set the tags.
+        # Alternatively, we could hold onto the tags (i.e. in `self._local_state.tags`) and then pass
+        # then up when AppPublish gets called. I'm not certain we want to support it, though.
+        # It might not be obvious to users that `.set_tags()` is eager and has immediate effect
+        # when the App is running, but lazy (and potentially ignored) otherwise. There would be
+        # other complications, like what do you do with any tags set in the constructor, and
+        # what should  `.get_tags()` do when it's called before the App is running?
+        if self._app_id is None:
+            raise InvalidError("`App.set_tags` cannot be called before the App is running.")
+        check_tag_dict(tags)
+        req = api_pb2.AppSetTagsRequest(app_id=self._app_id, tags=tags)
+
+        client = client or self._client or await _Client.from_env()
+        await client.stub.AppSetTags(req)
+
+    async def get_tags(self, *, client: Optional[_Client] = None) -> dict[str, str]:
+        """Get the tags that are currently attached to the App."""
+        if self._app_id is None:
+            raise InvalidError("`App.get_tags` cannot be called before the App is running.")
+        req = api_pb2.AppGetTagsRequest(app_id=self._app_id)
+        client = client or self._client or await _Client.from_env()
+        resp = await client.stub.AppGetTags(req)
+        return dict(resp.tags)
+
     async def _logs(self, client: Optional[_Client] = None) -> AsyncGenerator[str, None]:
         """Stream logs from the app.