Quero ativar uma instância virtualenv de um script Python.
Eu sei que é muito fácil de fazer, mas todos os exemplos que vi usam para executar comandos dentro do env e, em seguida, fecham o subprocesso.
Eu simplesmente quero ativar o virtualenv e retornar ao shell, da mesma forma que bin / activate faz.
Algo assim:
$me: my-script.py -d env-name
$(env-name)me:
Isso é possível?
Relevante:
Respostas:
Se você deseja executar um subprocesso Python no virtualenv, pode fazer isso executando o script usando o interpretador Python que reside dentro do diretório / bin / do 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])
No entanto, se você deseja ativar o virtualenv no interpretador Python atual em vez de um subprocesso, pode usar o 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_filede um local arbitrário ou ele precisa estar no virtualenvdiretório?
script_filenão precisa estar no diretório virtualenv, pode estar em qualquer lugar.
A solução mais simples para executar seu script sob o intérprete do virtualenv é substituir a linha shebang padrão pelo caminho para o intérprete do virtualenv, como no início do script:
#!/path/to/project/venv/bin/python
Torne o script executável:
chmod u+x script.py
Execute o script:
./script.py
Voila!
Acontece que, sim, o problema não é simples, mas a solução é.
Primeiro, tive que criar um script de shell para envolver o comando "source". Dito isto, usei o "." em vez disso, porque li que é melhor usá-lo do que a fonte para scripts Bash.
#!/bin/bash
. /path/to/env/bin/activate
Então, a partir do meu script Python, posso simplesmente fazer isso:
import os
os.system('/bin/bash --rcfile /path/to/myscript.sh')
Todo o truque está dentro do --rcfileargumento.
Quando o interpretador Python sai, ele deixa o shell atual no ambiente ativado.
Ganhar!
os.system('/bin/bash --rcfile path/to/env/activate') você sabe, quando uma instância do bash é iniciada, ele recebe .bashrc como um argumento para o --rcfile. Portanto, apenas especifique que o rcfile é o seu arquivo de ativação ... Não?
cat ~/.bashrc env/bin/activate > env/bin/activate2 && /bin/bash --rcfile env/bin/activate2
Para executar outro ambiente Python de acordo com a documentação oficial da Virtualenv , na linha de comando você pode especificar o caminho completo para o binário executável do Python, apenas isso (não há necessidade de ativar o virtualenv antes):
/path/to/virtualenv/bin/python
O mesmo se aplica se você deseja invocar um script da linha de comando com seu virtualenv. Você não precisa ativá-lo antes:
me$ /path/to/virtualenv/bin/python myscript.py
O mesmo para um ambiente Windows (seja da linha de comando ou de um script):
> \path\to\env\Scripts\python.exe myscript.py
Apenas uma solução simples que funciona para mim. Não sei por que você precisa do script Bash, que basicamente executa uma etapa inútil (estou errado?)
import os
os.system('/bin/bash --rcfile flask/bin/activate')
O que basicamente faz o que você precisa:
[hellsing@silence Foundation]$ python2.7 pythonvenv.py
(flask)[hellsing@silence Foundation]$
Então, em vez de desativar o ambiente virtual, basta Ctrl+ Dou sair. Essa é uma solução possível ou não é o que você queria?
O ambiente do processo filho é perdido no momento em que deixa de existir, e mover o conteúdo do ambiente de lá para o pai é um tanto complicado.
Você provavelmente precisa gerar um script de shell (você pode gerar um dinamicamente em / tmp) que produzirá as variáveis de ambiente virtualenv em um arquivo, que você então lê no processo Python pai e coloca em os.environ.
Ou você simplesmente analisa o script de ativação usando para a linha em aberto ("bin / activate"), extrai manualmente as coisas e coloca em os.environ. É complicado, mas não impossível.
A melhor resposta só funciona para Python 2.x
Para Python 3.x, use este:
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))
Referência: o que é uma alternativa para execfile no Python 3?
Você deve criar todos os seus virtualenvs em uma pasta, como virt.
Supondo que o nome da pasta virtualenv seja virt, se não, altere-o
cd
mkdir custom
Copie as linhas abaixo ...
#!/usr/bin/env bash
ENV_PATH="$HOME/virt/$1/bin/activate"
bash --rcfile $ENV_PATH -i
Crie um arquivo de script de shell e cole as linhas acima ...
touch custom/vhelper
nano custom/vhelper
Conceda permissão executável para seu arquivo:
sudo chmod +x custom/vhelper
Agora exporte o caminho da pasta personalizada para que você possa encontrá-lo na linha de comando clicando na guia ...
exportar PATH = $ PATH: "$ HOME / custom"
Agora você pode usá-lo de qualquer lugar, basta digitar o comando abaixo ...
vhelper YOUR_VIRTUAL_ENV_FOLDER_NAME
Suponha que seja abc então ...
vhelper abc
subprocess.Popen([venv_python_file, script_file]):?