Come posso creare una GUI in cima a un'app Python in modo che possa fare GUI o CLI?

Question

Sto cercando di scrivere un'app in Python per controllare un motore usando seriale. Tutto questo funziona in una situazione CLI ed è generalmente stabile. Ma mi chiedevo quanto fosse semplice aggiungere una GUI in cima a questa base di codice?

Presumo che ci sarà più codice, ma esiste un modo semplice per rilevare qualcosa come GTK, quindi ha applicato il codice solo quando era presente GTK?

Inoltre, la creazione di GUI in Python in generale: è meglio tenere fuori dal Codice come poche specifiche della GUI e utilizzare qualcosa come l'approccio basato su XML di GTK (usando la funzione GTK.glade.xml ())? Ci sono altri toolkit GUI che hanno un approccio simile all'approccio Glade / XML / "Explode in Code"?

Grazie per qualsiasi consiglio.

Andy

Answer 1

Esiste un modo semplice per rilevare qualcosa come GTK, quindi ha applicato il codice solo quando era presente GTK?

Innanzitutto, rompi la tua app in 3 moduli separati.

1. Il lavoro reale: foo_core.py.

2. Un modulo CLI che importa foo_core. Chiamalo foo_cli.py.

3. Un modulo GUI che importa foo_core. Chiamalo foo_gui.pyw.

Il foo_cli Il modulo sembra così.

import foo_core
import optparse

def main():
    # parse the command-line options
    # the real work is done by foo_core

if __name__ == "__main__":
   main()

Il foo_gui Il modulo può sembrare così.

 import foo_core
 import gtk # or whatever

 def main()
     # build the GUI
     # real work is done by foo_core under control of the GUI

 if __name__ == "__main__":
     main()

Questo è generalmente sufficiente. Alle persone si può fidare di decidere da sole se vogliono CLI o GUI.

Se vuoi confondere le persone, puoi scrivere un foo.py Script che fa qualcosa come il seguente.

try:
    import foo_gui
    foo_gui.main()
except ImportError:
    import foo_cli
    foo_cli.main()

Answer 2

Dipende dal tipo di interazione che desideri.

Se vuoi una GUI reale puoi usare il Dialog umile Modello per disaccoppiare le cose della GUI dalla logica del programma e utilizzare una "GUI" di testo per gestire la CLI. Questo ha anche un bell'effetto collaterale che le parti grandi della GUI diventano programmabili programmabili.

Un altro modo è assegnare sys.stdin e sys.S.Tout con i propri oggetti, che reindirizzano i tuoi programmi alla GUI (questo non funziona con le librerie non pithon). Ciò significa che hai meno possibilità di interazione nella GUI, ma molto meno sforzo di programmazione.

Answer 3

Non consiglio di fare una GUI in XML. Tutto ciò che XML fa è darti una mini lingua per descrivere un layout. Perché usare una mini lingua quando puoi avere il pieno potere di Python?

Per quanto riguarda il rilevamento di GTK, non lo suggerirei. Invece, aggiungi un argomento della riga di comando per determinare se creare una GUI o no (ad esempio: myprogram -g). Diventa quindi facile creare un collegamento desktop o un alias della riga di comando per iniziare in modalità GUI, pur essendo in grado di utilizzare lo strumento di riga di comando da qualsiasi terminale.

Tuttavia, vuoi mantenere il codice GUI separato dai bit che svolgono il vero lavoro. Dai te stesso una classe che contiene tutta la logica aziendale, quindi la GUI e la CLI accedono entrambi a questo oggetto per lavorare.

Answer 4

Bene, quello che faccio è che ho una e unica sceneggiatura bash con quanto segue:

if [ "${0}" == "mcm" ]; then
    /usr/bin/python ${inst_dir}/terminal/mcm-terminal.py ${@}
else
    /usr/bin/python ${inst_dir}/gtk/mcm-gtk.py &
fi

Quindi creo due collegamenti simil:/usr/sbin/mcm e/usr/bin/mcm-gtk

Funziona molto bene.