modal 1.2.5.dev4__tar.gz → 1.2.5.dev10__tar.gz

{modal-1.2.5.dev4 → modal-1.2.5.dev10}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: modal
-Version: 1.2.5.dev4
+Version: 1.2.5.dev10
 Summary: Python client library for Modal
 Author-email: Modal Labs <support@modal.com>
 License: Apache-2.0

{modal-1.2.5.dev4 → modal-1.2.5.dev10}/modal/_functions.py

@@ -701,6 +701,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         _experimental_proxy_ip: Optional[str] = None,
         _experimental_custom_scaling_factor: Optional[float] = None,
         restrict_output: bool = False,
+        http_config: Optional[api_pb2.HTTPConfig] = None,
     ) -> "_Function":
         """mdmd:hidden
 
@@ -1046,6 +1047,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     function_schema=function_schema,
                     supported_input_formats=supported_input_formats,
                     supported_output_formats=supported_output_formats,
+                    http_config=http_config,
                 )
 
                 if isinstance(gpu, list):
@@ -1083,6 +1085,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         untrusted=function_definition.untrusted,
                         supported_input_formats=supported_input_formats,
                         supported_output_formats=supported_output_formats,
+                        http_config=http_config,
                     )
 
                     ranked_functions = []

{modal-1.2.5.dev4 → modal-1.2.5.dev10}/modal/_partial_function.py

@@ -46,6 +46,7 @@ class _PartialFunctionFlags(enum.IntFlag):
     BATCHED = 64
     CONCURRENT = 128
     CLUSTERED = 256  # Experimental: Clustered functions
+    HTTP_WEB_INTERFACE = 512  # Experimental: HTTP server
 
     @staticmethod
     def all() -> int:
@@ -76,6 +77,7 @@ class _PartialFunctionParams:
     target_concurrent_inputs: Optional[int] = None
     build_timeout: Optional[int] = None
     rdma: Optional[bool] = None
+    http_config: Optional[api_pb2.HTTPConfig] = None
 
     def update(self, other: "_PartialFunctionParams") -> None:
         """Update self with params set in other."""
@@ -158,8 +160,9 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
             raise InvalidError("Interface decorators cannot be combined with lifecycle decorators.")
 
         has_web_interface = self.flags & _PartialFunctionFlags.WEB_INTERFACE
+        has_http_web_interface = self.flags & _PartialFunctionFlags.HTTP_WEB_INTERFACE
         has_callable_interface = self.flags & _PartialFunctionFlags.CALLABLE_INTERFACE
-        if has_web_interface and has_callable_interface:
+        if (has_web_interface or has_http_web_interface) and has_callable_interface:
             self.registered = True  # Hacky, avoid false-positive warning
             raise InvalidError("Callable decorators cannot be combined with web interface decorators.")
 

{modal-1.2.5.dev4 → modal-1.2.5.dev10}/modal/_runtime/user_code_imports.py

@@ -64,12 +64,10 @@ def call_lifecycle_functions(
 
 
 @contextmanager
-def _run_service_lifecycle(
+def lifecycle_asgi(
     event_loop: UserCodeEventLoop,
     container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
-    function_def: api_pb2.Function,
     finalized_functions: dict[str, FinalizedFunction],
-    exit_callback: Optional[Callable[[], None]],
 ) -> Generator[None, None, None]:
     lifespan_background_tasks = []
     try:
@@ -82,38 +80,34 @@ def _run_service_lifecycle(
                     event_loop.run(finalized_function.lifespan_manager.lifespan_startup())
         yield
     finally:
-        # Run exit handlers. From this point onward, ignore all SIGINT signals that come from
-        # graceful shutdowns originating on the worker, as well as stray SIGUSR1 signals that
-        # may have been sent to cancel inputs.
-        int_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
-        usr1_handler = signal.signal(signal.SIGUSR1, signal.SIG_IGN)
         try:
-            try:
-                # run lifespan shutdown for asgi apps
-                for finalized_function in finalized_functions.values():
-                    if finalized_function.lifespan_manager:
-                        with container_io_manager.handle_user_exception():
-                            event_loop.run(finalized_function.lifespan_manager.lifespan_shutdown())
-            finally:
-                # no need to keep the lifespan asgi call around - we send it no more messages
-                for task in lifespan_background_tasks:
-                    task.cancel()
-
-                # Identify "exit" methods and run them.
-                # want to make sure this is called even if the lifespan manager fails
-                if exit_callback:
-                    exit_callback()
-
-            # Finally, commit on exit to catch uncommitted volume changes and surface background
-            # commit errors.
-            container_io_manager.volume_commit(
-                [v.volume_id for v in function_def.volume_mounts if v.allow_background_commits]
-            )
+            # run lifespan shutdown for asgi apps
+            for finalized_function in finalized_functions.values():
+                if finalized_function.lifespan_manager:
+                    with container_io_manager.handle_user_exception():
+                        event_loop.run(finalized_function.lifespan_manager.lifespan_shutdown())
         finally:
-            # Restore the original signal handler, needed for container_test hygiene since the
-            # test runs `main()` multiple times in the same process.
-            signal.signal(signal.SIGINT, int_handler)
-            signal.signal(signal.SIGUSR1, usr1_handler)
+            # no need to keep the lifespan asgi call around - we send it no more messages
+            for task in lifespan_background_tasks:
+                task.cancel()
+
+
+def disable_signals():
+    int_handler = signal.signal(signal.SIGINT, signal.SIG_IGN)
+    usr1_handler = signal.signal(signal.SIGUSR1, signal.SIG_IGN)
+    return int_handler, usr1_handler
+
+
+def try_enable_signals(int_handler, usr1_handler):
+    if int_handler is not None and usr1_handler is not None:
+        signal.signal(signal.SIGINT, int_handler)
+        signal.signal(signal.SIGUSR1, usr1_handler)
+
+
+def volume_commit(
+    container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager", function_def: api_pb2.Function
+):
+    container_io_manager.volume_commit([v.volume_id for v in function_def.volume_mounts if v.allow_background_commits])
 
 
 class Service(metaclass=ABCMeta):
@@ -127,14 +121,30 @@ class Service(metaclass=ABCMeta):
     user_cls_instance: Any
     app: "modal.app._App"
     service_deps: Optional[Sequence["modal._object._Object"]]
+    function_def: api_pb2.Function
 
     @abstractmethod
     def get_finalized_functions(
         self, fun_def: api_pb2.Function, container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager"
     ) -> dict[str, "FinalizedFunction"]: ...
 
+    @abstractmethod
     @contextmanager
+    def lifecycle_presnapshot(
+        self,
+        event_loop: UserCodeEventLoop,
+        container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
+    ) -> Generator[None, None, None]: ...
+
     @abstractmethod
+    @contextmanager
+    def lifecycle_postsnapshot(
+        self,
+        event_loop: UserCodeEventLoop,
+        container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
+    ) -> Generator[None, None, None]: ...
+
+    @contextmanager
     def execution_context(
         self,
         event_loop: UserCodeEventLoop,
@@ -150,6 +160,34 @@ class Service(metaclass=ABCMeta):
         6. Yield finalized_functions for execution
         7. Handles cleanup (lifespan shutdown, 'exit' methods)
         """
