Kann ein Python-Decorator einer Instanzmethode auf die Klasse zugreifen?

Als andere haben darauf hingewiesen, daß die Klasse wurde noch nicht erstellt an der Zeit, die der Dekorator aufgerufen wird. Jedoches ist möglich, mit dem function-Objekt wird mit dem Symbol-Parameter, dann re-schmücken die Funktion in der Metaklasse ist __new__ Methode. Sie müssen Zugriff auf die Funktion __dict__ Attribut direkt, als-zumindest für mich - func.foo = 1 führte zu einem AttributeError.

InformationsquelleAutor der Antwort Mark Visser

Das problem ist, dass wenn der Dekorator aufgerufen wird die Klasse noch nicht existiert. Versuchen Sie dies:

def loud_decorator(func):
    print("Now decorating %s" % func)
    def decorated(*args, **kwargs):
        print("Now calling %s with %s,%s" % (func, args, kwargs))
        return func(*args, **kwargs)
    return decorated

class Foo(object):
    class __metaclass__(type):
        def __new__(cls, name, bases, dict_):
            print("Creating class %s%s with attributes %s" % (name, bases, dict_))
            return type.__new__(cls, name, bases, dict_)

    @loud_decorator
    def hello(self, msg):
        print("Hello %s" % msg)

Foo().hello()

Dieses Programm erzeugt folgende Ausgabe:

Now decorating <function hello at 0xb74d35dc>
Creating class Foo(<type 'object'>,) with attributes {'__module__': '__main__', '__metaclass__': <class '__main__.__metaclass__'>, 'hello': <function decorated at 0xb74d356c>}
Now calling <function hello at 0xb74d35dc> with (<__main__.Foo object at 0xb74ea1ac>, 'World'),{}
Hello World

Wie Sie sehen, sind Sie gehen zu müssen, um herauszufinden, einen anderen Weg, das zu tun, was Sie wollen.

InformationsquelleAutor der Antwort Ants Aasma

Was Kolben-Edel tut, ist erstellen Sie einen temporären cache, speichert es auf die Methode, dann wird etwas anderes (die Tatsache, dass die Kolben zu registrieren, wird die Klassen mit einem register Klasse Methode) tatsächlich wickelt sich die Methode.

Können Sie wiederverwenden, dieses Muster, dieses mal mit einer Metaklasse, so dass Sie wickeln die Methode beim import.

def route(rule, **options):
    """A decorator that is used to define custom routes for methods in
    FlaskView subclasses. The format is exactly the same as Flask's
    `@app.route` decorator.
    """

    def decorator(f):
        # Put the rule cache on the method itself instead of globally
        if not hasattr(f, '_rule_cache') or f._rule_cache is None:
            f._rule_cache = {f.__name__: [(rule, options)]}
        elif not f.__name__ in f._rule_cache:
            f._rule_cache[f.__name__] = [(rule, options)]
        else:
            f._rule_cache[f.__name__].append((rule, options))

        return f

    return decorator

Auf die eigentliche Klasse (Sie könnte das gleiche tun mit einer Metaklasse):

@classmethod
def register(cls, app, route_base=None, subdomain=None, route_prefix=None,
             trailing_slash=None):

    for name, value in members:
        proxy = cls.make_proxy_method(name)
        route_name = cls.build_route_name(name)
        try:
            if hasattr(value, "_rule_cache") and name in value._rule_cache:
                for idx, cached_rule in enumerate(value._rule_cache[name]):
                    # wrap the method here

Quelle: https://github.com/apiguy/flask-classy/blob/master/flask_classy.py

InformationsquelleAutor der Antwort charlax

Funktion weiß nicht, ob es eine Methode bei der Bestimmung Punkt, wenn das decorator-code ausgeführt wird. Nur wenn der Zugriff über die Klasse/Instanz-id kann es wissen, seine Klasse/Instanz. Um diese Beschränkung zu überwinden, können Sie dekorieren, indem Sie descriptor Objekt um die tatsächliche Verzögerung Deko-code bis der Zugriff/Aufruf-Zeit:

class decorated(object):
    def __init__(self, func, type_=None):
        self.func = func
        self.type = type_

    def __get__(self, obj, type_=None):
        func = self.func.__get__(obj, type_)
        print('accessed %s.%s' % (type_.__name__, func.__name__))
        return self.__class__(func, type_)

    def __call__(self, *args, **kwargs):
        name = '%s.%s' % (self.type.__name__, self.func.__name__)
        print('called %s with args=%s kwargs=%s' % (name, args, kwargs))
        return self.func(*args, **kwargs)

Dies ermöglicht es Ihnen, zu schmücken einzelne (statische|Klasse) Methoden:

class Foo(object):
    @decorated
    def foo(self, a, b):
        pass

    @decorated
    @staticmethod
    def bar(a, b):
        pass

    @decorated
    @classmethod
    def baz(cls, a, b):
        pass

