Introspection per ottenere nomi decoratori su un metodo?

Question

Sto cercando di capire come ottenere i nomi di tutti i decoratori su un metodo. Posso già ottenere il nome del metodo e docstring, ma non riesco a capire come ottenere un elenco di decoratori.

Answer 1

Se è possibile cambiare il modo di chiamare i decoratori da

class Foo(object): 
    @many 
    @decorators 
    @here 
    def bar(self): 
     pass 

a

class Foo(object): 
    @register(many,decos,here) 
    def bar(self): 
     pass 

allora si potrebbe registrare i decoratori in questo modo:

def register(*decorators): 
    def register_wrapper(func): 
     for deco in decorators[::-1]: 
      func=deco(func) 
     func._decorators=decorators   
     return func 
    return register_wrapper 

Ad esempio:

def many(f): 
    def wrapper(*args,**kwds): 
     return f(*args,**kwds) 
    return wrapper 

decos = here = many 

class Foo(object): 
    @register(many,decos,here) 
    def bar(self): 
     pass 

foo=Foo() 

Qui accedere alla tupla di decoratori:

print(foo.bar._decorators) 
# (<function many at 0xb76d9d14>, <function decos at 0xb76d9d4c>, <function here at 0xb76d9d84>) 

Qui si stampa solo i nomi dei decoratori:

print([d.func_name for d in foo.bar._decorators]) 
# ['many', 'decos', 'here'] 

Answer 2

Questo a mio parere non è possibile. Un decoratore non è una sorta di attributo o metadati di un metodo. Un decoratore è una comoda sintassi per la sostituzione di una funzione con il risultato di una chiamata di funzione. Vedi http://docs.python.org/whatsnew/2.4.html?highlight=decorators#pep-318-decorators-for-functions-and-methods per maggiori dettagli.

Answer 3

E 'impossibile fare in modo generale, perché

@foo 
def bar ... 

è esattamente lo stesso di

def bar ... 
bar = foo (bar) 

Si può fare in alcuni casi particolari, come probabilmente @staticmethod analizzando oggetti funzione , ma non meglio di così.

Answer 4

Questo perché i decoratori sono "zucchero sintattico". Diciamo che avete il seguente decoratore:

def MyDecorator(func): 
    def transformed(*args): 
     print "Calling func " + func.__name__ 
     func() 
    return transformed 

E lo si applica ad una funzione:

@MyDecorator 
def thisFunction(): 
    print "Hello!" 

Ciò equivale a:

thisFunction = MyDecorator(thisFunction) 

Si potrebbe incorporare una "storia" nella funzione oggetto, forse, se hai il controllo dei decoratori. Scommetto che c'è un altro modo intelligente per farlo (forse per incarico preponderante), ma sfortunatamente non sono molto esperto in Python. :(

Answer 5

Come Faisal notes, si potrebbe avere i decoratori si attaccano i metadati alla funzione, ma a mia conoscenza non è fatto automaticamente.

Answer 6

Non è possibile, per definizione.Decorator:

@dec 
def foo(): 
    return 1 

è solo scorciatoia per:

def foo_internal() 
    return 1 
foo = dec(foo_internal) 

Si noti che, decoratore dec è semplicemente un po 'di qualcosa di callable ritorno (funzione, forse qualche altro oggetto callable). Non so nemmeno se foo ha nulla a che fare con la definizione decorato, per esempio:

def dec(f): 
    def not_foo(): 
     return 0 
    return not_foo 

Se avete bisogno di mettere un po 'ulteriori informazioni sui metodi, classi ecc .--- come ad esempio attributi in .NET --- imposta semplicemente alcuni attributi su di essi.

def foo() 
    return 1 
foo.decorated = True 

Oppure implementare decoratori che impostano tali attributi, se è davvero utile per la leggibilità.

def dec(f): 
    f.decorated = True 
    return f 

---

Bene. Python è open-source. Puoi sempre estendere l'interprete Python per tracciare i decoratori applicati all'oggetto. Poiché (come mostrato sopra) l'oggetto restituito dal decoratore non deve essere correlato in alcun modo all'oggetto decorato, questa implementazione dovrebbe memorizzare le informazioni dall'oggetto decorato prima di applicare il decoratore, applicare il decoratore, sostituire le informazioni del decoratore sull'oggetto restituito e aggiungere informazioni sull'ultimo decoratore.

Può essere fatto. Ma non sono sicuro che sia davvero utile. E aggiunge un po 'di spese generali ad ogni decoratore. Quindi non mi aspetto un tale meccanismo nel mainstream Python, a meno che non offra altri vantaggi, come la semplificazione dell'implementazione di decoratori, ecc.

Answer 7

Non si può, ma peggio ancora, esistono librerie per nascondere il fatto che si ha decorato una funzione per cominciare. Vedere Functools o la libreria decoratore (@decorator se potessi trovarlo) per ulteriori informazioni.

Answer 8

Sono sorpreso che questa domanda è così vecchio e nessuno ha avuto il tempo di aggiungere il modo attuale introspettiva per fare questo, ecco che è:

Il codice che si desidera ispezionare ...

def template(func): 
    def wrapper(*args, **kwargs): 
     return func(*args, **kwargs) 
    return wrapper 

baz = template 
che = template 

class Foo(object): 
    @baz 
    @che 
    def bar(self): 
     pass 

Ora è possibile controllare quanto sopra Foo classe con qualcosa di simile ...

import ast 
import inspect 

def get_decorators(cls): 
    target = cls 
    decorators = {} 

    def visit_FunctionDef(node): 
     decorators[node.name] = [] 
     for n in node.decorator_list: 
      name = '' 
      if isinstance(n, ast.Call): 
       name = n.func.attr if isinstance(n.func, ast.Attribute) else n.func.id 
      else: 
       name = n.attr if isinstance(n, ast.Attribute) else n.id 

      decorators[node.name].append(name) 

    node_iter = ast.NodeVisitor() 
    node_iter.visit_FunctionDef = visit_FunctionDef 
    node_iter.visit(ast.parse(inspect.getsource(target))) 
    return decorators 

print get_decorators(Foo) 

questo dovrebbe stampare qualcosa di simile ...

{'bar': ['baz', 'che']} 

o almeno lo ha fatto quando ho provato questo con Python 2.7.9 reale veloce :)