Remove ability to reference methods as Functions directly on Cls

modal/cls.py

@@ -863,18 +863,28 @@ def __call__(self, *args, **kwargs) -> _Obj:
         )
 
     def __getattr__(self, k):
-        # TODO: remove this method - access to attributes on classes (not instances) should be discouraged
-        if not self._is_local() or k in self._method_partials:
-            # if not local (== k *could* be a method) or it is local and we know k is a method
-            deprecation_warning(
-                (2025, 1, 13),
-                "Calling a method on an uninstantiated class will soon be deprecated; "
-                "update your code to instantiate the class first, i.e.:\n"
-                f"{self._name}().{k} instead of {self._name}.{k}",
+        if self._user_cls is not None:
+            # local class, we can check if there are static attributes and let the user access them
+            # except if they are PartialFunction (i.e. methods)
+            v = getattr(self._user_cls, k)
+            if not isinstance(v, modal.partial_function.PartialFunction):
+                return v
+
+        # We create a synthetic dummy Function that is guaranteed to raise an AttributeError when
+        # a user tries to use any of its "live methods" - this lets us raise exceptions for users
+        # only if they try to access methods on a Cls as if they were methods on the instance.
+        async def method_loader(fun: _Function, resolver: Resolver, existing_object_id: Optional[str]):
+            raise AttributeError(
+                "You can't access methods on a Cls directly - Did you forget to instantiate the class first?\n"
+                "e.g. instead of MyClass.method.remote(), do MyClass().method.remote()"
             )
-            return getattr(self(), k)
-        # non-method attribute access on local class - arguably shouldn't be used either:
-        return getattr(self._user_cls, k)
+
+        return _Function._from_loader(
+            method_loader,
+            rep=f"UnboundMethod({self._name}.{k})",
+            deps=lambda: [],
+            hydrate_lazily=True,
+        )
 
     def _is_local(self) -> bool:
         return self._user_cls is not None

test/cls_test.py

@@ -1126,30 +1126,55 @@ def f(self):
                 pass
 
 
-def test_using_method_on_uninstantiated_cls(recwarn):
+def test_using_method_on_uninstantiated_cls():
     app = App()
 
     @app.cls(serialized=True)
     class C:
+        some_non_param_variable = 10
+
         @method()
         def method(self):
             pass
 
-    assert len(recwarn) == 0
-    with pytest.raises(AttributeError):
-        C.blah  # type: ignore   # noqa
-    assert len(recwarn) == 0
-
-    assert isinstance(C().method, Function)  # should be fine to access on an instance of the class
-    assert len(recwarn) == 0
-
-    # The following should warn since it's accessed on the class directly
-    C.method  # noqa  # triggers a deprecation warning
-    # TODO: this will be an AttributeError or return a non-modal unbound function in the future:
-    assert len(recwarn) == 1
-    warning_string = str(recwarn[0].message)
-    assert "instantiate the class first" in warning_string
-    assert "C().method instead of C.method" in warning_string
+    assert C.some_non_param_variable == 10
+
+    with pytest.raises(AttributeError, match="blah"):
+        C.blah  # type: ignore
+
+    with pytest.raises(AttributeError, match="Did you forget to instantiate the class first?"):
+        # The following should error since the class is supposed to be instantiated first
+        C.method.remote()  # noqa
+
+
+def test_using_method_on_uninstantiated_hydrated_cls(set_env_client, client):
+    app = App()
+
+    @app.cls(serialized=True)
+    class C:
+        some_non_param_variable = 10
+
+        @method()
+        def method(self):
+            pass
+
+    with app.run(client=client):
+        assert C.some_non_param_variable == 10
+
+        with pytest.raises(AttributeError, match="blah"):
+            C.blah  # type: ignore
+
+        with pytest.raises(AttributeError, match="Did you forget to instantiate the class first?"):
+            # The following should error since the class is supposed to be instantiated first
+            C.method.remote()  # noqa
+
+
+def test_using_method_on_uninstantiated_remote_cls(set_env_client):
+    C = modal.Cls.from_name("app", "C")
+
+    with pytest.raises(AttributeError, match="Did you forget to instantiate the class first?"):
+        # The following should error since the class is supposed to be instantiated first
+        C.method.remote()  # noqa
 
 
 def test_bytes_serialization_validation(servicer, client, set_env_client):