XHPy

XHPy estende sintassi Python in modo che i frammenti XML diventano espressioni Python valide.
Vantaggi
& Nbsp; * Semplicità: scrivere la logica dell'interfaccia utente in modo semplice, sintassi espressiva senza la necessità di modelli esterni o lingue templating.
& Nbsp; * Flessibilità: espressioni uso Python liberamente all'interno dei tag XHPy, e viceversa.
& Nbsp; * Sicurezza: beneficiare di escape automatico del testo all'interno dei tag XHPy.
& Nbsp; * Riusabilità: costruire componenti riutilizzabili per sottoclassi: x: Elemento.
Un esempio
In bar.py:
da xhpy.init import register_xhpy_module
register_xhpy_module ('foo')
import foo
In foo.py:
da xhpy.pylib import *
Classe: ui: foo (: x: Elemento):
& Nbsp; attributo lista bar
& Nbsp; categoria flusso%
& Nbsp; def render (self):
& Nbsp; a =

& Nbsp; per B in self.getAttribute ('bar'):
& Nbsp; a.appendChild (
• {b}
)
& Nbsp; restituire un
Stampa

Ora possiamo eseguire bar.py come un normale script Python:
$ Python bar.py

• 0
• 1
• 2

Congratulazioni! Hai appena scritto la tua prima snippet di XHPy.
Sintassi
XHPy aggiunge qualche nuova sintassi di Python. Linea per linea del tempo di riproduzione!
da xhpy.init import register_xhpy_module
Questo inizializza XHPy e permette di registrare i moduli per essere interpretati come XHPy.
register_xhpy_module ('foo')
Ora il modulo foo in foo.py verrà interpretato come XHPy se importati. Se foo fosse un pacchetto, tutti i suoi moduli sarebbe anche essere registrati; questo è utile per registrare le librerie UI.
import foo
Per utilizzare effettivamente XHPy, tuttavia, probabilmente si vuole la biblioteca di base:
da xhpy.pylib import *
Ora si ha accesso a tutti gli elementi HTML 4.0 standard, l': x: classe base elemento (questo è quello che si costruisce componenti personalizzati in cima!), E alcune utility.
Classe: ui: foo (: x: Elemento):
Conoscere nuovi componenti è semplice: basta sottoclasse: x: Elemento. Per la classe componente da registrare, si deve iniziare con: - la distingue chiaramente i componenti da classi Python ordinari.
attributo lista bar
Si tratta di una dichiarazione di attributo, il che significa che: ui: foo consente attributi bar tag. Notare il

in seguito - come XHP, XHPy utilizza la sintassi attributo XML.
categoria flusso%
Questa è una dichiarazione categoria -: ui: foo fa parte della categoria di flusso%. Le categorie sono utili soprattutto come un modo di identificare gli elementi che sono simili senza usare l'ereditarietà; per esempio, il tag in pylib.html trovi
bambini (PCDATA |% flusso) *
indicando che i suoi figli devono o contengono testo o essere di categoria flusso%. (Così possiamo mettere ! All'interno di )
def render (self):
Quando si stampa un: x: elemento (o chiamare str su di esso), il render () viene richiamato il metodo; questo è dove mettere la logica dell'interfaccia utente.
a =

per B in self.getAttribute ('bar'):
& Nbsp; a.appendChild (
• {b}
)
restituire un
Qui, è un wrapper sottile intorno
che permette di costruire una lista non ordinata da una lista Python. Elementi HTML standard come
e
• sono resi automaticamente - salvo che, in XHPy, è possibile utilizzare le espressioni Python all'interno dei tag, in modo che
  {B}
  è sostituito dal valore di b. Si noti l'uso di getAttribute () e appendChild ():
  self.getAttribute ('bar')
  recupera il valore della barra degli attributi (in questo caso, gamma (3)), mentre
  a.appendChild (
• {b}
)
aggiunge
• {b}
come figlio di un =
.
XHPy si basa in gran parte fuori XHP; per maggiori dettagli su questi ultimi, vedi il `XHP wiki & Nbsp; * non ci sono punti e virgola;
& Nbsp; * nomi di classe XHPy possono essere utilizzati classi Python ovunque ordinarie può;
& Nbsp; * tag XHPy ignorano gli spazi interni, ma deve obbedire esternamente indentazione e la linea di continuazione regole.
Altro su quest'ultimo punto:
def foo (href):
& Nbsp; ritorno
bar def (href):
& Nbsp; ritorno
& Nbsp;
sono validi, mentre
def foo (href):
& Nbsp; ritorno
& Nbsp;
& Nbsp;
non è, in quanto introduce un dedent supplementare dopo .
Come funziona
Quando tu
import xhpy.init
XHPy installa un gancio di importazione. Questo gancio trappole istruzioni import successive, loro che attraversa un preprocessore che analizza un superset di Python. Questo preprocessore traduce tag XHPy e nomi di classe per valida Python, poi esegue il codice tradotto in un contesto di modulo.
Questo è simile a come funziona XHP, tranne:
& Nbsp; * con, ad esempio, pythonenv, si può sempre usare XHPy anche senza l'accesso alle directory di installazione del pacchetto Python a livello di sistema;
. & Nbsp; * di default, Python compila bytecode .pyc file dai moduli, in modo che il pre-elaborazione deve solo essere fatto una volta quando un modulo viene prima importata

Requisiti :

• Python
20 Feb 15