class Bar(Foo):
    pass

Nun können Sie die Dekorator-code für die Introspektion...

>>> Foo.foo
accessed Foo.foo
>>> Foo.bar
accessed Foo.bar
>>> Foo.baz
accessed Foo.baz
>>> Bar.foo
accessed Bar.foo
>>> Bar.bar
accessed Bar.bar
>>> Bar.baz
accessed Bar.baz

...und für wechselnde Verhalten der Funktion:

>>> Foo().foo(1, 2)
accessed Foo.foo
called Foo.foo with args=(1, 2) kwargs={}
>>> Foo.bar(1, b='bcd')
accessed Foo.bar
called Foo.bar with args=(1,) kwargs={'b': 'bcd'}
>>> Bar.baz(a='abc', b='bcd')
accessed Bar.baz
called Bar.baz with args=() kwargs={'a': 'abc', 'b': 'bcd'}

InformationsquelleAutor der Antwort aurzenligl

Wie Mark schon sagt:

1. Alle Dekorator aufgerufen wird, BEVOR die Klasse aufgebaut ist, so unbekannt ist der Dekorateur.
2. Wir können tag diese Methoden und stellen Sie die erforderlichen post-Prozess später.
3. Haben wir zwei Optionen für post-processing: automatisch am Ende der definition der Klasse, oder irgendwo, bevor die Anwendung ausgeführt wird. Ich bevorzuge die 1. option mit einer Basis-Klasse, aber Sie können Sie mit der 2. Ansatz.

Dieser code zeigt, wie dies funktioniert über die automatische post-processing:

def expose(**kw):
    "Note that using **kw you can tag the function with any parameters"
    def wrap(func):
        name = func.func_name
        assert not name.startswith('_'), "Only public methods can be exposed"

        meta = func.__meta__ = kw
        meta['exposed'] = True
        return func

    return wrap

class Exposable(object):
    "Base class to expose instance methods"
    _exposable_ = None  # Not necessary, just for pylint

    class __metaclass__(type):
        def __new__(cls, name, bases, state):
            methods = state['_exposed_'] = dict()

            # inherit bases exposed methods
            for base in bases:
                methods.update(getattr(base, '_exposed_', {}))

            for name, member in state.items():
                meta = getattr(member, '__meta__', None)
                if meta is not None:
                    print "Found", name, meta
                    methods[name] = member
            return type.__new__(cls, name, bases, state)

class Foo(Exposable):
    @expose(any='parameter will go', inside='__meta__ func attribute')
    def foo(self):
        pass

class Bar(Exposable):
    @expose(hide=True, help='the great bar function')
    def bar(self):
        pass

class Buzz(Bar):
    @expose(hello=False, msg='overriding bar function')
    def bar(self):
        pass

class Fizz(Foo):
    @expose(msg='adding a bar function')
    def bar(self):
        pass

print('-' * 20)
print("showing exposed methods")
print("Foo: %s" % Foo._exposed_)
print("Bar: %s" % Bar._exposed_)
print("Buzz: %s" % Buzz._exposed_)
print("Fizz: %s" % Fizz._exposed_)

print('-' * 20)
print('examine bar functions')
print("Bar.bar: %s" % Bar.bar.__meta__)
print("Buzz.bar: %s" % Buzz.bar.__meta__)
print("Fizz.bar: %s" % Fizz.bar.__meta__)

Die Ausgabe ergibt:

Found foo {'inside': '__meta__ func attribute', 'any': 'parameter will go', 'exposed': True}
Found bar {'hide': True, 'help': 'the great bar function', 'exposed': True}
Found bar {'msg': 'overriding bar function', 'hello': False, 'exposed': True}
Found bar {'msg': 'adding a bar function', 'exposed': True}
--------------------
showing exposed methods
Foo: {'foo': <function foo at 0x7f7da3abb398>}
Bar: {'bar': <function bar at 0x7f7da3abb140>}
Buzz: {'bar': <function bar at 0x7f7da3abb0c8>}
Fizz: {'foo': <function foo at 0x7f7da3abb398>, 'bar': <function bar at 0x7f7da3abb488>}
--------------------
examine bar functions
Bar.bar: {'hide': True, 'help': 'the great bar function', 'exposed': True}
Buzz.bar: {'msg': 'overriding bar function', 'hello': False, 'exposed': True}
Fizz.bar: {'msg': 'adding a bar function', 'exposed': True}

Beachten Sie, dass in diesem Beispiel:

1. Wir beschriften können jede beliebige Funktion mit beliebigen Parametern.
2. Jede Klasse hat seine eigenen Methoden ausgesetzt.
3. Erben ausgesetzt Methoden.
4. Methoden überschreiben werden als Freilegung feature aktualisiert wird.

Hoffe, das hilft

InformationsquelleAutor der Antwort asterio gonzalez