Чи потрібно обов'язково модифікувати сам клас? Або мета просто замінити те, що object.method () робить у певний момент під час виконання?
Я запитую, тому що я обійшов проблему фактичної модифікації класу на виклики специфічних методів виправлення мавп у моєму фреймворку за допомогою getattribute та Runtime Decorator на моєму об'єкті спадкування Base.
Методи, отримані базовим об'єктом у getattribute , обертаються у Runtime_Decorator, який аналізує аргументи ключових слів методу для застосування декораторів / мавпячих латок.
Це дозволяє використовувати синтаксис object.method (monkey_patch = "mypatch"), object.method (decorator = "mydecorator") і навіть object.method (decorators = my_decorator_list).
Це працює для будь-якого окремого виклику методу (я залишаю магічні методи), робить це, фактично не змінюючи жодних атрибутів класу / екземпляра, може використовувати довільні, навіть іноземні методи для виправлення, і буде прозоро працювати на підкасках, які успадковуються від Base (за умови, що вони не не відміняю гетатрибут, звичайно).
import trace
def monkey_patched(self, *args, **kwargs):
print self, "Tried to call a method, but it was monkey patched instead"
return "and now for something completely different"
class Base(object):
def __init__(self):
super(Base, self).__init__()
def testmethod(self):
print "%s test method" % self
def __getattribute__(self, attribute):
value = super(Base, self).__getattribute__(attribute)
if "__" not in attribute and callable(value):
value = Runtime_Decorator(value)
return value
class Runtime_Decorator(object):
def __init__(self, function):
self.function = function
def __call__(self, *args, **kwargs):
if kwargs.has_key("monkey_patch"):
module_name, patch_name = self._resolve_string(kwargs.pop("monkey_patch"))
module = self._get_module(module_name)
monkey_patch = getattr(module, patch_name)
return monkey_patch(self.function.im_self, *args, **kwargs)
if kwargs.has_key('decorator'):
decorator_type = str(kwargs['decorator'])
module_name, decorator_name = self._resolve_string(decorator_type)
decorator = self._get_decorator(decorator_name, module_name)
wrapped_function = decorator(self.function)
del kwargs['decorator']
return wrapped_function(*args, **kwargs)
elif kwargs.has_key('decorators'):
decorators = []
for item in kwargs['decorators']:
module_name, decorator_name = self._resolve_string(item)
decorator = self._get_decorator(decorator_name, module_name)
decorators.append(decorator)
wrapped_function = self.function
for item in reversed(decorators):
wrapped_function = item(wrapped_function)
del kwargs['decorators']
return wrapped_function(*args, **kwargs)
else:
return self.function(*args, **kwargs)
def _resolve_string(self, string):
try:
module_name, decorator_name = string.split(".")
except ValueError:
module_name = "__main__"
decorator_name = string
finally:
return module_name, decorator_name
def _get_module(self, module_name):
try:
module = modules[module_name]
except KeyError:
module = __import__(module_name)
finally:
return module
def _get_decorator(self, decorator_name, module_name):
module = self._get_module(module_name)
try:
decorator_wrap = getattr(module, decorator_name)
except AttributeError:
print("failed to locate decorators %s for function %s." %\
(kwargs["decorator"], self.function))
else:
return decorator_wrap
class Tracer(object):
def __init__(self, function):
self.function = function
def __call__(self, *args, **kwargs):
tracer = trace.Trace(trace=1)
tracer.runfunc(self.function, *args, **kwargs)
b = Base()
b.testmethod(monkey_patch="monkey_patched")
b.testmethod(decorator="Tracer")
Недолік цього підходу є GetAttribute гаків всього доступ до атрибутів, тому перевірка і потенціал обгортання методів відбуваються навіть для атрибутів, які не є методами + не використовуватиме цю функцію для конкретного виклику в питанні. І використання гетаттрибуту взагалі за своєю суттю дещо складне.
Фактичний вплив цих накладних витрат на мій досвід / для моїх цілей був незначним, і на моїй машині працює двоядерний Celeron. У попередній реалізації я використовував самоаналіз методів на об'єкті init і тоді прив'язував Runtime_Decorator до методів. Роблячи речі таким чином, виключається необхідність використання гетаттрибута та зменшуються накладні витрати, про які згадувалося раніше ... однак, це також розбиває соління (можливо, не кріп) і є менш динамічним, ніж цей підхід.
Єдині випадки використання, з якими я справді стикався "в дикій природі" за допомогою цієї техніки, були декоратори хронометражу та трасування. Однак можливості, які він відкриває, надзвичайно широкі.
Якщо у вас є вже існуючий клас, який неможливо змусити успадковувати з іншої бази (або використовувати техніку, яка є власним визначенням класу або в базовому класі '), то все це просто не стосується вашої проблеми, на жаль.
Я не думаю, що встановлення / видалення атрибутів, що не викликаються, для класу під час виконання обов’язково є настільки складним завданням? за винятком випадків, коли ви хочете, щоб класи, які успадковуються від модифікованого класу, також автоматично відображали зміни в них самих ... Це все одно було б черв'яками "нічого не може" за звуком цього.