Peut un Python décoratrice d'une méthode d'instance accéder à la classe?

Si vous utilisez Python 2.6 ou version ultérieure, vous pouvez utiliser une classe décorateur, peut-être quelque chose comme ceci (attention: le code non testé).

def class_decorator(cls):
   for name, method in cls.__dict__.iteritems():
        if hasattr(method, "use_class"):
            # do something with the method and class
            print name, cls
   return cls

def method_decorator(view):
    # mark the method as something that requires view's class
    view.use_class = True
    return view

@class_decorator
class ModelA(object):
    @method_decorator
    def a_method(self):
        # do some stuff
        pass

La méthode décorateur marques de la méthode que celle qui est d'intérêt par l'ajout d'un "use_class" attribut - les fonctions et les méthodes sont aussi des objets, de sorte que vous pouvez ajouter des métadonnées.

Après la classe a été créée la classe décorateur passe alors par tous les moyens et tout ce qui est nécessaire sur les méthodes qui ont été marqués.

Si vous voulez toutes les méthodes pour être affecté ensuite, vous pouvez quitter le mode décorateur et il suffit d'utiliser la classe décorateur.

Comme Marque suggère:

1. Tout le décorateur est appelé AVANT la classe est construit, donc, est inconnu du décorateur.
2. Nous pouvons tag ces méthodes et le cas échéant, de post-traiter plus tard.
3. Nous avons deux options pour le post-traitement: automatiquement à la fin de la définition de la classe ou quelque part avant l'application sera exécutée. Je préfère la 1ère option à l'aide d'une classe de base, mais vous pouvez suivre la 2ème approche.

Ce code montre comment cela peut fonctionne en utilisant automatique de post-traitement:

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__)

La sortie des rendements:

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}

Notez que dans cet exemple:

1. Nous pouvons annoter n'importe quelle fonction arbitraire de paramètres.
2. Chaque classe a ses propres méthodes exposées.
3. Nous pouvons hériter de méthodes exposées ainsi.
4. méthodes peuvent être prépondérantes comme exposant caractéristique est mise à jour.

Espère que cette aide

Le problème est que lorsque le décorateur est appelé la classe n'existe pas encore. Essayez ceci:

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()

Ce programme permettra de sortie:

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

Comme vous le voyez, vous allez devoir trouver un autre moyen de faire ce que vous voulez.

Ce flacon chic n'est de créer un cache temporaire qu'il stocke sur la méthode, puis il utilise autre chose (le fait que le Flacon va enregistrer les classes à l'aide d'un register méthode de classe) réellement encapsule la méthode.

Vous pouvez réutiliser ce modèle, cette fois à l'aide d'une métaclasse, de sorte que vous pouvez envelopper la méthode à l'importation de temps.

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

Sur la classe réelle (on pourrait faire la même à l'aide d'une métaclasse):

@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

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

C'est une vieille question, mais il est venu à travers les vénusiens. http://venusian.readthedocs.org/en/latest/

Il semble avoir la capacité de décorer méthodes et de vous donner accès à la fois la classe et de la méthode pour le faire.
Note tht appel setattr(ob, wrapped.__name__, decorated) n'est pas typique de la façon de l'utilisation des vénusiens et un peu de défaites le but.

De toute façon... l'exemple ci-dessous est complète et doit s'exécuter.

import sys
from functools import wraps
import venusian
def logged(wrapped):
def callback(scanner, name, ob):
@wraps(wrapped)
def decorated(self, *args, **kwargs):
print 'you called method', wrapped.__name__, 'on class', ob.__name__
return wrapped(self, *args, **kwargs)
print 'decorating', '%s.%s' % (ob.__name__, wrapped.__name__)
setattr(ob, wrapped.__name__, decorated)
venusian.attach(wrapped, callback)
return wrapped
class Foo(object):
@logged
def bar(self):
print 'bar'
scanner = venusian.Scanner()
scanner.scan(sys.modules[__name__])
if __name__ == '__main__':
t = Foo()
t.bar()

Fonction ne sais pas si c'est une méthode à la définition du point, lorsque le décorateur code s'exécute. Seulement quand il est accessible via la classe/identificateur de l'instance, il peut connaître sa classe/instance. Pour surmonter cette limitation, vous pouvez décorer les descripteurs de l'objet de retarder réelle de décoration de code jusqu'à ce que l'accès/heure d'appel:

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)

Cela vous permet de décorer individuels (statique|classe) méthodes:

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

Maintenant, vous pouvez utiliser le décorateur code de l'introspection...

>>> 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

...et pour le changement de comportement de la fonction:

>>> 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'}