Qual é a maneira correta de instalar pip, virtualenv e distribuir para Python?

Pergunta curta

• O que é a maneira correta de instalar pip, virtualenve distribute?

fundo

Na minha resposta à pergunta 4314376 do SO , eu recomendei o uso ez_setuppara que você pudesse instalar pipe da virtualenvseguinte maneira:

curl -O http://peak.telecommunity.com/dist/ez_setup.py
sudo python ez_setup.py
sudo easy_install pip
sudo pip install virtualenv

Originalmente, retirei essas instruções da postagem do blog de Jesse Noller. Então, você deseja usar o Python no Mac? . Eu gosto da idéia de manter um diretório global de pacotes de sites limpo, então os únicos outros pacotes que eu instalo são virtualenvwrappere distribute. (Eu adicionei recentemente distributeà minha caixa de ferramentas por causa deste anúncio de serviço público do Python . Para instalar esses dois pacotes, usei:

sudo pip install virtualenvwrapper
curl -O http://python-distribute.org/distribute_setup.py
sudo python distribute_setup.py

Não há mais ferramentas de instalação e easy_install

Para realmente seguir esse anúncio de serviço público do Python , em uma nova instalação do Python, eu faria o seguinte:

curl -O http://python-distribute.org/distribute_setup.py
sudo python distribute_setup.py
sudo easy_install pip
sudo pip install virtualenv
sudo pip install virtualenvwrapper

Repreensão de Glyph

Em um comentário à minha resposta à pergunta 4314376 do SO, o usuário do SO Glyph declarou:

NÃO. NUNCA faça sudo python setup.py installo que for. Escreva um ~ / .pydistutils.cfg que coloque sua instalação do pip em ~ / .local ou algo assim. Especialmente os arquivos nomeados ez_setup.pytendem a absorver versões mais recentes de coisas como setuptools e easy_install, que podem quebrar outras coisas no sistema operacional.

Voltar à pergunta curta

Portanto, a resposta de Glyph me leva à minha pergunta original:

• O que é a maneira correta de instalar pip, virtualenve distribute?

Você pode fazer isso sem instalar nada no próprio python.

Você não precisa de sudo ou privilégios.

Você não precisa editar nenhum arquivo.

Instale o virtualenv em um ambiente virtual de inicialização. Use o ambiente virtual para criar mais. Como o virtualenv é enviado com pip e distribuir, você obtém tudo de uma instalação.

1. Faça o download do virtualenv:
   • http://pypi.python.org/pypi/virtualenv
   • https://pypi.python.org/packages/source/v/virtualenv/virtualenv-12.0.7.tar.gz (ou qualquer que seja a versão mais recente!)
2. Descompacte o tarball de origem
3. Use o tarball descompactado para criar um ambiente virtual limpo. Este ambiente virtual será usado para "inicializar" outros. Todos os seus ambientes virtuais automaticamente contêm pip e distribuem.
4. Usando o pip, instale o virtualenv nesse ambiente de inicialização.
5. Use esse ambiente de inicialização para criar mais!

Aqui está um exemplo no bash:

# Select current version of virtualenv:
VERSION=12.0.7
# Name your first "bootstrap" environment:
INITIAL_ENV=bootstrap
# Set to whatever python interpreter you want for your first environment:
PYTHON=$(which python)
URL_BASE=https://pypi.python.org/packages/source/v/virtualenv

# --- Real work starts here ---
curl -O $URL_BASE/virtualenv-$VERSION.tar.gz
tar xzf virtualenv-$VERSION.tar.gz
# Create the first "bootstrap" environment.
$PYTHON virtualenv-$VERSION/virtualenv.py $INITIAL_ENV
# Don't need this anymore.
rm -rf virtualenv-$VERSION
# Install virtualenv into the environment.
$INITIAL_ENV/bin/pip install virtualenv-$VERSION.tar.gz

Agora você pode usar o ambiente "bootstrap" para criar mais:

# Create a second environment from the first:
$INITIAL_ENV/bin/virtualenv py-env1
# Create more:
$INITIAL_ENV/bin/virtualenv py-env2

Enlouquecer!

Nota

Isso pressupõe que você não está usando uma versão muito antiga do virtualenv. Versões antigas exigiam os sinalizadores --no-site-packges(e dependendo da versão do Python --distribute). Agora você pode criar seu ambiente de inicialização com apenas python virtualenv.py path-to-bootstrapou python3 virtualenv.py path-to-bootstrap.

Eu acho que Glyph significa fazer algo assim:

1. Crie um diretório ~/.local, se ele ainda não existir.
2. No seu ~/.bashrc, verifique se ~/.local/binestá em PATHe que ~/.localestá em PYTHONPATH.

3. Crie um arquivo ~/.pydistutils.cfgque contenha

   [install]
   prefix=~/.local

   É um arquivo no formato ConfigParser padrão.

4. Baixe distribute_setup.py e execute python distribute_setup.py(não sudo). Se ele reclamar de um site-packagesdiretório inexistente , crie-o manualmente:

   mkdir -p ~ / .local / lib / python2.7 / site-packages /

5. Execute which easy_installpara verificar se é proveniente de~/.local/bin

6. Corre pip install virtualenv
7. Corre pip install virtualenvwrapper
8. Crie uma pasta virtual contendo uma pasta, digamos ~/.virtualenvs

9. Em ~/.bashrcadição

   export WORKON_HOME
   source ~/.local/bin/virtualenvwrapper.sh

É isso aí, não há uso de sudotodo e seu ambiente Python está ~/.localcompletamente separado do Python do sistema operacional. Isenção de responsabilidade: Não tenho certeza da compatibilidade virtualenvwrapperdeste cenário - não pude testá-lo no meu sistema :-)

