Decoratore di metodi di classe con argomenti autonomi?

Come faccio a passare un campo di classe a un decoratore su un metodo di classe come argomento? Quello che voglio fare è qualcosa di simile:

class Client(object):
    def __init__(self, url):
        self.url = url

    @check_authorization("some_attr", self.url)
    def get(self):
        do_work()

Si lamenta che il sé non esiste per il passaggio self.urlal decoratore. C'è un modo per aggirare questo?

Sì. Invece di passare l'attributo dell'istanza al momento della definizione della classe, verificalo in fase di esecuzione:

def check_authorization(f):
    def wrapper(*args):
        print args[0].url
        return f(*args)
    return wrapper

class Client(object):
    def __init__(self, url):
        self.url = url

    @check_authorization
    def get(self):
        print 'get'

>>> Client('http://www.google.com').get()
http://www.google.com
get

Il decoratore intercetta gli argomenti del metodo; il primo argomento è l'istanza, quindi ne legge l'attributo. È possibile passare il nome dell'attributo come stringa al decoratore e utilizzare getattrse non si desidera codificare il nome dell'attributo:

def check_authorization(attribute):
    def _check_authorization(f):
        def wrapper(self, *args):
            print getattr(self, attribute)
            return f(self, *args)
        return wrapper
    return _check_authorization

from re import search
from functools import wraps

def is_match(_lambda, pattern):
    def wrapper(f):
        @wraps(f)
        def wrapped(self, *f_args, **f_kwargs):
            if callable(_lambda) and search(pattern, (_lambda(self) or '')): 
                f(self, *f_args, **f_kwargs)
        return wrapped
    return wrapper

class MyTest(object):

    def __init__(self):
        self.name = 'foo'
        self.surname = 'bar'

    @is_match(lambda x: x.name, 'foo')
    @is_match(lambda x: x.surname, 'foo')
    def my_rule(self):
        print 'my_rule : ok'

    @is_match(lambda x: x.name, 'foo')
    @is_match(lambda x: x.surname, 'bar')
    def my_rule2(self):
        print 'my_rule2 : ok'



test = MyTest()
test.my_rule()
test.my_rule2()

ouput: my_rule2: ok

Un esempio più conciso potrebbe essere il seguente:

#/usr/bin/env python3
from functools import wraps

def wrapper(method):
    @wraps(method)
    def _impl(self, *method_args, **method_kwargs):
        method_output = method(self, *method_args, **method_kwargs)
        return method_output + "!"
    return _impl

class Foo:
    @wrapper
    def bar(self, word):
        return word

f = Foo()
result = f.bar("kitty")
print(result)

Che stamperà:

kitty!

Un'altra opzione sarebbe quella di abbandonare lo zucchero sintattico e decorare in __init__classe.

def countdown(number):
    def countdown_decorator(func):
        def func_wrapper():
            for index in reversed(range(1, number+1)):
                print("{}".format(index))
            func()
        return func_wrapper
    return countdown_decorator

class MySuperClass():
    def __init__(self, number):
        self.number = number
        self.do_thing = countdown(number)(self.do_thing)

    def do_thing(self):
        print('im doing stuff!')


myclass = MySuperClass(3)

myclass.do_thing()

che avrebbe stampato

3
2
1
im doing stuff!

Non puoi. Non c'è nessun selfnel corpo della classe, perché non esiste alcuna istanza. Dovresti passarlo, diciamo, a strcontenente il nome dell'attributo per cercare l'istanza, che la funzione restituita può quindi fare, o utilizzare un metodo completamente diverso.