+        int_handler, usr1_handler = None, None
+        try:
+            # 1. Pre-snapshot Enter
+            with self.lifecycle_presnapshot(event_loop, container_io_manager):
+                # 2. Snapshot -- If this container is being used to create a checkpoint, checkpoint the container after
+                # global imports and initialization. Checkpointed containers run from this point onwards.
+                maybe_snapshot(container_io_manager, self.function_def)
+                # 3. Breakpoint wrapper
+                create_breakpoint_wrapper(container_io_manager)
+                # 4. Post-snapshot Enter
+                with self.lifecycle_postsnapshot(event_loop, container_io_manager):
+                    # Get Functions
+                    with container_io_manager.handle_user_exception():
+                        finalized_functions = self.get_finalized_functions(self.function_def, container_io_manager)
+                    # 5. Start ASGI lifespan
+                    with lifecycle_asgi(event_loop, container_io_manager, finalized_functions):
+                        # 6. Yield Finalized Functions
+                        try:
+                            yield finalized_functions
+                        finally:
+                            int_handler, usr1_handler = disable_signals()
+        finally:
+            # 9. Volume commit - runs OUTSIDE all lifecycle managers so exit handlers
+            # have a chance to write to disk before we commit volumes
+            try:
+                volume_commit(container_io_manager, self.function_def)
+            finally:
+                try_enable_signals(int_handler, usr1_handler)
 
 
 def construct_webhook_callable(
@@ -265,27 +303,22 @@ class ImportedFunction(Service):
         }
 
     @contextmanager
