modAL 1.3.1.dev32__tar.gz → 1.3.1.dev34__tar.gz

{modal-1.3.1.dev32 → modal-1.3.1.dev34}/PKG-INFO

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

{modal-1.3.1.dev32 → modal-1.3.1.dev34}/modal/__init__.py

@@ -41,6 +41,7 @@ try:
     from .schedule import Cron, Period
     from .scheduler_placement import SchedulerPlacement
     from .secret import Secret
+    from .server import Server
     from .snapshot import SandboxSnapshot
     from .volume import Volume
 except Exception:
@@ -75,6 +76,7 @@ __all__ = [
     "SandboxSnapshot",
     "SchedulerPlacement",
     "Secret",
+    "Server",
     "Tunnel",
     "Volume",
     "asgi_app",

{modal-1.3.1.dev32 → modal-1.3.1.dev34}/modal/_container_entrypoint.py

@@ -5,6 +5,7 @@ import os
 from modal._runtime.user_code_imports import (
     Service,
     import_class_service,
+    import_server_service,
     import_single_function_service,
 )
 
@@ -300,7 +301,18 @@ def main(container_args: api_pb2.ContainerArguments, client: Client):
                 param_kwargs = {}
 
             with execution_context._import_context():
-                if function_def.is_class:
+                if function_def.is_server:
+                    service_base_function_id = container_args.app_layout.function_ids[function_def.function_name]
+                    service_function_hydration_data = [
+                        o for o in container_args.app_layout.objects if o.object_id == service_base_function_id
+                    ][0]
+                    service = import_server_service(
+                        function_def,
+                        service_function_hydration_data,
+                        client,
+                        ser_usr_cls,
+                    )
+                elif function_def.is_class:
                     # this is a bit ugly - match the function and class based on function name to get metadata
                     # This metadata is required in order to hydrate the class in case it's not globally
                     # decorated (or serialized)

{modal-1.3.1.dev32 → modal-1.3.1.dev34}/modal/_functions.py

@@ -689,6 +689,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         nonpreemptible: bool = False,
         is_builder_function: bool = False,
         is_auto_snapshot: bool = False,
+        is_server: bool = False,
         enable_memory_snapshot: bool = False,
         block_network: bool = False,
         restrict_modal_access: bool = False,
@@ -722,7 +723,6 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     f"Function {raw_f} has a schedule, so it needs to support being called with no arguments"
                 )
         else:
-            # must be a "class service function"
             assert info.user_cls
             assert not webhook_config
             assert not schedule
@@ -734,7 +734,8 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
         ]
 
         retry_policy = _parse_retries(
-            retries, f"Function '{info.get_tag()}'" if info.raw_f else f"Class '{info.get_tag()}'"
+            retries,
+            f"Function '{info.get_tag()}'" if info.raw_f else f"Class '{info.get_tag()}'",
         )
 
         if retry_policy is not None:
@@ -1054,6 +1055,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                     supported_input_formats=supported_input_formats,
                     supported_output_formats=supported_output_formats,
                     http_config=http_config,
+                    is_server=is_server,
                 )
 
                 if isinstance(gpu, list):
@@ -1093,6 +1095,7 @@ class _Function(typing.Generic[P, ReturnType, OriginalReturnType], _Object, type
                         supported_input_formats=supported_input_formats,
                         supported_output_formats=supported_output_formats,
                         http_config=http_config,
+                        is_server=function_definition.is_server,
                     )
 
                     ranked_functions = []

{modal-1.3.1.dev32 → modal-1.3.1.dev34}/modal/_object.py

@@ -127,9 +127,11 @@ class _Object:
         assert isinstance(object_id, str) and self._type_prefix is not None
         if not object_id.startswith(self._type_prefix):
             raise ExecutionError(
-                f"Can not hydrate {type(self)}:"
+                f"Can not hydrate {type(self)}: "
                 f" it has type prefix {self._type_prefix}"
-                f" but the object_id starts with {object_id[:3]}"
+                f" but the object_id starts with {object_id[:3]}. "
+                "This usually means the object name was previously used for a different type. "
+                "Rename the object/app or stop the previous deployment and redeploy."
             )
         self._object_id = object_id
         self._client = client
