fix

Author: molocule

modal/_partial_function.py

@@ -125,7 +125,6 @@ class _PartialFunction(typing.Generic[P, ReturnType, OriginalReturnType]):
     user_cls: Optional[type] = None  # class
     flags: _PartialFunctionFlags
     params: _PartialFunctionParams
-    registered: bool = False  # Set to True when registered with an App to avoid warnings
 
     def __init__(
         self,

modal/_server.py

@@ -39,11 +39,11 @@ def _get_user_cls(self) -> type:
         return self._user_cls
 
     def _get_app(self) -> "modal.app._App":
-        assert self._app, "app can only be extracted for local Server (in container entrypoint)"
+        assert self._app, "App can only be extracted for a local Server (in container entrypoint)"
         return self._app
 
     def _get_service_function(self) -> _Function:
-        assert self._service_function is not None  # don't we need this?
+        assert self._service_function is not None
         return self._service_function
 
     @staticmethod
@@ -86,15 +86,63 @@ async def update_autoscaler(
 
     # ============ Hydration ============
     async def hydrate(self, client: Optional[_Client] = None) -> "_Server":
-        """Hydrate the server by hydrating its underlying service function."""
         # This is required since we want to support @livemethod() decorated methods
-        # and is normally handled by the _Object.hydrate() method
-        # but we only want to hydrate the service function.
         service_function = self._get_service_function()
         await service_function.hydrate(client)
         return self
 
     # ============ Construction ============
+    @staticmethod
+    def from_local(
+        wrapped_user_cls: "type | _PartialFunction",
+        app: "modal.app._App",
+        service_function: _Function,
+    ) -> "_Server":
+        """Create a Server from a local class definition."""
+
+        # Note: Validation should be done by the caller (app.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)
+
+        server = _Server()
+        server._app = app
+        server._user_cls = user_cls
+        server._service_function = service_function
+        return server
+
+    @classmethod
+    def from_name(
+        cls: type["_Server"],
+        app_name: str,
+        name: str,
+        *,
+        environment_name: Optional[str] = None,
+        client: Optional[_Client] = None,
+    ) -> "_Server":
+        """Reference a Server from a deployed App by its name.
+
+        This is a lazy method that defers hydrating the local
+        object with metadata from Modal servers until the first
+        time it is actually used.
+
+        TODO(claudia): Add examples
+        """
+
+        load_context_overrides = LoadContext(client=client, environment_name=environment_name)
+
+        server = _Server()
+        server._service_function = _Function._from_name(
+            app_name,
+            name,
+            load_context_overrides=load_context_overrides,
+        )
+        return server
+
+    def _is_local(self) -> bool:
+        """Returns True if this Server has local source code available."""
+        return self._user_cls is not None
+
+    # ============ Validation ============
 
     @staticmethod
     def _validate_wrapped_user_cls_decorators(
@@ -157,64 +205,3 @@ def validate_construction_mechanism(wrapped_user_cls: "type | _PartialFunction")
                 f"Server class {user_cls.__name__} cannot have a custom __init__ method. "
                 "Use @modal.enter() for initialization logic instead."
             )
-
-    @staticmethod
-    def from_local(
-        wrapped_user_cls: "type | _PartialFunction",
-        app: "modal.app._App",
-        service_function: _Function,
-    ) -> "_Server":
-        """Create a Server from a local class definition.
-
-        Note: Validation should be done by the caller (app.server()) BEFORE creating
-        the service function, so we don't repeat it here.
-        """
-        # Extract the underlying class if wrapped in a _PartialFunction (e.g., from @modal.clustered())
-        user_cls = _Server._extract_user_cls(wrapped_user_cls)
-
-        # Mark lifecycle methods as registered to avoid warnings
-        lifecycle_flags = ~_PartialFunctionFlags.interface_flags()
-        lifecycle_partials = _find_partial_methods_for_user_cls(user_cls, lifecycle_flags)
-        for partial_function in lifecycle_partials.values():
-            partial_function.registered = True
-
-        server = _Server()
-        server._app = app
-        server._user_cls = user_cls
-        server._service_function = service_function
-        return server
-
-    @classmethod
-    def from_name(
-        cls: type["_Server"],
-        app_name: str,
-        name: str,
-        *,
-        environment_name: Optional[str] = None,
-        client: Optional[_Client] = None,
-    ) -> "_Server":
-        """Reference a Server from a deployed App by its name.
-
-        This is a lazy method that defers hydrating the local
-        object with metadata from Modal servers until the first
-        time it is actually used.
-
-        TODO(claudia): Add examples
-        """
-
-        load_context_overrides = LoadContext(client=client, environment_name=environment_name)
-
-        # Server service functions use "#ClassName" naming convention
-        service_function_name = f"#{name}"
-
-        server = _Server()
-        server._service_function = _Function._from_name(
-            app_name,
-            service_function_name,
-            load_context_overrides=load_context_overrides,
-        )
-        return server
-
-    def _is_local(self) -> bool:
-        """Returns True if this Server has local source code available."""
-        return self._user_cls is not None

modal/app.py

@@ -1286,19 +1286,19 @@ def wrapper(wrapped_user_cls: Union[CLS_T, _PartialFunction, Callable]) -> Serve
             # 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
-            else:
-                user_cls = wrapped_user_cls
 
             local_state = self._local_state
 
             # Create the FunctionInfo for the server, note we treat FunctionInfo as a class for servers
             # Use "#ClassName" format to avoid collision with class_ids which use "ClassName"
-            info = FunctionInfo(None, serialized=serialized, user_cls=user_cls, name_override=f"#{user_cls.__name__}")
+            info = FunctionInfo(None, serialized=serialized, user_cls=user_cls, name_override=f"{user_cls.__name__}")
             # Create the service function
             service_function = _Function.from_local(
                 info,
@@ -1337,19 +1337,7 @@ def wrapper(wrapped_user_cls: Union[CLS_T, _PartialFunction, Callable]) -> Serve
             )
 
             self._add_function(service_function, is_web_endpoint=False)
-
-            # Create the Server object
             server: Server = Server.from_local(wrapped_user_cls, self, service_function)
-
-            # Mark lifecycle methods as registered
-            for flag in (~_PartialFunctionFlags.interface_flags(),):
-                for partial in _find_partial_methods_for_user_cls(user_cls, flag).values():
-                    partial.registered = True
-
-            # Note: We don't register the Server in classes - only the service_function is registered.
-            # The Server is just a local wrapper. The container side identifies servers via
-            # function_def.is_class and the function_ids.
-
             return server  # type: ignore
 
         return wrapper

test/container_test.py

@@ -2484,7 +2484,7 @@ def test_server_lifecycle_with_deployed_metadata(servicer, tmp_path, deployed_su
         servicer,
         tmp_path,
         deployed_support_function_definitions,
-        "AppServerWithEnter.*",  # function name as stored by isolated_deploy
+        "AppServerWithEnter",
         inputs=[],  # Server classes don't have method inputs
     )
     stdout, stderr = container_process.communicate(timeout=15)

test/flash_cls_test_with_app_server.py

@@ -68,15 +68,15 @@ def test_run_server(client, servicer):
     assert servicer.n_functions == 1
     objects = servicer.app_objects[app_id]
     # Servers use just the class name, not "ClassName.*"
-    server_function_id = objects["#FlashClassDefault"]
+    server_function_id = objects["FlashClassDefault"]
     assert servicer.precreated_functions == {server_function_id}
     assert method_handle_object_id == server_function_id
     assert len(objects) == 1  # just the service function
     assert server_function_id.startswith("fu-")
     assert servicer.app_functions[server_function_id].is_class
 
     assert servicer.app_functions[server_function_id].module_name == "test.flash_cls_test_with_app_server"
-    assert servicer.app_functions[server_function_id].function_name == "#FlashClassDefault"
+    assert servicer.app_functions[server_function_id].function_name == "FlashClassDefault"
     assert servicer.app_functions[server_function_id].target_concurrent_inputs == 10
     assert servicer.app_functions[server_function_id].method_definitions_set
     assert servicer.app_functions[server_function_id].startup_timeout_secs == 30
@@ -106,7 +106,7 @@ def test_flash_params_override_experimental_options(client, servicer):
         app_id = flash_params_override_app.app_id
 
         objects = servicer.app_objects[app_id]
-        server_function_id = objects["#FlashParamsOverrideClass"]
+        server_function_id = objects["FlashParamsOverrideClass"]
 
         assert servicer.app_functions[server_function_id].target_concurrent_inputs == 11
         assert servicer.app_functions[server_function_id].experimental_options["flash"] == "us-east"

test/server_test.py

@@ -247,9 +247,9 @@ def start(self):
 
     with app.run(client=client):
         # This should not raise AttributeError: '_Server' object has no attribute 'hydrate'
-        urls = URLServer.get_urls()  # type: ignore[attr-defined]
+        urls = URLServer._experimental_get_urls()  # type: ignore[attr-defined]
         # URLs are generated by the mock servicer based on function name and proxy regions
-        assert urls == ["https://modal-labs--#urlserver.modal-us-east.modal.direct"]
+        assert urls == ["https://modal-labs--urlserver.modal-us-east.modal.direct"]
 
 
 def test_server_update_autoscaler(client, servicer):
@@ -444,9 +444,9 @@ def start(self):
         objects = servicer.app_objects[app_id]
 
         # Servers use "#ClassName" naming convention
-        assert "#ObjectsServer" in objects
+        assert "ObjectsServer" in objects
 
-        server_id = objects["#ObjectsServer"]
+        server_id = objects["ObjectsServer"]
         assert server_id.startswith("fu-")