-    def execution_context(
+    def lifecycle_presnapshot(
         self,
         event_loop: UserCodeEventLoop,
         container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
-    ) -> Generator[dict[str, "FinalizedFunction"], None, None]:
-        # If this container is being used to create a checkpoint, checkpoint the container after
-        # global imports and initialization. Checkpointed containers run from this point onwards.
-        maybe_snapshot(container_io_manager, self.function_def)
-        create_breakpoint_wrapper(container_io_manager)
-
-        with container_io_manager.handle_user_exception():
-            finalized_functions = self.get_finalized_functions(self.function_def, container_io_manager)
+    ):
+        # This is a no-op for imported functions since @enter methods are not supported
+        yield
 
-        with _run_service_lifecycle(
-            event_loop,
-            container_io_manager,
-            self.function_def,
-            finalized_functions,
-            None,
-        ):
-            yield finalized_functions
+    @contextmanager
+    def lifecycle_postsnapshot(
+        self,
+        event_loop: UserCodeEventLoop,
+        container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
+    ):
+        # This is a no-op for imported functions since @enter methods are not supported
+        yield
 
 
 @dataclass
@@ -340,53 +373,38 @@ class ImportedClass(Service):
         return finalized_functions
 
     @contextmanager
-    def execution_context(
+    def lifecycle_presnapshot(
         self,
         event_loop: UserCodeEventLoop,
         container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
-    ) -> Generator[dict[str, "FinalizedFunction"], None, None]:
-        # 1. Pre-snapshot Enter
+    ):
         # Identify all "enter" methods that need to run before we snapshot.
         if not self.function_def.is_auto_snapshot:
             pre_snapshot_methods = _find_callables_for_obj(
                 self.user_cls_instance, _PartialFunctionFlags.ENTER_PRE_SNAPSHOT
             )
             call_lifecycle_functions(event_loop, container_io_manager, list(pre_snapshot_methods.values()))
+        yield
 
-        # 2. Snapshot
-        # If this container is being used to create a checkpoint, checkpoint the container after
-        # global imports and initialization. Checkpointed containers run from this point onwards.
-        maybe_snapshot(container_io_manager, self.function_def)
-
-        # 3. Breakpoint wrapper
-        create_breakpoint_wrapper(container_io_manager)
-
-        # 4. Post-snapshot Enter
+    @contextmanager
+    def lifecycle_postsnapshot(
+        self,
+        event_loop: UserCodeEventLoop,
+        container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
+    ):
         # Identify the "enter" methods to run after resuming from a snapshot.
         if not self.function_def.is_auto_snapshot:
             post_snapshot_methods = _find_callables_for_obj(
                 self.user_cls_instance, _PartialFunctionFlags.ENTER_POST_SNAPSHOT
             )
             call_lifecycle_functions(event_loop, container_io_manager, list(post_snapshot_methods.values()))
-
-        # 5. Get Functions & Start Lifespan
-        with container_io_manager.handle_user_exception():
-            finalized_functions = self.get_finalized_functions(self.function_def, container_io_manager)
-
-        def exit_callback():
+        try:
+            yield
+        finally:
             if not self.function_def.is_auto_snapshot:
                 exit_methods = _find_callables_for_obj(self.user_cls_instance, _PartialFunctionFlags.EXIT)
                 call_lifecycle_functions(event_loop, container_io_manager, list(exit_methods.values()))
 
