Voglio attivare un'istanza virtualenv da uno script Python.
So che è abbastanza facile da fare, ma tutti gli esempi che ho visto lo usano per eseguire comandi all'interno di env e quindi chiudere il sottoprocesso.
Voglio semplicemente attivare virtualenv e tornare alla shell, nello stesso modo in cui bin / attivare fa.
Qualcosa come questo:
$me: my-script.py -d env-name
$(env-name)me:
È possibile?
Pertinente:
Risposte:
Se vuoi eseguire un sottoprocesso Python sotto virtualenv, puoi farlo eseguendo lo script usando l'interprete Python che risiede nella directory / bin / di virtualenv:
import subprocess
# Path to a Python interpreter that runs any Python script
# under the virtualenv /path/to/virtualenv/
python_bin = "/path/to/virtualenv/bin/python"
# Path to the script that must run under the virtualenv
script_file = "must/run/under/virtualenv/script.py"
subprocess.Popen([python_bin, script_file])
Tuttavia, se vuoi attivare il virtualenv sotto l'attuale interprete Python invece di un sottoprocesso, puoi usare lo activate_this.pyscript:
# Doing execfile() on this file will alter the current interpreter's
# environment so you can import libraries in the virtualenv
activate_this_file = "/path/to/virtualenv/bin/activate_this.py"
execfile(activate_this_file, dict(__file__=activate_this_file))
script_fileda una posizione arbitraria, o deve essere nella virtualenvdirectory?
script_filenon deve essere nella directory virtualenv, può essere ovunque.
La soluzione più semplice per eseguire lo script con l'interprete di virtualenv è sostituire la riga shebang predefinita con il percorso dell'interprete di virtualenv in questo modo all'inizio dello script:
#!/path/to/project/venv/bin/python
Rendi eseguibile lo script:
chmod u+x script.py
Esegui lo script:
./script.py
Ecco!
Si scopre che, sì, il problema non è semplice, ma la soluzione lo è.
Per prima cosa ho dovuto creare uno script di shell per racchiudere il comando "source". Detto questo ho usato il "." invece, perché ho letto che è meglio usarlo rispetto ai sorgenti per gli script Bash.
#!/bin/bash
. /path/to/env/bin/activate
Quindi dal mio script Python posso semplicemente fare questo:
import os
os.system('/bin/bash --rcfile /path/to/myscript.sh')
L'intero trucco sta --rcfilenell'argomento.
Quando l'interprete Python esce lascia la shell corrente nell'ambiente attivato.
Vincere!
os.system('/bin/bash --rcfile path/to/env/activate') sai, quando viene avviata un'istanza di bash, prende .bashrc come argomento per il --rcfile. Quindi specifica che rcfile è il tuo file di attivazione ... No?
cat ~/.bashrc env/bin/activate > env/bin/activate2 && /bin/bash --rcfile env/bin/activate2
Per eseguire un altro ambiente Python secondo la documentazione ufficiale di Virtualenv , nella riga di comando è possibile specificare il percorso completo del binario eseguibile Python, solo quello (non è necessario attivare il virtualenv prima):
/path/to/virtualenv/bin/python
Lo stesso vale se vuoi invocare uno script dalla riga di comando con il tuo virtualenv. Non è necessario attivarlo prima:
me$ /path/to/virtualenv/bin/python myscript.py
Lo stesso per un ambiente Windows (sia dalla riga di comando che da uno script):
> \path\to\env\Scripts\python.exe myscript.py
Solo una semplice soluzione che funziona per me. Non so perché hai bisogno dello script Bash che fondamentalmente fa un passaggio inutile (mi sbaglio?)
import os
os.system('/bin/bash --rcfile flask/bin/activate')
Che fondamentalmente fa quello che ti serve:
[hellsing@silence Foundation]$ python2.7 pythonvenv.py
(flask)[hellsing@silence Foundation]$
Quindi invece di disattivare l'ambiente virtuale, basta Ctrl+ Do uscire. È una possibile soluzione o non è quello che volevi?
L'ambiente del processo figlio si perde nel momento in cui cessa di esistere e spostare il contenuto dell'ambiente da lì al genitore è alquanto complicato.
Probabilmente è necessario generare uno script di shell (è possibile generarne uno dinamicamente in / tmp) che genererà le variabili di ambiente virtualenv in un file, che verrà quindi letto nel processo Python genitore e inserito in os.environ.
Oppure puoi semplicemente analizzare lo script di attivazione in uso per la riga in open ("bin / activation"), estrarre manualmente le cose e mettere os.environ. È complicato, ma non impossibile.
La risposta migliore funziona solo per Python 2.x
Per Python 3.x, usa questo:
activate_this_file = "/path/to/virtualenv/bin/activate_this.py"
exec(compile(open(activate_this_file, "rb").read(), activate_this_file, 'exec'), dict(__file__=activate_this_file))
Riferimento: qual è un'alternativa a execfile in Python 3?
Dovresti creare tutti i tuoi messaggi di posta virtualenvelettronica in una cartella, ad esempio virt.
Supponendo che il nome della tua cartella virtualenv sia virt, se non cambiarlo
cd
mkdir custom
Copia le righe seguenti ...
#!/usr/bin/env bash
ENV_PATH="$HOME/virt/$1/bin/activate"
bash --rcfile $ENV_PATH -i
Crea un file script di shell e incolla le righe sopra ...
touch custom/vhelper
nano custom/vhelper
Concedi l'autorizzazione eseguibile al tuo file:
sudo chmod +x custom/vhelper
Ora esporta il percorso della cartella personalizzato in modo da poterlo trovare sulla riga di comando facendo clic sulla scheda ...
export PATH = $ PATH: "$ HOME / custom"
Ora puoi usarlo da qualsiasi luogo semplicemente digitando il comando seguente ...
vhelper YOUR_VIRTUAL_ENV_FOLDER_NAME
Supponiamo che sia abc allora ...
vhelper abc
subprocess.Popen([venv_python_file, script_file]):?