modal 1.1.5.dev83__py3-none-any.whl → 1.3.1.dev8__py3-none-any.whl

modal/app.py

@@ -2,6 +2,7 @@
 import inspect
 import typing
 from collections.abc import AsyncGenerator, Collection, Coroutine, Mapping, Sequence
+from dataclasses import dataclass
 from pathlib import PurePosixPath
 from textwrap import dedent
 from typing import (
@@ -20,20 +21,21 @@ from synchronicity.async_wrap import asynccontextmanager
 from modal_proto import api_pb2
 
 from ._functions import _Function
-from ._ipython import is_notebook
+from ._ipython import is_interactive_ipython
+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, check_tag_dict
 from .client import _Client
@@ -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,23 +169,25 @@ class _App:
 
     _name: Optional[str]
     _description: Optional[str]
-    _tags: dict[str, 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,
@@ -196,8 +216,6 @@ class _App:
 
         self._name = name
         self._description = name
-        self._tags = tags or {}
-        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)
@@ -205,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)
@@ -281,11 +308,13 @@ 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
 
@@ -310,18 +339,19 @@ class _App:
         App that is retrieved via `modal.App.lookup`. It is likely to be deprecated in the future.
 
         """
-        return self._image
+        return self._local_state.image_default
 
     @image.setter
     def image(self, value):
         """mdmd:hidden"""
-        self._image = value
+        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
@@ -457,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
 
@@ -473,18 +504,22 @@ 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
 
-            if not is_notebook():
+            # In a notebook or interactive REPL it would be relatively normal to rerun a cell that
+            # registers a function multiple times (i.e. as you iterate on the Function definition),
+            # and we don't want to warn about a collision in that case.
+            if not is_interactive_ipython():
                 logger.warning(
                     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}"
                 )
-        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:
@@ -495,9 +530,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:
@@ -508,7 +543,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
@@ -516,18 +551,18 @@ 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)
 
@@ -541,7 +576,7 @@ class _App:
         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._functions
+        return self._local_state.functions
 
     @property
     def registered_classes(self) -> dict[str, _Cls]:
@@ -553,7 +588,7 @@ class _App:
         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._classes
+        return self._local_state.classes
 
     @property
     def registered_entrypoints(self) -> dict[str, _LocalEntrypoint]:
@@ -564,7 +599,7 @@ class _App:
         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_entrypoints
+        return self._local_state.local_entrypoints
 
     @property
     def registered_web_endpoints(self) -> list[str]:
@@ -576,7 +611,7 @@ class _App:
         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._web_endpoints
+        return self._local_state.web_endpoints
 
     def local_entrypoint(
         self, _warn_parentheses_missing: Any = None, *, name: Optional[str] = None
@@ -637,10 +672,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
@@ -654,9 +690,7 @@ class _App:
         schedule: Optional[Schedule] = None,  # An optional Modal Schedule for the function
         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
+        gpu: Union[GPU_T, list[GPU_T]] = None,  # GPU request; either a single GPU type or a list of types
         serialized: bool = False,  # Whether to send the function over using cloudpickle.
         network_file_systems: dict[
             Union[str, PurePosixPath], _NetworkFileSystem
@@ -686,21 +720,17 @@ class _App:
         ] = None,  # Set this to True if it's a non-generator function returning a [sync/async] generator object
         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.
+        nonpreemptible: bool = False,  # Whether to run the function on a nonpreemptible instance.
         enable_memory_snapshot: bool = False,  # Enable memory checkpointing for faster cold starts.
         block_network: bool = False,  # Whether to block network access
         restrict_modal_access: bool = False,  # Whether to allow this function access to other Modal resources
-        # Maximum number of inputs a container should handle before shutting down.
-        # With `max_inputs = 1`, containers will be single-use.
-        max_inputs: Optional[int] = None,
+        single_use_containers: bool = False,  # When True, containers will shut down after handling a single input
         i6pn: Optional[bool] = None,  # Whether to enable IPv6 container networking within the region.
         # 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[
-            SchedulerPlacement
-        ] = 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_restrict_output: bool = False,  # Don't use pickle for return values
@@ -709,7 +739,10 @@ class _App:
         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
+        max_inputs: Optional[int] = None,  # Replaced with `single_use_containers`
         _experimental_buffer_containers: Optional[int] = None,  # Now stable API with `buffer_containers`
+        _experimental_scheduler_placement: Optional[SchedulerPlacement] = None,  # Replaced in favor of
+        # using `region` and `nonpreemptible`
     ) -> _FunctionDecoratorType:
         """Decorator to register a new Modal Function with this App."""
         if isinstance(_warn_parentheses_missing, _Image):
@@ -729,15 +762,48 @@ class _App:
                 "\n\nSee https://modal.com/docs/guide/modal-1-0-migration for more information.",
             )
 
+        if max_inputs is not None:
+            if not isinstance(max_inputs, int):
+                raise InvalidError(f"`max_inputs` must be an int, not {type(max_inputs).__name__}")
+            if max_inputs <= 0:
+                raise InvalidError("`max_inputs` must be positive")
+            if max_inputs > 1:
+                raise InvalidError("Only `max_inputs=1` is currently supported")
+            deprecation_warning(
+                (2025, 12, 16),
+                "The `max_inputs` parameter is deprecated. Please set `single_use_containers=True` instead.",
+                pending=True,
+            )
+            single_use_containers = max_inputs == 1
+
+        if _experimental_scheduler_placement is not None:
+            deprecation_warning(
+                (2025, 11, 17),
+                "The `_experimental_scheduler_placement` parameter is deprecated."
+                " Please use the `region` and `nonpreemptible` parameters instead.",
+            )
+            if region is not None or nonpreemptible:
+                raise InvalidError(
+                    "Cannot use `_experimental_scheduler_placement` together with "
+                    "`region` or `nonpreemptible` parameters."
+                )
+            # Extract regions and lifecycle from scheduler placement
+            if _experimental_scheduler_placement.proto.regions:
+                region = list(_experimental_scheduler_placement.proto.regions)
+            if _experimental_scheduler_placement.proto._lifecycle:
+                # Convert lifecycle to nonpreemptible: "on-demand" -> True, "spot" -> False
+                nonpreemptible = _experimental_scheduler_placement.proto._lifecycle == "on-demand"
+
         secrets = secrets or []
         if env:
             secrets = [*secrets, _Secret.from_dict(env)]
-        secrets = [*self._secrets, *secrets]
+        local_state = self._local_state
+        secrets = [*local_state.secrets_default, *secrets]
 
         def wrapped(
             f: Union[_PartialFunction, Callable[..., Any], None],
         ) -> _Function:
-            nonlocal is_generator, cloud, serialized
+            nonlocal is_generator, cloud, serialized, region, nonpreemptible
 
             # Check if the decorated object is a class
             if inspect.isclass(f):
@@ -775,6 +841,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, None))
                     max_concurrent_inputs = f.params.max_concurrent_inputs
                     target_concurrent_inputs = f.params.target_concurrent_inputs
                 else:
@@ -825,12 +892,6 @@ class _App:
             if is_generator is None:
                 is_generator = inspect.isgeneratorfunction(raw_f) or inspect.isasyncgenfunction(raw_f)
 
-            scheduler_placement: Optional[SchedulerPlacement] = _experimental_scheduler_placement
-            if region:
-                if scheduler_placement:
-                    raise InvalidError("`region` and `_experimental_scheduler_placement` cannot be used together")
-                scheduler_placement = SchedulerPlacement(region=region)
-
             function = _Function.from_local(
                 info,
                 app=self,
@@ -840,7 +901,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,
@@ -857,16 +918,17 @@ class _App:
                 timeout=timeout,
                 startup_timeout=startup_timeout or timeout,
                 cloud=cloud,
+                region=region,
+                nonpreemptible=nonpreemptible,
                 webhook_config=webhook_config,
                 enable_memory_snapshot=enable_memory_snapshot,
                 block_network=block_network,
                 restrict_modal_access=restrict_modal_access,
-                max_inputs=max_inputs,
-                scheduler_placement=scheduler_placement,
+                single_use_containers=single_use_containers,
                 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,
                 restrict_output=_experimental_restrict_output,
@@ -887,9 +949,7 @@ class _App:
         image: Optional[_Image] = None,  # The image to run as the container for the function
         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
+        gpu: Union[GPU_T, list[GPU_T]] = None,  # GPU request; either a single GPU type or a list of types
         serialized: bool = False,  # Whether to send the function over using cloudpickle.
         network_file_systems: dict[
             Union[str, PurePosixPath], _NetworkFileSystem
@@ -915,19 +975,15 @@ class _App:
         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.
+        nonpreemptible: bool = False,  # Whether to run the function on a non-preemptible instance.
         enable_memory_snapshot: bool = False,  # Enable memory checkpointing for faster cold starts.
         block_network: bool = False,  # Whether to block network access
         restrict_modal_access: bool = False,  # Whether to allow this class access to other Modal resources
-        # Limits the number of inputs a container handles before shutting down.
-        # Use `max_inputs = 1` for single-use containers.
-        max_inputs: Optional[int] = None,
+        single_use_containers: bool = False,  # When True, containers will shut down after handling a single input
         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!
-        _experimental_scheduler_placement: Optional[
-            SchedulerPlacement
-        ] = 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_restrict_output: bool = False,  # Don't use pickle for return values
@@ -936,7 +992,10 @@ class _App:
         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
+        max_inputs: Optional[int] = None,  # Replaced with `single_use_containers`
         _experimental_buffer_containers: Optional[int] = None,  # Now stable API with `buffer_containers`
+        _experimental_scheduler_placement: Optional[SchedulerPlacement] = None,  # Replaced in favor of
+        # using `region` and `nonpreemptible`
     ) -> Callable[[Union[CLS_T, _PartialFunction]], CLS_T]:
         """
         Decorator to register a new Modal [Cls](https://modal.com/docs/reference/modal.Cls) with this App.
@@ -944,12 +1003,6 @@ class _App:
         if _warn_parentheses_missing:
             raise InvalidError("Did you forget parentheses? Suggestion: `@app.cls()`.")
 
-        scheduler_placement = _experimental_scheduler_placement
-        if region:
-            if scheduler_placement:
-                raise InvalidError("`region` and `_experimental_scheduler_placement` cannot be used together")
-            scheduler_placement = SchedulerPlacement(region=region)
-
         if allow_concurrent_inputs is not None:
             deprecation_warning(
                 (2025, 4, 9),
@@ -958,16 +1011,56 @@ class _App:
                 "\n\nSee https://modal.com/docs/guide/modal-1-0-migration for more information.",
             )
 
+        if max_inputs is not None:
+            if not isinstance(max_inputs, int):
+                raise InvalidError(f"`max_inputs` must be an int, not {type(max_inputs).__name__}")
+            if max_inputs <= 0:
+                raise InvalidError("`max_inputs` must be positive")
+            if max_inputs > 1:
+                raise InvalidError("Only `max_inputs=1` is currently supported")
+            deprecation_warning(
+                (2025, 12, 16),
+                "The `max_inputs` parameter is deprecated. Please set `single_use_containers=True` instead.",
+                pending=True,
+            )
+            single_use_containers = max_inputs == 1
+
+        if _experimental_scheduler_placement is not None:
+            deprecation_warning(
+                (2025, 11, 17),
+                "The `_experimental_scheduler_placement` parameter is deprecated."
+                " Please use the `region` and `nonpreemptible` parameters instead.",
+            )
+            if region is not None or nonpreemptible:
+                raise InvalidError(
+                    "Cannot use `_experimental_scheduler_placement` together with "
+                    "`region` or `nonpreemptible` parameters."
+                )
+            # Extract regions and lifecycle from scheduler placement
+            if _experimental_scheduler_placement.proto.regions:
+                region = list(_experimental_scheduler_placement.proto.regions)
+            if _experimental_scheduler_placement.proto._lifecycle:
+                # Convert lifecycle to nonpreemptible: "on-demand" -> True, "spot" -> False
+                nonpreemptible = _experimental_scheduler_placement.proto._lifecycle == "on-demand"
+
         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
+            http_config = None
             if isinstance(wrapped_cls, _PartialFunction):
                 wrapped_cls.registered = True
                 user_cls = wrapped_cls.user_cls
+                if wrapped_cls.flags & _PartialFunctionFlags.HTTP_WEB_INTERFACE:
+                    http_config = wrapped_cls.params.http_config
                 if wrapped_cls.flags & _PartialFunctionFlags.CONCURRENT:
+                    verify_concurrent_params(
+                        params=wrapped_cls.params,
+                        is_flash=is_flash_object(experimental_options or {}, http_config=http_config),
+                    )
                     max_concurrent_inputs = wrapped_cls.params.max_concurrent_inputs
                     target_concurrent_inputs = wrapped_cls.params.target_concurrent_inputs
                 else:
@@ -977,6 +1070,7 @@ class _App:
                 if wrapped_cls.flags & _PartialFunctionFlags.CLUSTERED:
                     cluster_size = wrapped_cls.params.cluster_size
                     rdma = wrapped_cls.params.rdma
+
                 else:
                     cluster_size = None
                     rdma = None
@@ -1021,18 +1115,32 @@ class _App:
                     "The `@modal.concurrent` decorator cannot be used on methods; decorate the class instead."
                 )
 