-        with _run_service_lifecycle(
-            event_loop,
-            container_io_manager,
-            self.function_def,
-            finalized_functions,
-            exit_callback,
-        ):
-            yield finalized_functions
-
 
 def get_user_class_instance(_cls: modal.cls._Cls, args: tuple[Any, ...], kwargs: dict[str, Any]) -> typing.Any:
     """Returns instance of the underlying class to be used as the `self`

{modal-1.2.5.dev4 → modal-1.2.5.dev10}/modal/_utils/function_utils.py

@@ -75,8 +75,8 @@ def is_global_object(object_qual_name: str):
     return "<locals>" not in object_qual_name.split(".")
 
 
-def is_flash_object(experimental_options: Optional[dict[str, Any]]) -> bool:
-    return experimental_options.get("flash", False) if experimental_options else False
+def is_flash_object(experimental_options: Optional[dict[str, Any]], http_config: Optional[api_pb2.HTTPConfig]) -> bool:
+    return bool(experimental_options and experimental_options.get("flash", False)) or http_config is not None
 
 
 def is_method_fn(object_qual_name: str):

{modal-1.2.5.dev4 → modal-1.2.5.dev10}/modal/_utils/grpc_utils.py

@@ -1,6 +1,7 @@
 # Copyright Modal Labs 2022
 import asyncio
 import contextlib
+import os
 import platform
 import socket
 import time
@@ -396,7 +397,8 @@ async def _retry_transient_errors(
                 ):
                     last_server_retry_warning_time = now
                     logger.warning(
-                        f"Warning: Received {exc.status} status: {exc.message}. "
+                        f"Warning: Received {exc.status}{os.linesep}"
+                        f"{exc.message}{os.linesep}"
                         f"Will retry in {server_delay:0.2f} seconds."
                     )
 

{modal-1.2.5.dev4 → modal-1.2.5.dev10}/modal/_utils/task_command_router_client.py

@@ -5,7 +5,7 @@ import json
 import ssl
 import time
 import urllib.parse
-from typing import AsyncIterator, Optional
+from typing import AsyncGenerator, Optional
 
 import grpclib.client
 import grpclib.config
@@ -18,6 +18,7 @@ from modal.exception import ExecTimeoutError
 from modal_proto import api_pb2, task_command_router_pb2 as sr_pb2
 from modal_proto.task_command_router_grpc import TaskCommandRouterStub
 
+from .async_utils import aclosing
 from .grpc_utils import RETRYABLE_GRPC_STATUS_CODES, connect_channel
 
 
@@ -242,7 +243,7 @@ class TaskCommandRouterClient:
         # Quotes around the type required for protobuf 3.19.
         file_descriptor: "api_pb2.FileDescriptor.ValueType",
         deadline: Optional[float] = None,
-    ) -> AsyncIterator[sr_pb2.TaskExecStdioReadResponse]:
+    ) -> AsyncGenerator[sr_pb2.TaskExecStdioReadResponse, None]:
         """Stream stdout/stderr batches from the task, properly retrying on transient errors.
 
         Args:
@@ -253,7 +254,7 @@ class TaskCommandRouterClient:
               None, wait forever. If the deadline is exceeded, raises an
               ExecTimeoutError.
         Returns:
-            AsyncIterator[sr_pb2.TaskExecStdioReadResponse]: A stream of stdout/stderr batches.
+            AsyncGenerator[sr_pb2.TaskExecStdioReadResponse, None]: A stream of stdout/stderr batches.
         Raises:
             ExecTimeoutError: If the deadline is exceeded.
             Other errors: If retries are exhausted on transient errors or if there's an error
@@ -268,8 +269,9 @@ class TaskCommandRouterClient:
         else:
             raise ValueError(f"Invalid file descriptor: {file_descriptor}")
 
-        async for item in self._stream_stdio(task_id, exec_id, sr_fd, deadline):
-            yield item
+        async with aclosing(self._stream_stdio(task_id, exec_id, sr_fd, deadline)) as stream:
+            async for item in stream:
+                yield item
 
     async def exec_stdin_write(
         self, task_id: str, exec_id: str, offset: int, data: bytes, eof: bool
@@ -453,7 +455,7 @@ class TaskCommandRouterClient:
         # Quotes around the type required for protobuf 3.19.
         file_descriptor: "sr_pb2.TaskExecStdioFileDescriptor.ValueType",
         deadline: Optional[float] = None,
-    ) -> AsyncIterator[sr_pb2.TaskExecStdioReadResponse]:
+    ) -> AsyncGenerator[sr_pb2.TaskExecStdioReadResponse, None]:
         """Stream stdio from the task, properly updating the offset and retrying on transient errors.
         Raises ExecTimeoutError if the deadline is exceeded.
         """

