Как определить, вызывается ли метод класса в экземпляре или в классе

Для этого я использую декоратор классов __call__ и __get__.

Вот:

class LoggerDecorator:
    def __init__(self, func):
        self.func = func
    
    def __call__(self, *args, **kwargs):
        return self.func(*args, **kwargs)
    
    def __get__(self, instance, owner):
        if not instance:
            return self.func.__get__(owner, owner)
        return self.func.__get__(instance, owner)

Пояснения:

Ключевая идея этой реализации — использовать методы __get__ и __call__ в декораторе класса для обработки различных типов вызовов функций.

Проблема, с которой мы здесь сталкиваемся, заключается в том, что декоратор используется как универсальный способ обертывания различных функций, но получаемые им параметры различаются в зависимости от типа вызываемой функции (например, classmethod(cls, ), staticmethod(), instance method(self, )). Как отметил автор темы, параметризация (например, использование типа первого параметра функции) в качестве определяющего условия для функции-обертки, несомненно, рискованна.

Здесь вместо декоратора функции мы используем декоратор класса. Условие обработки декоратора перенесено с «параметризации» вспомогательной функции-оболочки на дескриптор __get__, который определяет, используется ли функция экземпляром, созданным экземпляром.

1. __get__ : метод __get__ вызывается для получения атрибута класса-владельца (доступ к атрибуту класса) или экземпляра этого класса (доступ к атрибуту экземпляра).

   Давайте возьмем «метод класса» в качестве примера и сравним различия в методе get, когда он вызывается «напрямую» (обычное использование) и когда он вызывается созданным экземпляром:

   class LoggerDecorator:
       def __init__(self, func):
           self.func = func
   
       def __get__(self, instance, owner):
           print(f'self:     {self}')
           print(f'instance: {instance}')
           print(f'owner:    {owner}')
           return self.func.__get__(owner, owner)
   
    class SomeClass:
        @LoggerDecorator
        @classmethod
        def class_method(cls, some_var):
            print(f"print some_var: {some_var}")
   
   # Call Directly
   SomeClass.class_method("Call Directly")
   
   # Called by instance.
   s = SomeClass()
   s.class_method("Called by instance")
   

   # OUTPUT
   --- Called by directly ---
   self:     <__main__.LoggerDecorator object at 0x7f36aad05590>
   instance: None
   owner:    <class '__main__.SomeClass'>
   print some_var: Call Directly
   
   --- Called by instance ---
   self:     <__main__.LoggerDecorator object at 0x7f36aad05590>
   instance: <__main__.SomeClass object at 0x7f36aad06150>
   owner:    <class '__main__.SomeClass'>
   print some_var: Called by instance
   

   Мы можем заметить, что при прямом вызове экземпляром будет None. И результат тот же для статического метода (для его вызова необходим экземпляр). Следовательно, мы можем использовать, является ли экземпляр в __get__None в качестве определяющего фактора.

2. __call__: Метод __call__ отвечает за оформление «автономных функций» или любой функции, не принадлежащей классу. Когда мы декорируем функцию следующим образом:

   @LoggerDecorator
   def standalone_function():
      return
   

   что равно

   LoggerDecorator(standalone_function)
   

   и это запускает метод __call__.

Полное тестирование: код и результат

class LoggerDecorator:
    def __init__(self, func):
        self.func = func
 
    def __call__(self, *args, **kwargs):
        return self.func(*args, **kwargs)
 
    def __get__(self, instance, owner): 
        print(f'self:     {self}')
        print(f'instance: {instance}')
        print(f'owner:    {owner}')

        if not instance:
            return self.func.__get__(owner, owner)
        return self.func.__get__(instance, owner)


class SomeClass:
    @LoggerDecorator
    @classmethod
    def class_method(cls, some_var: str, *args, **kwargs):
        print(f"Class method: {some_var}")
        print(f"Class method args: {args}")
        print(f"Class method kwargs: {kwargs}")
    
    @LoggerDecorator
    def instance_method(self, some_var: str, *args, **kwargs):
        print(f"Instance method: {some_var}")
        print(f"Instance method args: {args}")
        print(f"Instance method kwargs: {kwargs}")

    @LoggerDecorator
    @staticmethod
    def static_method(some_var: str, *args, **kwargs):
        print(f"Static method: {some_var}")
        print(f"Static method args: {args}")
        print(f"Static method kwargs: {kwargs}")

@LoggerDecorator
def standalone_function(some_var: str, *args, **kwargs):
    print(f"Standalone function: {some_var}")
    print(f"Standalone function args: {args}")
    print(f"Standalone function kwargs: {kwargs}")

if __name__ == '__main__':
    ### Class Method ###
    # Call Directly
    print("### Class Method ###")
    print("--- Called by directly ---")
    SomeClass.class_method("Test1", "class_directly", a1 = "class_a", b1 = "class_b")

    # Called by instance.
    print("")
    print("--- Called by instance ---")
    s = SomeClass()
    s.class_method("Test2", "class_by_instance", a1 = "class_a", b1 = "class_b")
 
    ### Static Method ###
    # Call Directly
    print("")
    print("### Static Method ###")
    print("--- Called by directly ---")
    SomeClass.static_method("Test3", "static_directly", a1 = "static_a", b1 = "static_b")
 
    # Called by instance.
    print("")
    print("--- Called by instance ---")
    s.static_method("Test4", "static_by_instance", a1 = "static_a", b1 = "static_b")
 
    ### Instance Method ###
    # Call only by instance
    print("")
    print("### Instance Method ###")
    s.instance_method("Test5", "instance", a1 = "instance_a", b1 = "instance_b")

    ### Standalone Function
    print("")
    print("### Standalone Function ###")
    standalone_function("Test6", "standalone", a1 = "standalone_a", b1 = "standalone_b")

### Class Method ###
--- Called by directly ---
self:     <__main__.LoggerDecorator object at 0x7f858c34e390>
instance: None
owner:    <class '__main__.SomeClass'>
Class method: Test1
Class method args: ('class_directly',)
Class method kwargs: {'a1': 'class_a', 'b1': 'class_b'}

--- Called by instance ---
self:     <__main__.LoggerDecorator object at 0x7f858c34e390>
instance: <__main__.SomeClass object at 0x7f858c34f410>
owner:    <class '__main__.SomeClass'>
Class method: Test2
Class method args: ('class_by_instance',)
Class method kwargs: {'a1': 'class_a', 'b1': 'class_b'}

### Static Method ###
--- Called by directly ---
self:     <__main__.LoggerDecorator object at 0x7f858c34f0d0>
instance: None
owner:    <class '__main__.SomeClass'>
Static method: Test3
Static method args: ('static_directly',)
Static method kwargs: {'a1': 'static_a', 'b1': 'static_b'}

--- Called by instance ---
self:     <__main__.LoggerDecorator object at 0x7f858c34f0d0>
instance: <__main__.SomeClass object at 0x7f858c34f410>
owner:    <class '__main__.SomeClass'>
Static method: Test4
Static method args: ('static_by_instance',)
Static method kwargs: {'a1': 'static_a', 'b1': 'static_b'}

### Instance Method ###
self:     <__main__.LoggerDecorator object at 0x7f858c34e510>
instance: <__main__.SomeClass object at 0x7f858c34f410>
owner:    <class '__main__.SomeClass'>
Instance method: Test5
Instance method args: ('instance',)
Instance method kwargs: {'a1': 'instance_a', 'b1': 'instance_b'}

### Standalone Function ###
Standalone function: Test6
Standalone function args: ('standalone',)
Standalone function kwargs: {'a1': 'standalone_a', 'b1': 'standalone_b'}