Software screenshot:
Dettagli del software:
Versione: 0.1.7
Data di caricamento: 20 Feb 15
Sviluppatore: Dave Mankoff
Licenza: Libero
Popolarità: 5
FormPump è uno strumento di Python che si integra con i motori di template popolari, che consente di compilare in modo pulito in moduli HTML.
Il FormPump è una raccolta di estensioni template engine Python scritte per fare moduli HTML molto più facile lavorare con. Esso affronta direttamente i problemi legati alla compilazione valori nei vostri ingressi, l'applicazione di etichette agli ingressi e la visualizzazione dei messaggi di errore in un modo rapido. Lo fa con l'introduzione di una serie di tag / funzioni nel modello che creano forme elementi in modo intuitivo e naturale che è veloce da adattare in codice esistente.
Allo stato attuale, FormPump supporta Jinja2.
An Introductory [Jinja2] Esempio
(Gli esempi mostrati in questa README sono mostrati in Jinja2. Altre lingue templating avranno utilizzo simile.)
>>> Da formpump JinjaPump import
>>> Da Jinja2 import Ambiente
>>> Env = Ambiente (estensioni = [JinjaPump])
>>> Tpl = env.from_string ('' '
... {Forma% di classe "esempio" = "semplice-forma"%}
... {% Label 'ing'} Inserire un valore: {% ENDLABEL%}
... {Text% "INP"%}
... {% ENDFORM%}
... '' ')
>>> Tpl.render print ()
& Nbsp;>>> tpl.render print (form_vars = {'esempio': {'INP': 123}})
Nell'esempio precedente, vediamo un semplice oggetto modello viene creato che contiene una forma. Quando reso senza argomenti, si stampa semplicemente il modulo senza informazioni riempito. Quando le speciali "form_vars" dict viene fornito, riempie i valori si può trovare in forma come si genera.
Si può inoltre notare i lunghi, attributi id brutti che sono stati fissati. Questi sono necessari in modo che FormPump in grado di associare le etichette con ingressi; FormPump li costituisce come va. Siete liberi di ignorare voi stessi, semplicemente fornire il proprio ID e per gli attributi sui vostri elementi. FormPump tiene automaticamente traccia delle etichette e degli ingressi nel modello e cerca di associarli in modo intelligente uno con l'altro, ma solo quando gli ingressi non hanno id specificato, e le etichette non hanno per sta specificato.
la compilazione di moduli
FormPump riempie in forme, cercando su valori di ingresso nella variabile modello designato. Il valore predefinito è form_vars ma possono essere configurati impostando la proprietà values_dict_name dell'estensione (per Jinja2, impostare questo sull'ambiente: env.values_dict_name).
form_vars è un dizionario di dizionari. Chiavi di primo livello sono gli identificatori di contesto forma, spiegate in dettaglio più avanti. Ogni contesto modulo si riferisce a un altro dizionario, che è un semplice insieme di coppie chiave-valore che FormPump utilizza per ricercare i valori per il modulo. Le chiavi riferiscono al nome dell'ingresso. I valori sono diventati l'attributo value * per l'ingresso, convertito in unicode.
* Nota: Per gli ingressi, come un pulsante, in cui sono predeterminati valori, FormPump utilizza il valore form_vars per determinare quale pulsante di preselezione, se presente.
Contesto Forma di
FormPump permette di avere più di un modulo nel modello. Ogni modulo può avere nomi di ingresso sovrapposti. Le forme sono disambiguare da ciò FormPump chiama contesto modulo. L'esempio sopra mostra un contesto modulo impostato su "esempio" - è la stringa che segue immediatamente la parola chiave modulo. La stringa deve essere una stringa costante, non un'espressione dinamica variabile o altro, (c'è un modo per aggirare questo coperto di seguito).
Un semplice esempio dovrebbe chiarire il loro utilizzo:
& Nbsp;>>> tpl = env.from_string ('' '
... {Forma% "a"%}
... {Text% "INP"%}
... {% ENDFORM%}
... {Forma% "b"%}
... {Text% "INP"%}
... {% ENDFORM%}
... '' ')
& Nbsp;>>> tpl.render print (form_vars = {'a': {'INP': 'A'}, 'b': {'INP': 'B'}})
Contesti Forma in realtà servono a un duplice scopo. Un ostacolo comune di avere più moduli HTML su una singola pagina è che può essere difficile determinare quale forma è stata presentata se entrambe le forme hanno lo stesso attributo action. Contesti modulo può aiutare.
Con le impostazioni di default, come mostrato finora, non hanno effetto diretto sulla produzione. Tuttavia, se si imposta la proprietà form_name_key sull'estensione, FormPump inserirà automaticamente un ingresso nascosto che contiene il valore modulo contesto come il suo nome, (per Jinja2, impostare questo sull'ambiente).
& Nbsp;>>> env.form_name_key = '__'
& Nbsp;>>> tpl = env.from_string ('' '
... {Forma% "esempio"%}
... {% ENDFORM%}
... '' ')
& Nbsp;>>> tpl.render print ()
Il valore inviato può quindi essere utilizzato per identificare facilmente la forma presentata sul server.
Ma, con questa funzione porta in primo piano una complicazione in più! Diciamo che vogliamo avere una forma ripetuta più volte in una singola pagina. Con ogni ripetizione della forma, vogliamo cambiare le variabili che sono preriempita. Ad esempio, supponiamo di avere una lista di persone in una società, e si vuole essere in grado di modificare e inviare gli aggiornamenti al numero di telefono per ciascuno di essi. Pertanto si desidera lo stesso formname sottoposto al server, ma una forma contesto _different nella compilazione del modulo. Inserire la funzione form_ctx, che consente di modificare il contesto in cui FormPump cerca valori da al volo. La funzione form_ctx consente inoltre di assegnare nomi di contesto dinamico alle vostre forme, che la funzione modulo standard non fa:
& Nbsp;>>> tpl = env.from_string ('' '
...
... {Forma% "persona"%}
... {% Form_ctx "persona.% D"% persona ['id']%}
... {% Nascosto "id"%}
... {% Label "telefono"%} {{persona ['name']}} {% ENDLABEL%}
... {Text% "telefono"%}
... {% ENDFORM%}
...
... {% Per persona in persone%}
...
... {% Endfor%}
...
... '' ')
& Nbsp;>>> persone = [{'id': 1, 'name': 'Bill B.', 'telefono': '555-123-4567'},
... {'Id': 2, 'Nome': 'Chris C.', 'telefono': '555-7654-321'}]
& Nbsp;>>> tpl.render stampa (persone = persone,
... Form_vars = dict ([('persona.% D'% persona ['id'], persona) per persona in persone]))
& Nbsp;
& Nbsp;
& Nbsp;
& Nbsp;
& Nbsp;
& Nbsp;
Se si guarda al di sopra, vedrete due forme, entrambe con lo stesso nome del modulo, ma con differenti valori inseriti nei grazie alla form_ctx dinamica. La funzione form_ctx influisce su tutti gli ingressi che vengono dopo. È possibile specificare form_ctx più di un modulo, se si desidera, ognuno vanificare il precedente. Si noti, tuttavia, che la sua potrebbe diventare stilisticamente confusione.
Errori Modulo
Errori di forma di lavoro molto simile form_vars. È possibile utilizzare la funzione di errore nel modello per indicare dove gli errori dovrebbero andare, e quindi specificare form_error come un dizionario nidificato di dizionari contenenti qualsiasi e tutti i messaggi di errore vuoi mettere in. Qualsiasi errore che non trova un valore corrispondente ricerca form_error sarà lasciato fuori dal risultato finale.
>>> Tpl = env.from_string ('' '
... {Forma% "esempio"%}
... {Errore% "Campo_A"%}
... {Text% "Campo_A"%}
... {Errore% "Campo_B"%}
... {Text% "Campo_B"%}
... {% ENDFORM%}
... '' ')
>>> Print tpl.render (form_vars = {"esempio": {"Campo_A": "val A", "Campo_B": "val B"}},
... Form_errors = {"esempio": {"Campo_B": "Errore di B"}})
Si noti inoltre che tutti gli ingressi che trovano un errore avrà la classe di "errore" css aggiunto a loro.
I messaggi di errore di impostazione predefinita vengono emessi come sopra & mdash; in un div con la classe "error-messaggio". È possibile specificare il proprio messaggio di errore stile assegnando funzioni al dizionario error_renderers e quindi specificare l'attributo renderer nel modello: {error% renderer = "custom"%}. . Per impostazione predefinita, tutti gli errori utilizzano il renderer "default", che si è liberi di ignorare
Requisiti :
- Python
I commenti non trovato