{modal-1.2.5.dev4 → modal-1.2.5.dev10}/modal/app.py

@@ -827,7 +827,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))
+                    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:
@@ -1025,11 +1025,17 @@ class _App:
         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))
+                    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:
@@ -1039,6 +1045,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
@@ -1083,10 +1090,17 @@ 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."
+                )
+
             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,
@@ -1117,6 +1131,7 @@ class _App:
                 block_network=block_network,
                 restrict_modal_access=restrict_modal_access,
                 max_inputs=max_inputs,
+                http_config=http_config,
                 i6pn_enabled=i6pn_enabled,
                 cluster_size=cluster_size,
                 rdma=rdma,
@@ -1130,6 +1145,7 @@ class _App:
             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}"

{modal-1.2.5.dev4 → modal-1.2.5.dev10}/modal/client.pyi

@@ -32,7 +32,7 @@ class _Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.5.dev4",
+        version: str = "1.2.5.dev10",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.
@@ -163,7 +163,7 @@ class Client:
         server_url: str,
         client_type: int,
         credentials: typing.Optional[tuple[str, str]],
-        version: str = "1.2.5.dev4",
+        version: str = "1.2.5.dev10",
     ):
         """mdmd:hidden
         The Modal client object is not intended to be instantiated directly by users.

{modal-1.2.5.dev4 → modal-1.2.5.dev10}/modal/experimental/__init__.py

@@ -19,7 +19,12 @@ from ..cls import _Cls
 from ..exception import InvalidError
 from ..image import DockerfileSpec, ImageBuilderVersion, _Image, _ImageRegistryConfig
 from ..secret import _Secret
-from .flash import flash_forward, flash_get_containers, flash_prometheus_autoscaler  # noqa: F401
+from .flash import (  # noqa: F401
+    flash_forward,
+    flash_get_containers,
+    flash_prometheus_autoscaler,
+    http_server,
+)
 
 
 def stop_fetching_inputs():

{modal-1.2.5.dev4 → modal-1.2.5.dev10}/modal/experimental/flash.py

@@ -7,9 +7,10 @@ import sys
 import time
 import traceback
 from collections import defaultdict
-from typing import Any, Optional
+from typing import Any, Callable, Optional, Union
 from urllib.parse import urlparse
 
+from modal._partial_function import _PartialFunctionFlags
 from modal.cls import _Cls
 from modal.dict import _Dict
 from modal_proto import api_pb2
@@ -28,15 +29,17 @@ class _FlashManager:
         self,
         client: _Client,
         port: int,
-        process: Optional[subprocess.Popen] = None,
+        process: Optional[subprocess.Popen] = None,  # to be deprecated
         health_check_url: Optional[str] = None,
+        startup_timeout: int = 30,
         h2_enabled: bool = False,
     ):
         self.client = client
         self.port = port
+        self.process = process
         # Health check is not currently being used
         self.health_check_url = health_check_url
-        self.process = process
+        self.startup_timeout = startup_timeout
         self.tunnel_manager = _forward_tunnel(port, h2_enabled=h2_enabled, client=client)
         self.stopped = False
         self.num_failures = 0
@@ -49,10 +52,15 @@ class _FlashManager:
 
         start_time = time.monotonic()
 
+        def check_process_is_running() -> Optional[Exception]:
+            if process is not None and process.poll() is not None:
+                return Exception(f"Process {process.pid} exited with code {process.returncode}")
+            return None
+
         while time.monotonic() - start_time < timeout:
             try:
-                if process is not None and process.poll() is not None:
-                    return False, Exception(f"Process {process.pid} exited with code {process.returncode}")
+                if error := check_process_is_running():
+                    return False, error
                 with socket.create_connection(("localhost", self.port), timeout=0.5):
                     return True, None
             except (ConnectionRefusedError, OSError):
@@ -101,6 +109,7 @@ class _FlashManager:
 
     async def _run_heartbeat(self, host: str, port: int):
         first_registration = True
+        start_time = time.monotonic()
         while True:
             try:
                 port_check_resp, port_check_error = await self.is_port_connection_healthy(process=self.process)
@@ -122,12 +131,15 @@ class _FlashManager:
                         )
                         first_registration = False
                 else:
-                    logger.error(
-                        f"[Modal Flash] Deregistering container {self.task_id} on {self.tunnel.url} "
-                        f"due to error: {port_check_error}, num_failures: {self.num_failures}"
-                    )
-                    self.num_failures += 1
-                    await self.client.stub.FlashContainerDeregister(api_pb2.FlashContainerDeregisterRequest())
+                    if first_registration and (time.monotonic() - start_time < self.startup_timeout):
+                        continue
+                    else:
+                        logger.error(
+                            f"[Modal Flash] Deregistering container {self.task_id} on {self.tunnel.url} "
+                            f"due to error: {port_check_error}, num_failures: {self.num_failures}"
+                        )
+                        self.num_failures += 1
+                        await self.client.stub.FlashContainerDeregister(api_pb2.FlashContainerDeregisterRequest())
 
             except asyncio.CancelledError:
                 logger.warning("[Modal Flash] Shutting down...")
@@ -171,6 +183,7 @@ async def flash_forward(
     port: int,
     process: Optional[subprocess.Popen] = None,
     health_check_url: Optional[str] = None,
+    startup_timeout: int = 30,
     h2_enabled: bool = False,
 ) -> _FlashManager:
     """
