Come può un decoratore passare le variabili in una funzione senza cambiarne la firma?

Question

Permettetemi innanzitutto di riconoscere che quello che voglio fare può essere considerato qualsiasi cosa da sciocco a cattivo, ma voglio scoprire se posso farlo comunque in Python.

Diciamo che ho un decoratore di funzioni che accetta gli argomenti delle parole chiave che definiscono le variabili e voglio accedere a quelle variabili nella funzione di avvolgimento. Potrei fare qualcosa di simile:

def more_vars(**extras): 
    def wrapper(f): 
     @wraps(f) 
     def wrapped(*args, **kwargs): 
      return f(extras, *args, **kwargs) 
     return wrapped 
    return wrapper 

Ora posso fare qualcosa di simile:

@more_vars(a='hello', b='world') 
def test(deco_vars, x, y): 
    print(deco_vars['a'], deco_vars['b']) 
    print(x, y) 

test(1, 2) 
# Output: 
# hello world 
# 1 2 

La cosa che non mi piace di questo è che quando si utilizza questo decoratore, è necessario cambia la firma della chiamata della funzione, aggiungendo la variabile extra oltre allo schiaffo sul decoratore. Inoltre, se si guarda al l'aiuto per la funzione, si vede una variabile in più che non ci si aspetta di utilizzare quando si chiama la funzione:

help(test) 
# Output: 
# Help on function test in module __main__: 
# 
# test(deco_vars, x, y) 

Questo lo fa apparire come l'utente deve chiamare la funzione con 3 parametri, ma ovviamente non funzionerà. Quindi dovresti anche aggiungere un messaggio alla docstring che indica che il primo parametro non fa parte dell'interfaccia, è solo un dettaglio di implementazione e dovrebbe essere ignorato. Questo è un po 'schifoso, però. C'è un modo per farlo senza appendere queste variabili su qualcosa nella portata globale? Idealmente, mi piacerebbe farlo sembrare come il seguente:

@more_vars(a='hello', b='world') 
def test(x, y): 
    print(a, b) 
    print(x, y) 

test(1, 2) 
# Output: 
# hello world 
# 1 2 
help(test) 
# Output: 
# Help on function test in module __main__: 
# 
# test(x, y) 

io sono contento di un Python 3 unica soluzione se ne esiste uno.

Answer 1

Non mi piace l'idea di iniettare i locali nello spazio dei nomi. Sebbene sia probabilmente possibile, sarebbe brutto gestire le collisioni tra i nuovi locali e i nomi che sono già presenti nella funzione.

È accettabile archiviarli come attrs sull'oggetto funzione? In questo modo sono assegnati ai nomi.

from functools import wraps 

def more_vars(**extras): 
    def wrapper(f): 
     @wraps(f) 
     def wrapped(*args, **kwargs): 
      return f(*args, **kwargs) 
     for k,v in extras.items(): 
      setattr(wrapped, k, v) 
     return wrapped 
    return wrapper 

@more_vars(a='hello', b='world') 
def test(x, y): 
    print(test.a, test.b) 
    print(x, y) 

Answer 2

Si potrebbe fare questo con qualche inganno che inserisce le variabili passate per il decoratore in variabili locali della funzione:

import sys 
from functools import wraps 
from types import FunctionType 


def is_python3(): 
    return sys.version_info >= (3, 0) 


def more_vars(**extras): 
    def wrapper(f): 
     @wraps(f) 
     def wrapped(*args, **kwargs): 
      fn_globals = {} 
      fn_globals.update(globals()) 
      fn_globals.update(extras) 
      if is_python3(): 
       func_code = '__code__' 
      else: 
       func_code = 'func_code' 
      call_fn = FunctionType(getattr(f, func_code), fn_globals) 
      return call_fn(*args, **kwargs) 
     return wrapped 
    return wrapper 


@more_vars(a="hello", b="world") 
def test(x, y): 
    print("locals: {}".format(locals())) 
    print("x: {}".format(x)) 
    print("y: {}".format(y)) 
    print("a: {}".format(a)) 
    print("b: {}".format(b)) 


if __name__ == "__main__": 
    test(1, 2) 

può fare questo? Sicuro! Dovresti farlo? Probabilmente no!

(Codice disponibili here.)

Answer 3

Sembra che il tuo unico problema è che help sta mostrando la firma del grezzo test come la firma della funzione avvolto, e non si desidera.

L'unica ragione che sta accadendo è che wraps (o, meglio, update_wrapper, che wraps chiamate) esplicitamente copie questo dal wrappee per l'involucro.

È possibile decidere esattamente cosa si fa e non si desidera copiare. Se quello che vuoi fare in modo diverso è abbastanza semplice, è solo questione di filtrare le cose fuori dallo standard WRAPPER_ASSIGNMENTS e WRAPPER_UPDATES.Se vuoi cambiare altre cose, potresti dover inserire il numero update_wrapper e utilizzare la tua versione, ma lo functools è uno di quei moduli che ha un collegamento a the source proprio nella parte superiore della documentazione, perché è pensato per essere usato come esempio leggibile codice.

Nel tuo caso, può essere solo una questione di wraps(f, updated=[]), oppure si può decidere di fare qualcosa di fantasia, come l'uso inspect.signature per ottenere la firma di f, e modificarlo per rimuovere il primo parametro, e costruire un involucro in modo esplicito intorno a questo per ingannare anche il modulo inspect.