Python: Наследование наложения декоратора?

Question

Я работаю с довольно большой базой кода ООП, и я хотел бы добавить некоторые трассировки/протоколирования. Самый простой способ сделать это - представить декоратор вокруг определенных методов на некоторых базовых классах, но, к сожалению, декораторы не наследуются.

я попробовать что-то вроде следующего:

def trace(fn): 
    def wrapper(instance, *args, **kwargs): 
     result = fn(instance, *args, **kwargs) 
     # trace logic... 
     return result 
    return wrapper 

class BaseClass(object): 
    def __init__(self, ...): 
     ... 
     self.__call__ = trace(self.__call__) # line added to end of method 

... и в то время как метод __call__является завернутые (который я могу видеть из печати информации экземпляра на консоль) в wrapper функции ISN» t выполняется, как ожидалось.

Я также кратко рассмотрел использование метакласса на основе this answer, но он мгновенно разбивает другие части системы, которые используют интроспекцию, поэтому я думаю, что это не-go.

Есть ли какой-либо другой способ я могу заставить приложение этих декораторов использовать метод классов __call__, наследующий от BaseClass?

Answer 1

Зачем метапрограммировать беспорядок в самоанализе? Возможно, вы не используете его правильно? Попробуйте это (предполагая Python2.х):

class MyMeta(type): 
    def __new__(mcl, name, bases, nmspc): 
     if "__call__" in nmspc: 
      nmspc["__call__"] = trace(nmspc["__call__"]) 
     return super(MyMeta, mcl).__new__(mcl, name, bases, nmspc) 

class BaseClass(object): 
    __metaclass__ = MyMeta 

Вы можете просто наследовать от BaseClass и __call__ будет получить завернутые автоматически.

Я не уверен, что такое самоанализ нарушит это. Если BaseClass фактически не наследует от object, а от чего-то, что реализует свою собственную мета? Но вы можете справиться и с этим делом, заставив MyMeta унаследовать от метафайла этого родителя (вместо type).

Answer 2

Вы не можете сделать это ... видеть вещи, как здесь: Python method resolution mystery

В принципе. большинство специальных функций просматриваются на уровне класса. Обезвреживание его после инициализации не будет иметь никакого эффекта.

Тем не менее, вы должны быть в состоянии сделать что-то вроде этого:

class BaseClass(object): 
    __call__ = trace(object.__call__) 
    def __init__(self, ...): 
     ... 

Теперь она обернута в класса уровне, поэтому он будет работать.

Редактировать: Это не совсем ответ. То, что вы хотите что-то вроде:

class BaseClass(object): 
    @decorator 
    __call__ = something 

class SubClass(BaseClass): 
    __call__ = something_else 

В этом случае ... это не имеет значения, что вы положили для метода BaseClass __call__, метод SubClass отменит его. Речь идет не о декораторах и не-декораторах, так как это функции (ну, действительно, атрибуты, так как на самом деле не очень много различий в python), которые наследуются. Декораторы смотрят отдельно от функции, но они на самом деле не являются - в приведенном выше, все, что делает декоратор, изменяет определение __call__ от something до decorator(something) (которое все равно должно возвращать вызываемый).

Затем, в подклассе, вы переназначаете эту функцию на нечто совершенно другое.

Вы можете использовать декоратор класса, но эти вещи, как вы заметили, имеют тенденцию нарушать самоанализ; они превращают класс в функцию, возвращающую класс. Аналогичная проблема с заводскими функциями.

Возможно, посмотрите на модуль profile? Я знаю, что есть некоторые крючки нижнего уровня, которые он использует для отслеживания вызовов функций и т. Д., Которые вы также можете использовать (хотя они мало знают о них).