@@ -137,7 +139,7 @@ class _Object:
         self._is_hydrated = True
 
     def _hydrate_metadata(self, metadata: Optional[Message]):
-        # override this is subclasses that need additional data (other than an object_id) for a functioning Handle
+        # override this if it's a subclass that needs additional data (other than an object_id) for a functioning Handle
         pass
 
     def _get_metadata(self) -> Optional[Message]:

{modal-1.3.1.dev32 → modal-1.3.1.dev34}/modal/_resolver.py

@@ -34,7 +34,7 @@ class StatusRow:
 
     def warning(self, warning: api_pb2.Warning):
         if self._step_node is not None:
-            self._step_node.add(f"[yellow]:warning:[/yellow] {warning.message}")
+            self._step_node.add(f"⚠️ {warning.message}")
 
     def finish(self, message):
         if self._step_node is not None and self._spinner is not None:

{modal-1.3.1.dev32 → modal-1.3.1.dev34}/modal/_runtime/user_code_imports.py

@@ -13,6 +13,7 @@ from typing import Any, Callable, Generator, Optional, Sequence
 import modal._object
 import modal._runtime.container_io_manager
 import modal.cls
+import modal.server
 from modal import Function
 from modal._functions import _Function
 from modal._partial_function import (
@@ -129,21 +130,23 @@ class Service(metaclass=ABCMeta):
         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]: ...
+    ) -> Generator[None, None, None]:
+        # Default no-op implementation for services without pre-snapshot lifecycle handling
+        yield
 
-    @abstractmethod
     @contextmanager
     def lifecycle_postsnapshot(
         self,
         event_loop: UserCodeEventLoop,
         container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
-    ) -> Generator[None, None, None]: ...
+    ) -> Generator[None, None, None]:
+        # Default no-op implementation for services without post-snapshot lifecycle handling
+        yield
 
     @contextmanager
     def execution_context(
@@ -303,13 +306,28 @@ class ImportedFunction(Service):
             )
         }
 
+
+class _LifecycleManager:
+    """Lifecycle manager for class-based services (Cls and Server).
+
+    Handles pre snapshot, post snapshot, and exit lifecycle handling
+    """
+
+    user_cls_instance: Any
+    function_def: api_pb2.Function
+
     @contextmanager
     def lifecycle_presnapshot(
         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
+        # 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
 
     @contextmanager
@@ -318,12 +336,26 @@ class ImportedFunction(Service):
         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
+        # Identify the "enter" methods to run after resuming from a snapshot.
+        flash_entry = _FlashContainerEntry(self.function_def.http_config)
+        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()))
+            flash_entry.enter()
+        try:
+            yield
+        finally:
+            if not self.function_def.is_auto_snapshot:
+                flash_entry.stop()
+                exit_methods = _find_callables_for_obj(self.user_cls_instance, _PartialFunctionFlags.EXIT)
+                call_lifecycle_functions(event_loop, container_io_manager, list(exit_methods.values()))
+                flash_entry.close()
 
 
 @dataclass
-class ImportedClass(Service):
+class ImportedClass(_LifecycleManager, Service):
     user_cls_instance: Any
     app: "modal.app._App"
     service_deps: Optional[Sequence["modal._object._Object"]]
@@ -373,42 +405,18 @@ class ImportedClass(Service):
             finalized_functions[method_name] = finalized_function
         return finalized_functions
 
-    @contextmanager
-    def lifecycle_presnapshot(
-        self,
-        event_loop: UserCodeEventLoop,
-        container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
-    ):
-        # 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
 
-    @contextmanager
-    def lifecycle_postsnapshot(
-        self,
-        event_loop: UserCodeEventLoop,
-        container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager",
-    ):
-        flash_entry = _FlashContainerEntry(self.function_def.http_config)
-        # 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()))
-            flash_entry.enter()
-        try:
-            yield
-        finally:
-            if not self.function_def.is_auto_snapshot:
-                flash_entry.stop()
-                exit_methods = _find_callables_for_obj(self.user_cls_instance, _PartialFunctionFlags.EXIT)
-                call_lifecycle_functions(event_loop, container_io_manager, list(exit_methods.values()))
-                flash_entry.close()
+@dataclass
+class ImportedServer(_LifecycleManager, Service):
+    user_cls_instance: Any
+    app: "modal.app._App"
+    service_deps: Optional[Sequence["modal._object._Object"]]
+    function_def: api_pb2.Function
+
+    def get_finalized_functions(
+        self, fun_def: api_pb2.Function, container_io_manager: "modal._runtime.container_io_manager.ContainerIOManager"
+    ) -> dict[str, "FinalizedFunction"]:
+        return {}
 
 
 def get_user_class_instance(_cls: modal.cls._Cls, args: tuple[Any, ...], kwargs: dict[str, Any]) -> typing.Any:
