Muss die Klasse selbst unbedingt geändert werden? Oder ist das Ziel einfach zu ersetzen, was object.method () zu einem bestimmten Zeitpunkt zur Laufzeit tut?
Ich frage, weil ich das Problem, die Klasse tatsächlich zu modifizieren, um Affen-Patch-spezifische Methodenaufrufe in meinem Framework mit getattribute und einem Runtime Decorator auf meinem Base-Vererbungsobjekt zu ändern, umgehe .
Methoden, die von einem Basisobjekt in getattribute abgerufen werden, werden in einen Runtime_Decorator eingeschlossen, der die Methode analysiert und Schlüsselwortargumente aufruft, damit Dekoratoren / Affen-Patches angewendet werden.
Auf diese Weise können Sie die Syntax object.method (monkey_patch = "mypatch"), object.method (decorator = "mydecorator") und sogar object.method (decorators = my_decorator_list) verwenden.
Dies funktioniert für jeden einzelnen Methodenaufruf (ich lasse magische Methoden weg), ohne Klassen- / Instanzattribute zu ändern, kann beliebige, sogar fremde Methoden zum Patchen verwenden und funktioniert transparent bei Unterklassen, die von Base erben (sofern sie dies nicht tun) getattribute natürlich nicht überschreiben ).
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")
Der Nachteil dieses Ansatzes ist getAttribute Haken alle Zugriff auf Attribute, so dass die Überprüfung von und potenzielle Umwickeln von Methoden auch für Attribute auf, der nicht Methoden sind + nicht die Funktion für den bestimmten Anruf in Frage gestellt werden , nutzen. Und die Verwendung von getattribute ist von Natur aus etwas kompliziert.
Die tatsächlichen Auswirkungen dieses Overheads waren meiner Erfahrung nach / für meine Zwecke vernachlässigbar, und auf meiner Maschine wird ein Dual-Core-Celeron ausgeführt. Die vorherige Umsetzung verwendete ich introspected Methoden auf Objekt init und banden die Runtime_Decorator Verfahren dann. Auf diese Weise wurde die Verwendung von getattribute überflüssig und der zuvor erwähnte Overhead reduziert. Es bricht jedoch auch Gurke (möglicherweise nicht Dill) und ist weniger dynamisch als dieser Ansatz.
Die einzigen Anwendungsfälle, auf die ich mit dieser Technik tatsächlich "in the wild" gestoßen bin, waren Timing- und Tracing-Dekorateure. Die Möglichkeiten, die sich daraus ergeben, sind jedoch äußerst vielfältig.
Wenn Sie eine bereits vorhandene Klasse haben, die nicht von einer anderen Basis geerbt werden kann (oder die Technik verwenden, die ihre eigene Klassendefinition oder die Basisklasse enthält), dann trifft das Ganze leider überhaupt nicht auf Ihr Problem zu.
Ich denke nicht, dass das Festlegen / Entfernen nicht aufrufbarer Attribute für eine Klasse zur Laufzeit unbedingt so herausfordernd ist. es sei denn, Sie möchten, dass Klassen, die von der geänderten Klasse erben, automatisch auch die Änderungen in sich selbst widerspiegeln ... Das wäre jedoch eine ganze Reihe weiterer Würmer.