Se você seguir as etapas recomendadas em vários tutoriais que eu vinculei nesta resposta , poderá obter o efeito desejado sem as etapas "manuais" um tanto complicadas das respostas de Walker e Vinay. Se você estiver no Ubuntu:

sudo apt-get install python-pip python-dev

O equivalente é alcançado no OS X usando o homebrew para instalar o python (mais detalhes aqui ).

brew install python

Com o pipinstalado, você pode usá-lo para obter os pacotes restantes (você pode omitir sudono OS X, ao usar a instalação python local).

sudo pip install virtualenvwrapper

(esses são os únicos pacotes que você precisa instalar globalmente e duvido que entrem em conflito com qualquer nível de sistema do sistema operacional. Se você quiser ser super seguro, poderá manter as versões da distribuição sudo apt-get install virtualenvwrapper)

Nota: no Ubuntu 14.04, recebo alguns erros com a instalação do pip , então uso pip3 install virtualenv virtualenvwrappere adiciono VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3ao meu .bashrc/.zshrcarquivo.

Você então anexa ao seu .bashrcarquivo

export WORKON_HOME
source /usr/local/bin/virtualenvwrapper.sh

e fonte

. ~/.bashrc

É basicamente isso. Agora, a única decisão é se você deseja criar um virtualenv para incluir pacotes no nível do sistema

mkvirtualenv --system-site-packages foo

onde os pacotes de sistema existentes não precisam ser reinstalados, eles são vinculados às versões do interpretador do sistema. Nota: você ainda pode instalar novos pacotes e atualizar os pacotes incluídos do sistema existentes sem o sudo - eu testei e funciona sem interrupções do interpretador do sistema.

kermit@hocus-pocus:~$ sudo apt-get install python-pandas
kermit@hocus-pocus:~$ mkvirtualenv --system-site-packages s
(s)kermit@hocus-pocus:~$ pip install --upgrade pandas
(s)kermit@hocus-pocus:~$ python -c "import pandas; print(pandas.__version__)"
0.10.1
(s)kermit@hocus-pocus:~$ deactivate
kermit@hocus-pocus:~$ python -c "import pandas; print(pandas.__version__)"
0.8.0

A alternativa, se você deseja um ambiente completamente separado, é

mkvirtualenv --no-site-packages bar

ou considerando que essa é a opção padrão, basta

mkvirtualenv bar

O resultado é que você tem um novo virtualenv, onde você pode instalar seus pacotes favoritos de maneira livre e sem sujeira

pip install flask

Python 3.4 em diante

