Crea un pacchetto di un'applicazione Python con le sue dipendenze
Qualche tempo fa ho sviluppato un'applicazione in Python. Per impostare il contesto, si trattava di creare un eseguibile in grado di distribuire a finestra mobile-compose.yml applicando le regole aziendali. Per non riscrivere tutto, ho creato un progetto in Python poter utilizzare la biblioteca finestra mobile-composizione che è anche in Python. Una volta funzionante, la mia applicazione doveva essere compilata in un unico file. Il mio obiettivo era quello di generare un file binario che includa tutte le sue dipendenze (un po' come Golang).
Attenzione! La generazione di un file binario non ti esonera dall'installare Python sulla tua macchina. Il file binario non è un'applicazione compilata ma solo un pacchetto.
Architettura
Per prima cosa creerai una cartella foobar nel tuo progetto. Questo conterrà tutto il tuo lavoro.
|
1
2
3
4
5
6
|
progetto
|_ __main__.py
|_ foobar
|_ __init__.py
|_ __main__.py
|_cli.py
|
Se ti sei imbattuto in questo articolo è perché conosci Python almeno quanto me e quindi sai come installare le dipendenze globalmente o in modo virtualenv.
Personalmente, eseguo i miei sviluppi in a Docker-contenitore quindi installo le mie dipendenze come globali.
Ecco come installare una dipendenza.
|
1
|
$ pip installa docopt
|
Quindi puoi lavorare sul tuo file clip.py. Ecco un esempio con l'uso della libreria dottoressa.
|
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
|
# progetto/foobar/cli.py
da dottoressa importare dottoressa
versione = "1.0.0"
aiuto= « » »Foobar
Uso:
versione foobar
Opzioni:
-h --help Visualizza la guida
Foobar è un falso progetto open source sviluppato da Baptiste Donaux.
"" "
def principale():
argomenti = docopt(aiuto)
if argomenti["versione"]:
Stampa("versione foobar", versione)
|
Sarà necessario un file per avviare l'applicazione in via di sviluppo (nel mio caso __init__.py è un file vuoto ma obbligatorio).
|
1
2
3
4
5
6
|
# progetto/foobar/__main__.py
da . importare cli
if __nome__ == " __mano__ ":
cli.main()
|
Per creare un pacchetto binario, avrai bisogno di un punto di ingresso (progetto/__main__.py).
|
1
2
3
4
5
6
|
# progetto/__main__.py
da foobar importare cli
if __nome__ == " __mano__ ":
cli.main()
|
Ora puoi eseguire facilmente la tua applicazione.
|
1
2
|
$ python ./foobar/ versione
('versione foobar', '1.0.0')
|
Costruisci un binario statico
Workflow
Da un progetto pulito (senza dipendenze...), ecco i passaggi che verranno eseguiti.
- Per creare un file virtualenv e attivarlo
- Installa le dipendenze ed esci virtualenv
- Elimina i file e le cartelle presenti nel file virtualenv/lib/python2.7/sites-packages che corrispondono a una cartella seme, una cartella cache, a file compilati o file di informazioni.
- Crea una cartella per creare il file finale
- Copia le dipendenze, le fonti e il file di input nella cartella appena creata.
- Crea una cartella compressa (.cerniera lampo) del contenuto della cartella build.
- Crea il file "binario" con un'intestazione per specificare l'ambiente e aggiungi a questo file il contenuto della cartella compressa.
Hardcore
Ecco i passaggi tecnici da seguire.
|
1
2
3
4
5
6
7
8
9
10
11
12
|
$ dipendenze virtualenv
$. ./dipendenze/bin/activate
$ pip installa docopt
$ disattivare
$ rm -rf $(trova ./dependencies/lib/python2.7/site-packages -print | egrep '(/pip/)|(__pycache__)|(.(pyc|dist-info|so)$)')
$ build mkdir
$ cp -R ./dependencies/lib/python2.7/site-packages/* ./foobar ./__main__.py ./build/
$ cd ./costruire
$ zip -r ../rilascio.zip *
$ eco '#!/usr/bin/env python' > ../rilascio
$ cat ../rilascio.zip >> ../rilascio
$ chmod +x ../rilascio
|
Conclusione
Ora puoi eseguire facilmente il tuo file binario. Incorpora tutto il suo contesto.
|
1
2
|
$ ./versione di rilascio
('versione foobar', '1.0.0')
|
Questa soluzione è stata molto comoda per me per distribuire un'applicazione con un singolo file. Puoi scaricare l'archivio dei file di esempio per riprodurre la mia dimostrazione.