@@ -497,29 +505,15 @@ def import_single_function_service(
     )
 
 
-def import_class_service(
+def _get_cls_or_user_cls(
     function_def: api_pb2.Function,
-    service_function_hydration_data: api_pb2.Object,
-    class_id: str,
-    client: "modal.client.Client",
     ser_user_cls: Optional[type],
-    cls_args,
-    cls_kwargs,
-) -> Service:
-    """
-    This imports a full class to be able to execute any @method or webhook decorated methods.
-
-    See import_function.
-    """
-    active_app: Optional["modal.app._App"]
-    service_deps: Optional[Sequence["modal._object._Object"]]
-    cls_or_user_cls: typing.Union[type, modal.cls.Cls]
-
+) -> typing.Union[type, modal.cls.Cls, modal.server.Server]:
     if function_def.definition_type == api_pb2.Function.DEFINITION_TYPE_SERIALIZED:
         assert ser_user_cls is not None
         cls_or_user_cls = ser_user_cls
     else:
-        # Load the module dynamically
+        # Load the module dynamically for non-serialized class.
         module = importlib.import_module(function_def.module_name)
         qual_name: str = function_def.function_name
 
@@ -527,9 +521,8 @@ def import_class_service(
             raise LocalFunctionError("Attempted to load a class defined in a function scope")
 
         parts = qual_name.split(".")
-        if not (
-            len(parts) == 2 and parts[1] == "*"
-        ):  # the "function name" of a class service "function placeholder" is expected to be "ClassName.*"
+        # Class service functions have pattern "ClassName.*", servers use "ClassName"
+        if not (len(parts) == 1 or (len(parts) == 2 and parts[1] == "*")):
             raise ExecutionError(
                 f"Internal error: Invalid 'service function' identifier {qual_name}. Please contact Modal support"
             )
@@ -537,6 +530,31 @@ def import_class_service(
         assert not function_def.use_method_name  # new "placeholder methods" should not be invoked directly!
         cls_name = parts[0]
         cls_or_user_cls = getattr(module, cls_name)
+    return cls_or_user_cls
+
+
+def import_class_service(
+    function_def: api_pb2.Function,
+    service_function_hydration_data: api_pb2.Object,
+    class_id: str,
+    client: "modal.client.Client",
+    ser_user_cls: Optional[type],
+    cls_args,
+    cls_kwargs,
+) -> Service:
+    """
+    This imports a full class to be able to execute any @method or webhook decorated methods.
+
+    See import_function.
+    """
+    active_app: Optional["modal.app._App"]
+    service_deps: Optional[Sequence["modal._object._Object"]]
+    cls_or_user_cls: typing.Union[type, modal.cls.Cls]
+
+    cls_or_user_cls = typing.cast(
+        typing.Union[type, modal.cls.Cls],
+        _get_cls_or_user_cls(function_def, ser_user_cls),
+    )
 
     if isinstance(cls_or_user_cls, modal.cls.Cls):
         _cls = typing.cast(modal.cls._Cls, synchronizer._translate_in(cls_or_user_cls))
@@ -572,6 +590,56 @@ def import_class_service(
     )
 
 
+def import_server_service(
+    function_def: api_pb2.Function,
+    service_function_hydration_data: api_pb2.Object,
+    client: "modal.client.Client",
+    ser_user_cls: Optional[type],
+) -> Service:
+    """
+    This imports a class as a server to server HTTP requests.
+
+    See import_function.
+    """
+    active_app: Optional["modal.app._App"]
+    service_deps: Optional[Sequence["modal._object._Object"]]
+    cls_or_user_cls: typing.Union[type, modal.server.Server]
+
+    cls_or_user_cls = typing.cast(
+        typing.Union[type, modal.server.Server],
+        _get_cls_or_user_cls(function_def, ser_user_cls),
+    )
+
+    if isinstance(cls_or_user_cls, modal.server.Server):
+        _server = typing.cast(modal._server._Server, synchronizer._translate_in(cls_or_user_cls))
+        server_service_function: _Function = _server._get_service_function()
+        service_deps = server_service_function.deps(only_explicit_mounts=True)
+        active_app = _server._get_app()
+
+    else:
+        # Undecorated user class (serialized or local scope-decoration).
+        service_deps = None  # we can't infer service deps for now
+        active_app = get_active_app_fallback(function_def)
+        _client = typing.cast("modal.client._Client", synchronizer._translate_in(client))
+        _service_function: modal._functions._Function[Any, Any, Any] = modal._functions._Function._new_hydrated(
+            service_function_hydration_data.object_id,
+            _client,
+            service_function_hydration_data.function_handle_metadata,
+            is_another_app=True,  # this skips re-loading the function, which is required since it doesn't have a loader
+        )
+
+        _server = modal._server._Server._from_local(cls_or_user_cls, active_app, _service_function)
+
+    user_cls = _server._get_user_cls()
+    # Create server object with lifecycle methods registered.
+    return ImportedServer(
+        user_cls_instance=user_cls(),
+        app=active_app,
+        service_deps=service_deps,
+        function_def=function_def,
+    )
+
+
 def get_active_app_fallback(function_def: api_pb2.Function) -> _App:
     # This branch is reached in the special case that the imported function/class is:
     # 1) not serialized, and

{modal-1.3.1.dev32 → modal-1.3.1.dev34}/modal/_server.py

@@ -41,10 +41,10 @@ class _Server:
     See [lifecycle hooks](https://modal.com/docs/guide/lifecycle-functions) for more information.
 
     Generally, you will not construct a Server directly.
-    Instead, use the [`@app.server()`](https://modal.com/docs/reference/modal.App#server) decorator.
+    Instead, use the [`@app._experimental_server()`](https://modal.com/docs/reference/modal.App#server) decorator.
 
     ```python notest
-    @app.server(port=8000, proxy_regions=["us-east", "us-west"])
+    @app._experimental_server(port=8000, proxy_regions=["us-east", "us-west"])
     class MyServer:
         @modal.enter()
         def start_server(self):
@@ -78,8 +78,14 @@ class _Server:
     # ============ Live Methods ============
 
     @live_method
-    async def get_urls(self) -> Optional[list[str]]:
-        return await self._get_service_function()._experimental_get_flash_urls()
+    async def get_urls(self) -> Optional[dict[str, str]]:
+        def _extract_region_from_url(url: str) -> str:
+            return url.split(".")[-3].removeprefix("modal-")
+
+        return {
+            _extract_region_from_url(url): url
+            for url in await self._get_service_function()._experimental_get_flash_urls()
+        }
 
     @live_method
     async def update_autoscaler(
@@ -129,7 +135,7 @@ class _Server:
     ) -> "_Server":
         """Create a Server from a local class definition."""
 
-        # Note: Validation should be done by the caller (app.server()) BEFORE creating the Server.
+        # Note: Validation should be done by the caller (app._experimental_server()) BEFORE creating the Server.
         # Extract the underlying class if wrapped in a _PartialFunction (e.g., from @modal.clustered())
         user_cls = _Server._extract_user_cls(wrapped_user_cls)
 
@@ -182,7 +188,7 @@ class _Server:
         user_cls = _Server._extract_user_cls(wrapped_user_cls)
 
         if not inspect.isclass(user_cls):
-            raise TypeError("The @app.server() decorator must be used on a class.")
+            raise TypeError("The @app._experimental_server() decorator must be used on a class.")
 
         # Check for modal.parameter() - not allowed on server classes
         params = {k: v for k, v in user_cls.__dict__.items() if is_parameter(v)}

{modal-1.3.1.dev32 → modal-1.3.1.dev34}/modal/_utils/function_utils.py

@@ -160,7 +160,6 @@ class FunctionInfo:
     ):
         self.raw_f = f
         self.user_cls = user_cls
-
         if f is None and user_cls:
             # "service function" for running all methods of a class
             self.implementation_name = f"{user_cls.__name__}.*"
@@ -264,8 +263,7 @@ class FunctionInfo:
         LOAD_ATTR = opcode.opmap["LOAD_ATTR"]
         STORE_ATTR = opcode.opmap["STORE_ATTR"]
 
-        func = self.raw_f
-        code = func.__code__
+        code = self.raw_f.__code__
         f_attr_ops = set()
         for instr in dis.get_instructions(code):
             if instr.opcode == LOAD_ATTR:
@@ -663,10 +661,11 @@ class FunctionCreationStatus:
                 )
 
         elif self.response.function.flash_service_urls:
+            self.status_row.finish(f"Created function {self.tag}.")
             for flash_service_url in self.response.function.flash_service_urls:
                 flash_service_url_status_row = self.resolver.add_status_row()
                 flash_service_url_status_row.finish(
-                    f"Created flash service endpoint for {self.tag} => "
+                    f"Created server endpoints for {self.tag} => "
                     f"[magenta underline]{flash_service_url}[/magenta underline]"
                 )
 

{modal-1.3.1.dev32 → modal-1.3.1.dev34}/modal/app.py

@@ -30,12 +30,18 @@ from ._partial_function import (
     _PartialFunctionFlags,
     verify_concurrent_params,
 )
+from ._server import _Server, validate_http_server_config
 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_flash_object, is_global_object, is_method_fn
+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
@@ -1184,6 +1190,155 @@ class _App:
 
         return wrapper
 
+    def _experimental_server(
+        self,
+        _warn_parentheses_missing=None,  # mdmd:line-hidden
+        *,
+        image: Optional[_Image] = None,  # The image to run as the container for the server
+        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; either a single GPU type or a list of types
+        serialized: bool = False,  # Whether to send the server class over using cloudpickle.
+        volumes: dict[
+            Union[str, PurePosixPath], Union[_Volume, _CloudBucketMount]
+        ] = {},  # Mount points for Modal Volumes & CloudBucketMounts
+        cpu: Optional[Union[float, tuple[float, float]]] = None,  # CPU cores to request
+        memory: Optional[Union[int, tuple[int, int]]] = None,  # Memory in MiB to request
+        ephemeral_disk: Optional[int] = None,  # Ephemeral disk size in MiB
+        min_containers: Optional[int] = None,  # Minimum number of containers to keep warm
+        max_containers: Optional[int] = None,  # Maximum number of containers
+        buffer_containers: Optional[int] = None,  # Additional idle containers under active load
+        scaledown_window: Optional[int] = None,  # Max idle time before scaling down (seconds)
+        proxy: Optional[_Proxy] = None,  # Modal Proxy to use in front of this server
+        port: int = 8000,  # Port the HTTP server listens on
+        startup_timeout: int = 30,  # Maximum startup time in seconds
+        exit_grace_period: int = 0,  # Grace period for in-flight requests on shutdown
+        proxy_regions: Optional[Sequence[str]] = ["us-east"],  # Required: Regions to deploy proxy endpoints
+        h2_enabled: bool = False,  # Enable HTTP/2
+        target_concurrency: Optional[int] = None,  # Target concurrency for the server
+        cloud: Optional[str] = None,  # Cloud provider (aws, gcp, oci, auto)
+        region: Optional[Union[str, Sequence[str]]] = None,  # Region(s) to run on
+        nonpreemptible: bool = False,  # Whether to use non-preemptible instances
+        enable_memory_snapshot: bool = False,  # Enable memory checkpointing
+        i6pn: Optional[bool] = None,  # Enable IPv6 container networking
+        include_source: Optional[bool] = None,  # Whether to add source to container
+        # Experimental options
+        experimental_options: Optional[dict[str, Any]] = None,
+    ) -> Callable[[Union[CLS_T, _PartialFunction]], _Server]:
+        """
+        Decorator to register a new Modal Server with this App.
+
+        Servers run HTTP servers that are started in an `@enter` method.
+        Unlike `@app.cls()`, servers only expose HTTP endpoints and do not
+        support `.remote()` method calls.
+
+        Example:
+
+        ```python
+        @app._experimental_server(port=8000, proxy_regions=["us-east"])
+        class MyServer:
+            @modal.enter()
+            def start(self):
+                self.proc = subprocess.Popen(["python3", "-m", "http.server", "8000"])
+
+            @modal.exit()
+            def stop(self):
+                self.proc.terminate()
+        ```
+        """
+        if _warn_parentheses_missing:
+            raise InvalidError("Did you forget parentheses? Suggestion: `@app._experimental_server()`.")
+
+        # Validate HTTP server config
+        validate_http_server_config(
+            port=port,
+            proxy_regions=proxy_regions,
+            startup_timeout=startup_timeout,
+            exit_grace_period=exit_grace_period,
+        )
+
+        if target_concurrency is not None:
+            if not isinstance(target_concurrency, int) or target_concurrency < 1:
+                raise InvalidError("The `target_concurrency` argument must be a positive integer.")
+
+        http_config = api_pb2.HTTPConfig(
+            port=port,
+            proxy_regions=proxy_regions,
+            startup_timeout=startup_timeout,
+            exit_grace_period=exit_grace_period,
+            h2_enabled=h2_enabled,
+        )
+
+        # Build secrets list
+        secrets_list: list[_Secret] = list(secrets) if secrets else []
+        if env:
+            secrets_list.append(_Secret.from_dict(env))
+
+        def wrapper(wrapped_user_cls: Union[CLS_T, _PartialFunction, Callable]) -> _Server:
+            _Server._validate_wrapped_user_cls_decorators(wrapped_user_cls, enable_memory_snapshot)
+
+            # Validate the server class
+            _Server._validate_construction_mechanism(wrapped_user_cls)
+
+            # Extract the underlying class if wrapped in a _PartialFunction (e.g., from @modal.clustered())
+            cluster_size = None
+            rdma = None
+            user_cls = wrapped_user_cls
+
+            if isinstance(wrapped_user_cls, _PartialFunction):
+                user_cls = wrapped_user_cls.user_cls
+                if wrapped_user_cls.flags & _PartialFunctionFlags.CLUSTERED:
+                    cluster_size = wrapped_user_cls.params.cluster_size
+                    rdma = wrapped_user_cls.params.rdma
+
+            local_state = self._local_state
+
+            # Create the FunctionInfo for the server, note we treat FunctionInfo as a class for servers
+            info = FunctionInfo(None, serialized=serialized, user_cls=user_cls, name_override=user_cls.__name__)
+            # Create the service function
+            service_function = _Function.from_local(
+                info,
+                app=self,
+                image=image or self._get_default_image(),
+                secrets=[*local_state.secrets_default, *secrets_list],
+                gpu=gpu,
+                network_file_systems={},  # Deprecated: No support for Server level network file systems
+                volumes={**local_state.volumes_default, **volumes},
+                cpu=cpu,
+                memory=memory,
+                ephemeral_disk=ephemeral_disk,
+                min_containers=min_containers,
+                max_containers=max_containers,
+                buffer_containers=buffer_containers,
+                scaledown_window=scaledown_window,
+                proxy=proxy,
+                retries=None,  # No support for Server level retries
+                max_concurrent_inputs=None,  # No support for Server level concurrent inputs
+                target_concurrent_inputs=target_concurrency,  # No support for Server level concurrent inputs
+                batch_max_size=None,  # No support for Server level batching
+                batch_wait_ms=None,  # No support for Server level batching
+                startup_timeout=startup_timeout,
+                cloud=cloud,
+                region=region,
+                nonpreemptible=nonpreemptible,
+                enable_memory_snapshot=enable_memory_snapshot,
+                single_use_containers=False,  # No support for single-use server containers
+                http_config=http_config,
+                is_server=True,
+                i6pn_enabled=i6pn or (cluster_size is not None),
+                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()},
+                restrict_output=False,
+            )
+
+            self._add_function(service_function, is_web_endpoint=False)
+            server: _Server = _Server._from_local(wrapped_user_cls, self, service_function)
+            return server
+
+        return wrapper
+
     def include(self, /, other_app: "_App", inherit_tags: bool = True) -> typing_extensions.Self:
         """Include another App's objects in this one.