O Python 3.3 adiciona o módulo venv e o Python 3.4 adiciona o módulo surepip . Isso torna o pip de bootstrapping tão fácil quanto:

python -m surepip

Talvez precedido por uma chamada venvpara fazê-lo dentro de um ambiente virtual.

O pip garantido é descrito na PEP 453 .

No Ubuntu:

sudo apt-get install python-virtualenv

O pacote python-pipé uma dependência e, portanto, será instalado também.

Eu fiz esse procedimento para usarmos no trabalho.

cd ~
curl -s https://pypi.python.org/packages/source/p/pip/pip-1.3.1.tar.gz | tar xvz
cd pip-1.3.1
python setup.py install --user
cd ~
rm -rf pip-1.3.1

$HOME/.local/bin/pip install --user --upgrade pip distribute virtualenvwrapper

# Might want these three in your .bashrc
export PATH=$PATH:$HOME/.local/bin
export VIRTUALENVWRAPPER_VIRTUALENV_ARGS="--distribute"
source $HOME/.local/bin/virtualenvwrapper.sh

mkvirtualenv mypy
workon mypy
pip install --upgrade distribute
pip install pudb # Or whatever other nice package you might want.

Pontos principais para a segurança:

1. curl faz validação ssl. wget não.
2. A partir do pip 1.3.1, o pip também faz a validação de ssl.
3. Menos usuários podem fazer upload do tarball pypi que do tarball github.

Atualização: em julho de 2013, este projeto não é mais mantido. O autor sugere o uso de pyenv . (O pyenv não possui suporte interno para o virtualenv, mas funciona bem com ele.)

Pythonbrew é um gerenciador de versões para python e vem com suporte para virtualenv.

Depois de instalar pythonbrew e uma versão python usando venvs, é realmente fácil:

# Initializes the virtualenv 
pythonbrew venv init

# Create a virtual/sandboxed environment 
pythonbrew venv create mycoolbundle  

# Use it 
pythonbrew venv use mycoolbundle

Não há nenhum problema para instalar o sudo python setup.py, se você tem certeza que é o que deseja fazer.

A diferença é que ele usará o diretório de pacotes de sites do seu sistema operacional como destino para os arquivos .py serem copiados.

então, se você quiser que o pip seja acessível de maneira ampla, esse provavelmente é o caminho a percorrer. Não digo que os outros sejam ruins, mas isso provavelmente é justo o suficiente.

Instale o ActivePython . Inclui pip, virtualenv e Distribute.

Me deparei com o mesmo problema recentemente. Estou me tornando mais parcial com a mentalidade "sempre use um virtualenv", então meu problema era instalar o virtualenv com pip sem instalar a distribuição no meu diretório de pacotes de sites global ou de usuário. Para fazer isso, baixei manualmente distribuir, pip e virtualenv e, para cada um, executei “python setup.py install --prefix ~ / .local / python-private” (com uma configuração temporária de PYTHONPATH = ~ / .local / python-private) para que os scripts de instalação encontrem a distribuição). Mudei o script virtualenv para outro diretório que tenho no meu PATH e o editei para que os módulos de distribuição e virtualenv possam ser encontrados no sys.path. Tada: Eu não instalei nada em / usr, / usr / local ou em meu diretório de pacotes de sites de usuários, mas posso executar o virtualenv em qualquer lugar e nesse virtualenv recebo o pip.

Eu tive vários problemas (veja abaixo) ao instalar módulos SSL atualizados, mesmo dentro de uma virtualenv, sobre as versões mais antigas do Python fornecidas pelo sistema operacional, então agora uso pyenv.

O pyenv facilita muito a instalação de novas versões do Python e suporta virtualenvs. Começar é muito mais fácil do que as receitas para virtualenv listadas em outras respostas:

• No Mac, digite brew install pyenve no Linux, use pyenv-installer
• isso oferece suporte a virtualenv interno e troca de versão do Python (se necessário)
• funciona bem com Python 2 ou 3, pode ter várias versões instaladas ao mesmo tempo

