Make classproperty descriptor work #2563

Activity

1. JukkaL

   added

   bugmypy got something wrongmypy got something wrong

   priority-1-normal

   on Jan 16, 2017
2. JukkaL

   added

   false-positivemypy gave an error on correct codemypy gave an error on correct code

   on May 19, 2018
3. tyrion commented on Aug 22, 2019

   

   tyrion

   on Aug 22, 2019

   Contributor

   More actions

   It seems to work in this way:

   from typing import *
   
   T = TypeVar("T")
   V = TypeVar("V")
   
   class classproperty(Generic[T, V]):
       def __init__(self, getter: Callable[[Type[T]], V]) -> None:
           self.getter = getattr(getter, "__func__", getter)
   
       def __get__(self, instance: Any, owner: Type[T]) -> V:
           return self.getter(owner)
   
   class C:
       @classproperty
       @classmethod
       def foo(cls) -> int:
           return 42
   
   reveal_type(C.foo)

   I don't think it is ideal to have to use both classproperty and classmethod but I couldn't find an other way to make it work.
4. oakkitten commented on May 20, 2020

   

   oakkitten

   on May 20, 2020

   Last edited by oakkitten

   More actions

   the last example doesn't work with TypeVars:

   from typing import *
   
   T = TypeVar("T")
   V = TypeVar("V")
   
   class classproperty(Generic[T, V]):
       def __init__(self, getter: Callable[[Type[T]], V]) -> None:
           self.getter = getattr(getter, "__func__", getter)
   
       def __get__(self, instance: Any, owner: Type[T]) -> V:
           return self.getter(owner)
   
   F = TypeVar("F", bound='Foo')
   
   class Foo:
       @classproperty
       @classmethod
       def foo(cls: Type[F]) -> F:
           return cls()
   
   class Bar(Foo):
       pass
   
   reveal_type(Bar.foo)

   yields

   main.py:24: error: Argument 2 to "__get__" of "classproperty" has incompatible type "Type[Bar]"; expected "Type[F]"
   main.py:24: note: Revealed type is 'F`-1'
   Found 1 error in 1 file (checked 1 source file)
   

   seems to work if you remove T, although it feels like a wrong thing to do?
5. sirosen commented on Nov 5, 2021

   

   sirosen

   on Nov 5, 2021

   More actions

   Under 3.9, the docs are now recommending the use of classmethod(property(...)) to handle class properties. This is reinforced by sphinx having special-cased support for this case -- if you want autodoc to produce class property docs, it must be done by wrapping a property in the classmethod descriptor.

   If you try to do this and run mypy, however, the class property type is deduced as () -> T instead of T.

   e.g.

   class A:
       @classmethod
       @property
       def foo(cls) -> int:
           return 1
   
   reveal_type(A.foo)
   

   shows Revealed type is "def () -> builtins.int"

   Would it be possible to special-case classmethod(property(...)) to make that case behave correctly? That would satisfy at least some cases and harmonize with 3.9+ docs and sphinx behavior.

   Right now, trying to declare a read-only class property which satisfies the trifecta of

   • runtime behavior
   • sphinx autodoc extension
   • mypy

   is quite tricky.
6. AlexWaygood

   added

   topic-descriptorsProperties, class vs. instance attributesProperties, class vs. instance attributes

   on Mar 24, 2022
7. JacobHayes commented on May 9, 2022

   

   JacobHayes

   on May 9, 2022

   More actions

   I've been using a TypeVar and wrapping func to hack this together:

   from collections.abc import Callable
   from typing import TypeVar
   
   PropReturn = TypeVar("PropReturn")
   
   
   def classproperty(meth: Callable[..., PropReturn]) -> PropReturn:
       """Access a @classmethod like a @property."""
       # mypy doesn't understand class properties yet: https://github.com/python/mypy/issues/2563
       return classmethod(property(meth))  # type: ignore
   
   
   class A:
       @classproperty
       def x(cls) -> int:
           return 5
   
   
   print(A.x)  # 5
   reveal_type(A.x)  # note: Revealed type is "builtins.int"
   print(A().x)  # 5
   reveal_type(A().x)  # note: Revealed type is "builtins.int"

   Rather than muck with casts (since they'd be lying anyway 😁), the # type: ignore inside classproperty works around Argument 1 to "classmethod" has incompatible type "property"; expected "Callable[..., Any]" and Incompatible return value type.

   👍React with 👍1Reacted by E. M. Bray
8. hirotasoshu

   added a commit that references this issue on Dec 17, 2023

   feat(utils): add classproperty decorator

   ...

   342d704