+            for method in _find_partial_methods_for_user_cls(
+                user_cls, _PartialFunctionFlags.HTTP_WEB_INTERFACE
+            ).values():
+                method.registered = True  # Avoid warning about not registering the method (hacky!)
+                raise InvalidError(
+                    "The `@modal.http_server` decorator cannot be used on methods; decorate the class instead."
+                )
+
+            if http_config is not None:
+                for method in _find_partial_methods_for_user_cls(
+                    user_cls, _PartialFunctionFlags.CALLABLE_INTERFACE
+                ).values():
+                    method.registered = True  # Avoid warning about not registering the method (hacky!)
+                    raise InvalidError("Callable decorators cannot be combined with web interface decorators.")
+
             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,
@@ -1049,15 +1157,17 @@ class _App:
                 timeout=timeout,
                 startup_timeout=startup_timeout or timeout,
                 cloud=cloud,
+                region=region,
+                nonpreemptible=nonpreemptible,
                 enable_memory_snapshot=enable_memory_snapshot,
                 block_network=block_network,
                 restrict_modal_access=restrict_modal_access,
-                max_inputs=max_inputs,
-                scheduler_placement=scheduler_placement,
+                single_use_containers=single_use_containers,
+                http_config=http_config,
                 i6pn_enabled=i6pn_enabled,
                 cluster_size=cluster_size,
                 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_custom_scaling_factor=_experimental_custom_scaling_factor,
@@ -1068,6 +1178,12 @@ class _App:
 
             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)
             return cls  # type: ignore  # a _Cls instance "simulates" being the user provided class
@@ -1102,11 +1218,14 @@ class _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 "
@@ -1116,7 +1235,7 @@ class _App:
             self._add_class(tag, cls)
 
         if inherit_tags:
-            self._tags = {**other_app._tags, **self._tags}
+            this_local_state.tags = {**other_app_local_state.tags, **this_local_state.tags}
 
         return self
 
@@ -1132,7 +1251,7 @@ class _App:
 
         """
         # 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._tags`) and then pass
+        # 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
@@ -1144,7 +1263,7 @@ class _App:
         req = api_pb2.AppSetTagsRequest(app_id=self._app_id, tags=tags)
 
         client = client or self._client or await _Client.from_env()
-        await retry_transient_errors(client.stub.AppSetTags, req)
+        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."""
@@ -1152,7 +1271,7 @@ class _App:
             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 retry_transient_errors(client.stub.AppGetTags, req)
+        resp = await client.stub.AppGetTags(req)
         return dict(resp.tags)
 
     async def _logs(self, client: Optional[_Client] = None) -> AsyncGenerator[str, None]: