Qual è un buon modo per fornire ulteriori decorazioni/metadati per i parametri della funzione Python?

Question

Stiamo prendendo in considerazione l'utilizzo di Python (IronPython, ma non credo sia pertinente) per fornire una sorta di supporto "macro" per un'altra applicazione, che controlla un pezzo di equipaggiamento.

Vorremmo scrivere funzioni abbastanza semplici in Python, che richiedono alcuni argomenti: si tratta di cose come orari, temperature e posizioni. Diverse funzioni prenderebbero argomenti diversi e l'applicazione principale conterrebbe un'interfaccia utente (qualcosa come una griglia di proprietà) che consente agli utenti di fornire valori per gli argomenti della funzione Python.

Quindi, ad esempio, la funzione 1 potrebbe richiedere un tempo e una temperatura e la funzione2 potrebbe assumere una posizione e un paio di volte.

Ci piacerebbe essere in grado di creare dinamicamente l'interfaccia utente dal codice Python. Le cose facili da fare sono trovare un elenco di funzioni in un modulo e (usando inspect.getargspec) per ottenere un elenco di argomenti per ciascuna funzione.

Tuttavia, solo una lista di nomi di argomenti non è veramente sufficiente - idealmente vorremmo essere in grado di includere ulteriori informazioni su ciascun argomento - ad esempio, è "tipo" (tipo di alto livello - tempo, temperatura , ecc., non il tipo a livello di lingua), e forse un "nome descrittivo" o una descrizione.

Quindi, la domanda è, quali sono i buoni modi "pitonici" di aggiungere questo tipo di informazioni a una funzione.

Le due possibilità che ho pensato sono:

• Utilizzare una rigida convenzione di denominazione per gli argomenti, e quindi dedurre roba su di loro dai loro nomi (recuperati utilizzando getargspec)

• Invent nostra docstring meta-language (potrebbe essere poco più di CSV) e usare la docstring per i nostri metadati.

Perché Python sembra piuttosto popolare per la costruzione di scripting in grandi applicazioni, immagino che questo è un problema risolto con alcune convenzioni comuni, ma non sono stato in grado di trovarli.

Answer 1

decoratori sono un buon modo per aggiungere metadati alle funzioni. Aggiungere uno che prende un elenco dei tipi di aggiungere a una proprietà .params o qualcosa del genere:

def takes(*args): 
    def _takes(fcn): 
     fcn.params = args 
     return fcn 
    return _takes 

@takes("time", "temp", "time") 
def do_stuff(start_time, average_temp, stop_time): 
    pass 

Answer 2

vorrei utilizzare un qualche tipo di decoratore:

class TypeProtector(object): 
    def __init__(self, fun, types): 
     self.fun, self.types = fun, types 
    def __call__(self, *args, **kwargs) 
     # validate args with self.types 
     pass 
     # run function 
     return fun(*args, **kwargs) 

def types(*args): 
    def decorator(fun): 
     # validate args count with fun parameters count 
     pass 
     # return covered function 
     return TypeProtector(fun, args) 
    return decorator 

@types(Time, Temperature) 
def myfunction(foo, bar): 
    pass 

myfunction('21:21', '32C') 
print myfunction.types 

Answer 3

Il modo 'divinatorio' per fare questo sono function annotations.

def DoSomething(critical_temp: "temperature", time: "time") 
    pass 

Answer 4

per Python 2.x, mi piace usare la docstring

def my_func(txt): 
    """{ 
    "name": "Justin", 
    "age" :15 
    }""" 
    pass 

e può essere automaticamente assegnare all'oggetto funzione con questo frammento

for f in globals(): 
    if not hasattr(globals()[f], '__call__'): 
     continue 
    try: 
     meta = json.loads(globals()[f].__doc__) 
    except: 
     continue 
    for k, v in meta.items(): 
     setattr(globals()[f], k, v)