@@ -180,7 +193,14 @@ async def flash_forward(
     """
     client = await _Client.from_env()
 
-    manager = _FlashManager(client, port, process=process, health_check_url=health_check_url, h2_enabled=h2_enabled)
+    manager = _FlashManager(
+        client,
+        port,
+        process=process,
+        health_check_url=health_check_url,
+        startup_timeout=startup_timeout,
+        h2_enabled=h2_enabled,
+    )
     await manager._start()
     return manager
 
@@ -618,3 +638,57 @@ async def flash_get_containers(app_name: str, cls_name: str) -> list[dict[str, A
     req = api_pb2.FlashContainerListRequest(function_id=fn.object_id)
     resp = await client.stub.FlashContainerList(req)
     return resp.containers
+
+
+def _http_server(
+    port: Optional[int] = None,
+    *,
+    proxy_regions: list[str] = [],  # The regions to proxy the HTTP server to.
+    startup_timeout: int = 30,  # Maximum number of seconds to wait for the HTTP server to start.
+    exit_grace_period: Optional[int] = None,  # The time to wait for the HTTP server to exit gracefully.
+):
+    """Decorator for Flash-enabled HTTP servers on Modal classes.
+
+    Args:
+        port: The local port to forward to the HTTP server.
+        proxy_regions: The regions to proxy the HTTP server to.
+        startup_timeout: The maximum time to wait for the HTTP server to start.
+        exit_grace_period: The time to wait for the HTTP server to exit gracefully.
+
+    """
+    if port is None:
+        raise InvalidError(
+            "Positional arguments are not allowed. Did you forget parentheses? Suggestion: `@modal.http_server()`."
+        )
+    if not isinstance(port, int) or port < 1 or port > 65535:
+        raise InvalidError("First argument of `@http_server` must be a local port, such as `@http_server(8000)`.")
+    if startup_timeout <= 0:
+        raise InvalidError("The `startup_timeout` argument of `@http_server` must be positive.")
+    if exit_grace_period is not None and exit_grace_period < 0:
+        raise InvalidError("The `exit_grace_period` argument of `@http_server` must be non-negative.")
+
+    from modal._partial_function import _PartialFunction, _PartialFunctionParams
+
+    params = _PartialFunctionParams(
+        http_config=api_pb2.HTTPConfig(
+            port=port,
+            proxy_regions=proxy_regions,
+            startup_timeout=startup_timeout or 0,
+            exit_grace_period=exit_grace_period or 0,
+        )
+    )
+
+    def wrapper(obj: Union[Callable[..., Any], _PartialFunction]) -> _PartialFunction:
+        flags = _PartialFunctionFlags.HTTP_WEB_INTERFACE
+
+        if isinstance(obj, _PartialFunction):
+            pf = obj.stack(flags, params)
+        else:
+            pf = _PartialFunction(obj, flags, params)
+        pf.validate_obj_compatibility("`http_server`")
+        return pf
+
+    return wrapper
+
+
+http_server = synchronize_api(_http_server, target_module=__name__)