Como originar a ativação do virtualenv em um script Bash

Como você cria um script Bash para ativar um Python virtualenv?

Eu tenho uma estrutura de diretório como:

.env
    bin
        activate
        ...other virtualenv files...
src
    shell.sh
    ...my code...

Posso ativar meu virtualenv por:

user@localhost:src$ . ../.env/bin/activate
(.env)user@localhost:src$

No entanto, fazer o mesmo a partir de um script Bash não faz nada:

user@localhost:src$ cat shell.sh
#!/bin/bash
. ../.env/bin/activate
user@localhost:src$ ./shell.sh
user@localhost:src$ 

O que estou fazendo de errado?

Ao fazer o código, você está carregando o script de ativação em seu shell ativo.

Quando você faz isso em um script, você o carrega naquele shell que sai quando o script termina e você volta ao shell original não ativado.

Sua melhor opção seria fazê-lo em uma função

activate () {
  . ../.env/bin/activate
}

ou um pseudônimo

alias activate=". ../.env/bin/activate"

Espero que isto ajude.

Você deve chamar o script bash usando o código-fonte.

Aqui está um exemplo:

#!/bin/bash
# Let's call this script venv.sh
source "<absolute_path_recommended_here>/.env/bin/activate"

Em seu shell, basta chamá-lo assim:

> source venv.sh

Ou como @outmind sugeriu: (observe que isso não funciona com zsh)

> . venv.sh

Pronto, a indicação do shell será colocada em seu prompt.

Embora não adicione o prefixo "(.env)" ao prompt do shell, descobri que esse script funciona conforme o esperado.

#!/bin/bash
script_dir=`dirname $0`
cd $script_dir
/bin/bash -c ". ../.env/bin/activate; exec /bin/bash -i"

por exemplo

user@localhost:~/src$ which pip
/usr/local/bin/pip
user@localhost:~/src$ which python
/usr/bin/python
user@localhost:~/src$ ./shell
user@localhost:~/src$ which pip
~/.env/bin/pip
user@localhost:~/src$ which python
~/.env/bin/python
user@localhost:~/src$ exit
exit

Sourcing executa comandos shell em seu shell atual. Quando você fornece dentro de um script como está fazendo acima, está afetando o ambiente para aquele script, mas quando o script é encerrado, as mudanças no ambiente são desfeitas, pois efetivamente saíram do escopo.

Se sua intenção é executar comandos shell no virtualenv, você pode fazer isso em seu script após obter o script de ativação. Se sua intenção é interagir com um shell dentro do virtualenv, você pode gerar um sub-shell dentro de seu script que herdaria o ambiente.

Aqui está o script que uso com frequência. Execute como$ source script_name

#!/bin/bash -x
PWD=`pwd`
/usr/local/bin/virtualenv --python=python3 venv
echo $PWD
activate () {
    . $PWD/venv/bin/activate
}

activate

Para que serve a fonte do script bash?

1. Se você pretende alternar entre vários virtualenvs ou entrar em um virtualenv rapidamente, já tentou virtualenvwrapper? Ele fornece muitos utilitários como workon venv, mkvirtualenv venve assim por diante.

2. Se você acabou de executar um script python em determinado virtualenv, use /path/to/venv/bin/python script.pypara executá-lo.

Você também pode fazer isso usando um subshell para melhor conter seu uso - aqui está um exemplo prático:

#!/bin/bash

commandA --args

# Run commandB in a subshell and collect its output in $VAR
# NOTE
#  - PATH is only modified as an example
#  - output beyond a single value may not be captured without quoting
#  - it is important to discard (or separate) virtualenv activation stdout
#    if the stdout of commandB is to be captured
#
VAR=$(
    PATH="/opt/bin/foo:$PATH"
    . /path/to/activate > /dev/null  # activate virtualenv
    commandB  # tool from /opt/bin/ which requires virtualenv
)

# Use the output from commandB later
commandC "$VAR"

Este estilo é especialmente útil quando

• uma versão diferente commandAou commandCexiste em/opt/bin
• commandBexiste no sistema PATHou é muito comum
• esses comandos falham no virtualenv
• é preciso uma variedade de ambientes virtuais diferentes

Você deve usar vários comandos em uma linha. por exemplo:

os.system(". Projects/virenv/bin/activate && python Projects/virenv/django-project/manage.py runserver")

quando você ativa seu ambiente virtual em uma linha, acho que ele esquece as outras linhas de comando e você pode evitar isso usando vários comandos em uma linha. Funcionou para mim :)

Quando eu estava aprendendo venv, criei um script para me lembrar como ativá-lo.

#!/bin/sh
# init_venv.sh
if [ -d "./bin" ];then
  echo "[info] Ctrl+d to deactivate"
  bash -c ". bin/activate; exec /usr/bin/env bash --rcfile <(echo 'PS1=\"(venv)\${PS1}\"') -i"
fi

Isso tem a vantagem de alterar o prompt.