Isso funciona muito bem para isolar a versão "new Python" e o virtualenv do sistema Python. Como você pode usar facilmente um Python mais recente (pós 2.7.9), os módulos SSL já estão atualizados e, é claro, como qualquer configuração moderna de virtualvv isolada dos módulos do sistema Python.

Alguns bons tutoriais:

• Usando pyenv e virtualenv - ao selecionar uma versão do Python, é mais fácil usar pyenv global 3.6.1(global para o usuário atual) ou pyenv local 2.7.13(local para o diretório atual).
• noções básicas de pyenv e uso com virtualenv

O pyenv-virtualenvplugin agora está embutido no tipo pyenv commands | grep virtualenva ser verificado. Eu não usaria o plug-in pyenv-virtualenvwrapper para começar - veja como você se familiariza com o pyenv-virtualenv, que é mais integrado ao pyenv, pois isso cobre a maior parte do que o virtualenvwrapper faz.

pyenvé modelado rbenv(uma boa ferramenta para alternar versão Ruby) e sua única dependência é bash.

• O pyenv não tem relação com o mesmo nome pyvenv- isso é um equivalente do virtualenv que faz parte das versões recentes do Python 3 e não lida com a troca de versão do Python

Ressalvas

Dois avisos sobre pyenv:

1. Funciona apenas a partir de um shell bash ou similar - ou, mais especificamente, o plugin pyenv-virtualenv não gosta dash, o que é/bin/sh no Ubuntu ou Debian.
2. Ele deve ser executado a partir de um shell de login interativo (por exemplo, bash --loginusando um terminal), o que nem sempre é fácil de obter com ferramentas de automação como o Ansible .

Portanto, o pyenv é melhor para uso interativo e menos bom para servidores de script.

Problemas do módulo SSL

Uma razão para usar pyenvé que geralmente há problemas com a atualização dos módulos SSL do Python ao usar versões mais antigas do Python fornecidas pelo sistema:

• O Ubuntu 14.04 inclui o Python 2.7.6, que requer um esforço considerável para atualizá-lo para os módulos SSL certos, para que ele lide com o SNI (indicação do nome do servidor) como cliente. (Eu escrevi alguns scripts Ansible para isso, o que foi bastante doloroso e ainda está quebrado em alguns casos.)
• os módulos SSL atualizados serão mais importantes à medida que os sites Python.org forem migrados para o TLS 1.2 somente durante 2017 e 2018.

• Você pode fazer isso sem instalar nada no próprio python.

• Você não precisa de sudo ou privilégios.

• Você não precisa encontrar a versão mais recente de um virtualenvarquivo tar

• Você não precisa editar as informações da versão em um script bash para manter as coisas atualizadas.

• Você não precisa curl/ wgetou tarinstalou, nem pipoueasy_install

• isso funciona tanto para 2.7 quanto para 3.X

Salve o seguinte em /tmp/initvenv.py:

de importação futura print_function

import os, sys, shutil, tempfile, subprocess, tarfile, hashlib

try:
    from urllib2 import urlopen
except ImportError:
    from urllib.request import urlopen

tmp_dir = tempfile.mkdtemp(prefix='initvenv_')
try:
    # read the latest version from PyPI
    f = urlopen("https://pypi.python.org/pypi/virtualenv/")
    # retrieve the .tar.gz file
    tar_found = False
    url = None
    sha256 = None
    for line in f.read().splitlines():
        if isinstance(line, bytes):
            line = line.decode('utf-8')
        if tar_found:
            if 'sha256' in line:
                sha256 = line.split('data-clipboard-text')[1].split('"')[1]
                break
            continue
        if not tar_found and 'tar.gz">' not in line:
            continue
        tar_found = True
        for url in line.split('"'):
            if url.startswith('https'):
                break
    else:
        print('tar.gz not found')
        sys.exit(1)
    file_name = url.rsplit('/', 1)[1]
    print(file_name)
    os.chdir(tmp_dir)
    data = urlopen(url).read()
    data_sha256 = hashlib.sha256(data).hexdigest()
    if sha256 != data_sha256:
        print('sha256 not correct')
        print(sha256)
        print(data_sha256)
        sys.exit(1)
    with open(file_name, 'wb') as fp:
        fp.write(data)
    tar = tarfile.open(file_name)
    tar.extractall()
    tar.close()
    os.chdir(file_name.replace('.tar.gz', ''))
    print(subprocess.check_output([sys.executable, 'virtualenv.py'] +
                                  [sys.argv[1]]).decode('utf-8'), end='')
    if len(sys.argv) > 2:
        print(subprocess.check_output([
            os.path.join(sys.argv[1], 'bin', 'pip'), 'install', 'virtualenv'] +

            sys.argv[2:]).decode('utf-8'), end='')
