Ative um virtualenv com um script Python

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:

virtualenv ›Invocar um env a partir de um script

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))

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!

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