Class properties in Python 3.11+

Question

In Python 3.9, we gained the ability to chain @classmethod and @property to sensibly create class properties.

class Foo:
  @property
  def instance_property(self):
    return "A regular property"

  @classmethod
  @property
  def class_property(cls):
    return "A class property"

This was enabled by giving @classmethod proper interaction with the descriptor protocol, meaning one's prospects were not limited to @property but any descriptor under the sun. Everything was fine and dandy until it was discovered that the implementation led to "a number of downstream problems", with deprecation coming in Python 3.11.

I've read over the GitHub discussions concerning the deprecation a bit and will not gripe here about what I would call a hasty retraction to a hasty design. The fact of the matter is that class properties are a reasonable thing that people want and could use in Python 3.9/3.10, but now can't. The release notes suggest the following:

To “pass-through” a classmethod, consider using the __wrapped__ attribute that was added in Python 3.10.

It would not be controversial to call such a sentence extremely unhelpful on its own. The descriptor protocol is not something your average user will ever need to or want to encounter, and thus chaining @classmethod with them via a custom implementation is surely something that those in the know could and would spend time figuring out how to properly do in 3.11+.

But for those who have no idea what @property is besides that thing that lets them drop parentheses, how do you define class properties in Python 3.11+, and, in particular, how do you do it well?

Answer 1

Like I always did before 3.9, nonetheless: a custom "property" rewrite.

The problem is, "property" does a lot of things, and if one will need everything its in there, it is a lot of code.

I guess it is possible to just subclass property itself, so that we can get an extra .class_getter decorator.

A class setter, obviously, would involve either a custom metaclass or an especialisation of __setattr__.

Let's see if I can come with a reasonably short classproperty.

[after tinkering a bit]

So, it turns out simply inheriting property and adding a decorator for a "class getter" is not easily feasible - "property" is not written with subclassing and expanding its functionality in mind.

Therefore, the "easy" thing, and subset is to write a custom descriptor decorator, which will just convert a single method into a classgetter - and no set, del or inheritance support at all.

On the other hand, the code is short and simple:

class classproperty:
    def __init__(self, func):
        self.fget = func
    def __get__(self, instance, owner):
        return self.fget(owner)

And this simply works as expected:

In [19]: class A:
    ...:     @classproperty
    ...:     def test(cls):
    ...:         return f"property of {cls.__name__}"
    ...: 

In [20]: A.test
Out[20]: 'property of A'

Another way, if one wants to go all the way to have a class attribute setter, it is a matter of writing a plain property on a custom metaclass (which can exist just for holding the desired properties). This approach however will render the properties invisible on the instances - they will work only on the class itself:

In [22]: class MetaA(type):
    ...:     @property
    ...:     def test(cls):
    ...:         return cls._test
    ...:     @test.setter
    ...:     def test(cls, value):
    ...:         cls._test = value.upper()
    ...: 

In [23]: class A(metaclass=MetaA):
    ...:     pass
    ...: 

In [24]: A.test = "hello world!"

In [25]: A.test
Out[25]: 'HELLO WORLD!'

In [26]: A().test
--------------------------------------------------------------
...
AttributeError: 'A' object has no attribute

Answer 2

I think this is a very good question, and I wish it had a better answer. My favourite approach that I was able to find was using __init_subclass__ from this answer.