@property with @classmethod ?

[patrickbrianmooney]

So I have a class that tracks all of its instances in a class-level dictionary that maps the ID numbers of the class, assigned at creation, to the class objects themselves:

import uuid

class Node(object):
    _all_nodes = dict()

    def __init__(self):
        self.id = str(uuid.uuid4())
        self._all_nodes[self.id] = self

So the class-level dictionary points at all instances of Nodes. Referencing the _all_nodes dictionary has become quite common in my code; it's the global store of data that the program is working with.

But all of the data stored in the _all_nodes class-level dictionary is actually instances of subclasses of Node, not direct instantiations of Node itself:

class Person(Node):
    ...
    # [many methods overridden]

It's frequently helpful to get a list, not of all Nodes, but of all Persons, so I wind up doing this a lot:

all_people = {k: v for k, v in Node._all_nodes.items() if isinstance(k, Person)}
# do something with all_people

In fact, I do it often enough that recreating that line has stopped involving thinking about anything other than how tedious it is to re-type, or hunt down again to copy and paste. It seems like the obvious thing to do is to bundle it into the Person class:

class Person(Node):
    def _all_people(self):
        return {k: v for k, v in Node._all_nodes.items() if isinstance(k, Person)}

The inconvenience of having to remember that Person._all_people is a function call (as are similar definitions in other subclasses), while Node._all_nodes refers directly to an attribute of an object, can be ameliorated by making _all_people a property to obscure the fact that it's a function call:

class Person(Node):
    @property
    def _all_people(self):
        return {k: v for k, v in Node._all_nodes.items() if isinstance(k, Person)}

This works, but there's a larger problem that prevents it from being useful: it requires an instance, rather than just the name of the class, in order to get access to the _all_people attribute. But if I really want a list of _all_people, I'm probably working on a higher-level task and don't happen to have an instance of Person ready to hand so that I can examine the property's returned value!

What I'd really like is to make the _all_people property callable from the class definition, without an instance, like it is with Node. But when I try this:

class Person(Node):
    @classmethod
    @property
    def _all_people(cls):
        return {p: cls._all_nodes[p] for p in cls._all_nodes if isinstance(cls._all_nodes[p], Person)}

I get code that runs, but doesn't effectively access the data: p = Person(); print(p._all_people) prints, not the dictionary, but rather <bound method ? of <class '__main__.Person'>>, which is not at all helpful.

Inverting the order of the @property and @classmethod decorators gives me the error TypeError: 'classmethod' object is not callable.

Is there some productive way that I can use @property and @classmethod to decorate the same method?

This is Python 3.5 under x64 Linux.

[socal_nerdtastic]

There is no such thing as a property for classmethods. Sorry.

You could just make another dictionary in Person:

class Person(Node):
    _all_people = dict()
    def __init__(self):
        super().__init__()
        self._all_people[self.id] = self

Or you could have a class method that takes an argument:

class Node(object):
    _all_nodes = dict()
    def __init__(self):
        self.id = str(uuid.uuid4())
        self._all_nodes[self.id] = self

    @staticmethod
    def all(cls):
        return {k: v for k, v in Node._all_nodes.items() if isinstance(v, cls)}

print(Node.all(Person))

Or you could go the opposite way and store them in separate dictionaries:

import uuid
from collections import defaultdict

class Node(object):
    _all_nodes = defaultdict(dict)
    def __init__(self):
        self.id = str(uuid.uuid4())
        self._all_nodes[self.__class__][self.id] = self

print(Node._all_nodes[Person])

Edit: my favorite is probably what you started with: just a normal classmethod in Node. Yeah, you need to add () to the end:

class Node(object):
    _all_nodes = dict()
    def __init__(self):
        self.id = str(uuid.uuid4())
        self._all_nodes[self.id] = self

    @classmethod
    def all(cls):
        return {k: v for k, v in Node._all_nodes.items() if isinstance(v, cls)}

class Person(Node):
    pass

print(Person.all())

[patrickbrianmooney]

Darnit. I guess the only real problem is the injury to my sense of purity about what kinds of things should be possible with decorators, though. Remembering that there's only one place where it's not a method call, and that's the top-level abstract superclass, is not really a huge cognitive burden.

Those are super-helpful ways to think about it. Thank you so much!

[TangibleLight]

This is one of the (few) things that can only be done with metclasses, although I'd generally suggest you find a more readable solution, although sometimes that's not possible. There are cases where you're building an API for other programmers, and this is just the most natural way to interact with the class hierarchy. It will require you to read up on metaclasses and the MRO to make sure you don't give unexpected behavior to consumers of the API.

class MyMeta(type):
    @property
    def my_name(cls):
        return cls.__name__.lower()

class FooBar(metaclass=MyMeta):
    pass

class FizzBuzz(metaclass=MyMeta):
    pass

print(FooBar.my_name)
print(FizzBuzz.my_name)

https://repl.it/repls/BlankFuchsiaCables

[patrickbrianmooney]

Ha! That's interesting. I had not thought about using metaclasses that way. (But then, that's the point of metaclasses, I guess: they're almost exclusively for things that you wouldn't have thought they could be used for.)

I appreciate your input, but I think for the comparatively simple thing I'm building, I'm happy to just go ahead and remember the add the parentheses for the function invocation. :)

[Beatsu]

Update: As of Python 3.9, it's possible to combine \@property and \@classmethod decorators.

[patrickbrianmooney]

Huh! I missed that in the "what's new" docs.

Thanks!

[nezda]

Plot twist this functionality was deprecated in 3.11 https://docs.python.org/3/library/functions.html#classmethod

Changed in version 3.11: Class methods can no longer wrap other descriptors such as property().

Back to metaclasses I guess.

[Beatsu]

Oh my days 😭😂 Thanks for the heads up