装饰实例方法/类方法的 Python 装饰器是否有可能知道 class function 将绑定到？

Question

For a top-level function:

def wrap(f: Callable) -> Callable:
    # Some logic
    return f

When such a function is used to decorate another function defined within a class body:

class SomeClass:
    @wrap
    # may also be a @classmethod
    def some_method(self, *args, **kwargs):
        pass

Is it possible within the wrap function to somehow inspect the passed-in method ( SomeClass.some_method in this case) and retrieve the type object of SomeClass ?

I tried using a debugger to inspect f during runtime, but the only relevant info I could find from f while it's in the wrapper was the __qualname__ attribute, which contained the class name.

---

In case you want to know why I am trying to do this: I am trying to create some kind of schema that is based on the method names (the methods are all properties) for a certain class, and store this schema in a dict where I would like the keys to be the class objects themselves. Expressed in type signatures:

SchemaSource = TypeVar('SchemaSource', bound=Any)
Method = Callable[..., Any]  # will be bound to SchemaSource
Schema = Dict[Type[SchemaSource], Dict[str, Method]]

Of course, I could inspect the class __dict__ later, or use for example an __init_subclass__ hook, but because I would like to include some methods in the schema, I figured that decorating the functions would be a good way to provide this information with a single source.

Answer 1

As jasonharper mentions, the class doesn't exist yet by the time the decorator is called, and so the function it receives is just a regular function (except that its name mentions the class it will be bound to).

---

For my problem, I ended up doing it attrs -style, using an additional decorator to decorate the class as well.

def include(f: Callable) -> Callable:
    """Add function `f` to SchemaBuilder."""
    SchemaBuilder.append(f)
    return f

class SchemaBuilder:
    records: Dict[Type, Dict[Callable, Any]] = {}
    temporary: List[Callable] = []

    @classmethod
    def append(cls, f: Callable):
        """Temporarily store the method in a list."""
        cls.temporary.append(f)

    @classmethod
    def register(cls, target_cls: Type):
        """Associate all methods stored in the list with `target_cls`.

        We rely on the fact that `target_cls` will be instantiated
        (and thus this method called) as soon as all of its (immediate)
        methods have been created.
        """
        cls.records[target_cls] = {k: None for k in cls.temporary}
        cls.temporary = []

# In use:

@SchemaBuilder.register  # called later
class SomeClass:
    @property
    @include  # called first
    def some_property(self):  # will be included
        pass

    @property
    def some_other_property(self):  # will not be included
        pass