except:
    raise
finally:
    shutil.rmtree(tmp_dir)  # always clean up

e use-o como

python_binary_to_use_in_venv /tmp/initvenv.py your_venv_name [optional packages]

por exemplo (se você realmente precisa da distributecamada de compatibilidade setuptools)

python /tmp/initvenv.py venv distribute

Observe que, com versões mais antigas de python, isso pode lhe dar um InsecurePlatformWarningretorno.

Depois de ter seu virtualenv (nome, por exemplo venv), você pode configurar outro virtualenv usando o virtualenvrecém-instalado:

venv/bin/virtualenv venv2

virtualenvwrapper

Eu recomendo dar uma olhada no virtualenvwrapper também, depois de uma instalação única:

% /opt/python/2.7.10/bin/python /tmp/initvenv.py venv virtualenvwrapper

e ativação (pode ser feita a partir do seu script de login):

% source venv/bin/virtualenvwrapper.sh

você pode fazer coisas como:

% mktmpenv 
New python executable in tmp-17bdc3054a46b2b/bin/python
Installing setuptools, pip, wheel...done.
This is a temporary environment. It will be deleted when you run 'deactivate'.
(tmp-17bdc3054a46b2b)% 

¹ _{Não encontrei uma maneira de suprimir o aviso. Poderia ser resolvido dentro pipe / ou request, mas os desenvolvedores apontam um para o outro como a causa. Recebi a recomendação, muitas vezes não realista, de atualizar a versão python que estava usando para a versão mais recente. Estou certo de que isso poderia quebrar, por exemplo, minha instalação do Linux Mint 17. Felizmente, piparmazena em cache os pacotes; portanto, o Aviso é feito apenas uma vez por instalação de pacote.}

Há boas instruções no site oficial do Virtualenv. https://pypi.python.org/pypi/virtualenv

Basicamente, o que eu fiz foi instalar pipe sudo easy_install pip, em seguida, usei sudo pip install virtualenve criei um ambiente com: virtualenv my_env(nomeie o que você deseja), seguindo o que eu fiz virtualenv --distribute my_env:; que instalou distributeepip no meu virtualenv.

Mais uma vez, siga as instruções na virtualenvpágina.

Uma espécie de aborrecimento, proveniente de Ruby; P

Aqui está uma boa maneira de instalar o virtualenvwrapper (atualização disso ).

Faça o download do virtualenv-1.11.4 (você pode encontrar as mais recentes aqui ), descompacte-o, abraterminal

# Create a bootstrapenv and activate it:
$ cd ~
$ python <path to unzipped folder>/virtualenv.py bootstrapenv
$ source bootstrapenv/bin/activate

# Install virtualenvwrapper:
$ pip install virtualenvwrapper
$ mkdir -p ~/bootstrapenv/Envs

# append it to file `.bashrc`
$ vi ~/.bashrc
  source ~/bootstrapenv/bin/activate
  export WORKON_HOME=~/bootstrapenv/Envs
  source ~/bootstrapenv/bin/virtualenvwrapper.sh

# run it now.
$ source ~/.bashrc

É isso, agora você pode usar mkvirtualenv env1,lsvirtualenv ..etc

Nota: você pode excluir virtualenv-1.11.4e virtualenv-1.11.4.zipdas pastas Downloads.

A boa notícia é que se você instalou o python3.4, o pyvenv já está instalado. Então apenas

pyvenv project_dir
source project_dir/bin/activate
python --version   
python 3.4.*

Agora, neste ambiente virtual, você pode usar o pip para instalar módulos para este projeto.

Deixe esse ambiente virtual, apenas

deactivate