Qual è il modo corretto di installare pip, virtualenv e distribuirlo per Python?

Breve domanda

• Qual è il modo corretto per l'installazione pip, virtualenve distribute?

sfondo

Nella mia risposta alla domanda SO 4314376 , ho raccomandato di utilizzare in ez_setupmodo da poter installare pipe virtualenvcome segue:

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

Originariamente ho preso queste istruzioni dal post sul blog di Jesse Noller Quindi vuoi usare Python su Mac? . Mi piace l'idea di mantenere una directory globale pulita per i pacchetti di siti, quindi gli unici altri pacchetti che installo ci sono virtualenvwrappere distribute. (Di recente ho aggiunto distributealla mia cassetta degli attrezzi a causa di questo annuncio di servizio pubblico Python . Per installare questi due pacchetti, ho usato:

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

Niente più setuptools e easy_install

Per seguire davvero l'annuncio del servizio pubblico di Python , su una nuova installazione di Python, farei quanto segue:

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

Glyph's Rebuke

In un commento alla mia risposta alla domanda SO 4314376 , utente SO Glyph ha dichiarato:

NO. MAI MAI fare sudo python setup.py installqualunque cosa. Scrivi un ~ / .pydistutils.cfg che inserisca la tua installazione pip in ~ / .local o qualcosa del genere. Soprattutto i file denominati ez_setup.pytendono a risucchiare le versioni più recenti di cose come setuptools e easy_install, che possono potenzialmente danneggiare altre cose sul tuo sistema operativo.

Torna alla breve domanda

Quindi la risposta di Glyph mi porta alla mia domanda originale:

• Qual è il modo corretto per l'installazione pip, virtualenve distribute?

Puoi farlo senza installare nulla in Python stesso.

Non hai bisogno di sudo o di alcun privilegio.

Non è necessario modificare alcun file.

Installa virtualenv in un ambiente virtuale bootstrap. Usa quell'ambiente virtuale per crearne di più. Poiché virtualenv viene fornito con pip e distribuito, ottieni tutto da un'unica installazione.

1. Scarica virtualenv:
   • http://pypi.python.org/pypi/virtualenv
   • https://pypi.python.org/packages/source/v/virtualenv/virtualenv-12.0.7.tar.gz (o qualunque sia l'ultima versione!)
2. Decomprimere il tarball di origine
3. Utilizzare il tarball decompresso per creare un ambiente virtuale pulito. Questo ambiente virtuale verrà utilizzato per "avviare" altri. Tutti i tuoi ambienti virtuali conterranno automaticamente pip e distribuiranno.
4. Usando pip, installa virtualenv in quell'ambiente bootstrap.
5. Usa quell'ambiente bootstrap per crearne di più!

Ecco un esempio in 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

Ora puoi usare il tuo ambiente "bootstrap" per creare altro:

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

Andare fuori di testa!

Nota

Ciò presuppone che non si stia utilizzando una versione molto vecchia di virtualenv. Le vecchie versioni richiedevano i flag --no-site-packges(e in base alla versione di Python, --distribute). Ora puoi creare il tuo ambiente bootstrap con solo python virtualenv.py path-to-bootstrapo python3 virtualenv.py path-to-bootstrap.

Penso che glifo significhi fare qualcosa del genere:

1. Crea una directory ~/.local, se non esiste già.
2. Nella tua ~/.bashrc, assicurarsi che ~/.local/binè in PATHe che ~/.localè in PYTHONPATH.

3. Crea un file ~/.pydistutils.cfgche contiene

   [install]
   prefix=~/.local

   È un file standard in formato ConfigParser.

4. Scarica distribute_setup.py ed esegui python distribute_setup.py(no sudo). Se si lamenta di una site-packagesdirectory inesistente , crearla manualmente:

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

5. Esegui which easy_installper verificare che provenga~/.local/bin

6. Correre pip install virtualenv
7. Correre pip install virtualenvwrapper
8. Crea un env virtuale contenente una cartella, per esempio ~/.virtualenvs

9. In ~/.bashrcaggiunta

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

Questo è tutto, non serve sudoa nulla e il tuo ambiente Python è dentro ~/.local, completamente separato da Python del sistema operativo. Disclaimer: non sono sicuro di quanto sia compatibile virtualenvwrapperin questo scenario - non sono riuscito a testarlo sul mio sistema :-)

Se segui i passaggi indicati in diversi tutorial che ho collegato in questa risposta , puoi ottenere l'effetto desiderato senza i passaggi "manuali" piuttosto complicati nelle risposte di Walker e Vinay. Se sei su Ubuntu:

sudo apt-get install python-pip python-dev

L'equivalente si ottiene in OS X usando homebrew per installare Python (maggiori dettagli qui ).

brew install python

Con pipinstallato, puoi usarlo per ottenere i pacchetti rimanenti (puoi ometterlo sudoin OS X, mentre stai usando l'installazione di Python locale).

sudo pip install virtualenvwrapper

(questi sono i soli pacchetti necessari per l'installazione a livello globale e dubito che si scontrerà con qualsiasi sistema a livello di sistema dal sistema operativo. Se vuoi essere super sicuro, puoi mantenere le versioni della distribuzione sudo apt-get install virtualenvwrapper)

Nota: in Ubuntu 14.04 ricevo alcuni errori con l'installazione di pip , quindi uso pip3 install virtualenv virtualenvwrappere aggiungo VIRTUALENVWRAPPER_PYTHON=/usr/bin/python3al mio .bashrc/.zshrcfile.

Quindi aggiungi al tuo .bashrcfile

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

e fonte

. ~/.bashrc

Questo è fondamentalmente. Ora l'unica decisione è se si desidera creare un virtualenv per includere pacchetti a livello di sistema

mkvirtualenv --system-site-packages foo

dove i pacchetti di sistema esistenti non devono essere reinstallati, vengono collegati in modo simbolico alle versioni dell'interprete di sistema. Nota: è ancora possibile installare nuovi pacchetti e aggiornare i pacchetti inclusi dal sistema esistenti senza sudo: l'ho testato e funziona senza interruzioni dell'interprete di 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

L'alternativa, se si desidera un ambiente completamente separato, è

mkvirtualenv --no-site-packages bar

o dato che questa è l'opzione predefinita, semplicemente

mkvirtualenv bar

Il risultato è che hai una nuova virtualenv in cui puoi installare liberamente e senza soluzione di continuità i tuoi pacchetti preferiti

pip install flask

Python 3.4 in poi

Python 3.3 aggiunge il modulo venv e Python 3.4 aggiunge il modulo surepip . Questo rende il bootstrap pip semplice come:

python -m surepip

Forse preceduto da una chiamata venva farlo all'interno di un ambiente virtuale.

Il pip garantito è descritto in PEP 453 .

Su Ubuntu:

sudo apt-get install python-virtualenv

Il pacchetto python-pipè una dipendenza, quindi verrà installato anche.

Ho fatto questa procedura per usarla al lavoro.

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.

Punti chiave per la sicurezza:

1. curl fa la validazione ssl. wget no.
2. A partire da pip 1.3.1, pip esegue anche la convalida SSL.
3. Meno utenti possono caricare il tarball pypi rispetto a un tarball github.

Aggiornamento: da luglio 2013 questo progetto non è più mantenuto. L'autore suggerisce di usare Pyenv . (pyenv non ha il supporto integrato per virtualenv, ma gioca bene con esso.)

Pythonbrew è un gestore delle versioni per python e viene fornito con il supporto per virtualenv.

Dopo aver installato pythonbrew e una versione python usando venvs è davvero semplice:

# Initializes the virtualenv 
pythonbrew venv init

# Create a virtual/sandboxed environment 
pythonbrew venv create mycoolbundle  

# Use it 
pythonbrew venv use mycoolbundle

Non c'è nessun problema a fare sudo python setup.py install, se sei sicuro che sia quello che vuoi fare.

La differenza è che utilizzerà la directory dei pacchetti del sito del tuo sistema operativo come destinazione per i file .py da copiare.

quindi, se si desidera che pip sia accessibile a livello di sistema operativo, questa è probabilmente la strada da percorrere. Non dico che gli altri siano cattivi, ma questo è probabilmente abbastanza giusto.

Installa ActivePython . Include pip, virtualenv e Distribute.

Mi sono imbattuto nello stesso problema di recente. Sto diventando più parziale nella mentalità "usa sempre un virtualenv", quindi il mio problema era installare virtualenv con pip senza installare distribuire nella mia directory globale o dei siti dell'utente. Per fare ciò, ho scaricato manualmente distribut, pip e virtualenv, e per ognuno ho eseguito "python setup.py install --prefix ~ / .local / python-private" (con un'impostazione temporanea di PYTHONPATH = ~ / .local / python-private) in modo che gli script di installazione possano trovare la distribuzione). Ho spostato lo script virtualenv in un'altra directory che ho sul mio PERCORSO e l'ho modificato in modo che i moduli di distribuzione e virtualenv possano essere trovati su sys.path. Tada: Non ho installato nulla in / usr, / usr / local o nella directory dei pacchetti del mio sito utente, ma posso eseguire virtualenv ovunque, e in quel virtualenv ottengo pip.

Ho avuto vari problemi (vedi sotto) l'installazione di moduli SSL aggiornati, anche all'interno di virtualenv, in aggiunta alle versioni precedenti di Python fornite dal sistema operativo, quindi ora uso pyenv.

pyenv semplifica l'installazione di una nuova versione di Python e supporta virtualenvs. Iniziare è molto più semplice delle ricette per virtualenv elencate in altre risposte:

• Su Mac, digitare brew install pyenve su Linux, utilizzare pyenv-installer
• questo ti fornisce il supporto virtualenv integrato e il cambio di versione di Python (se richiesto)
• funziona bene con Python 2 o 3, può avere molte versioni installate contemporaneamente

Funziona molto bene per isolare la versione "nuova Python" e virtualenv dal sistema Python. Poiché è possibile utilizzare facilmente un Python più recente (post 2.7.9), i moduli SSL sono già aggiornati e, naturalmente, come qualsiasi configurazione virtualenv moderna, vengono isolati dai moduli Python di sistema.

Un paio di simpatici tutorial:

• Usando pyenv e virtualenv - quando si seleziona una versione di Python, è più facile da usare pyenv global 3.6.1(da globale a utente corrente) o pyenv local 2.7.13(da locale a directory corrente).
• nozioni di base di pyenv e uso con virtualenv

Il pyenv-virtualenvplug-in è ora incorporato: digitare pyenv commands | grep virtualenvper verificare. Non userei il plug-in pyenv-virtualenvwrapper per iniziare - guarda come vai avanti con pyenv-virtualenv che è più integrato in pyenv, poiché copre la maggior parte di ciò che fa virtualenvwrapper.

pyenvè modellato su rbenv(un buon strumento per cambiare la versione di Ruby) e la sua unica dipendenza è bash.

• pyenv non è correlato al nome molto simile pyvenv- è un equivalente di virtualenv che fa parte delle recenti versioni di Python 3 e non gestisce il cambio di versione di Python

Avvertenze

Due avvertimenti su pyenv:

1. Funziona solo da una shell bash o simile - o più specificamente, il plug-in pyenv-virtualenv non piace dash, che si trova /bin/shsu Ubuntu o Debian.
2. Deve essere eseguito da una shell di login interattiva (ad esempio bash --loginutilizzando un terminale), che non è sempre facile da ottenere con strumenti di automazione come Ansible .

Quindi pyenv è il migliore per l'uso interattivo e meno buono per i server di scripting.

Problemi del modulo SSL

Uno dei motivi per utilizzare pyenvè che spesso si verificano problemi con l'aggiornamento dei moduli SSL Python quando si utilizzano versioni precedenti di Python fornite dal sistema:

• Ubuntu 14.04 include Python 2.7.6 che richiede un notevole sforzo per aggiornarlo ai giusti moduli SSL in modo da gestire SNI (indicazione del nome del server) come client. (Ho scritto alcuni script Ansible per questo che è stato abbastanza doloroso e ancora rotto in alcuni casi.)
• i moduli SSL aggiornati saranno più importanti poiché i siti Python.org passano a TLS 1.2 solo durante il 2017 e il 2018.

• Puoi farlo senza installare nulla in Python stesso.

• Non hai bisogno di sudo o di alcun privilegio.

• Non è necessario trovare l'ultima versione di un virtualenvfile tar

• Non è necessario modificare le informazioni sulla versione in uno script bash per mantenere le cose aggiornate.

• Non è necessario curl/ wgeto tarinstallato, né pipoeasy_install

• funziona per 2.7 e 3.X

Salva quanto segue in /tmp/initvenv.py:

dalla futura importazione funzione_stampa

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 usalo come

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

ad es. (se hai davvero bisogno del distributelivello di compatibilità per setuptools)

python /tmp/initvenv.py venv distribute

Nota che, con le versioni precedenti di Python, questo potrebbe darti InsecurePlatformWarnings¹.

Una volta che hai il tuo virtualenv (nome es. venv) Puoi configurare un altro virtualenv usando il virtualenvappena installato:

venv/bin/virtualenv venv2

virtualenvwrapper

Ti consiglio di dare un'occhiata anche a virtualenvwrapper , dopo una volta una configurazione:

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

e attivazione (può essere eseguita dal tuo script di accesso):

% source venv/bin/virtualenvwrapper.sh

puoi fare cose come:

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

¹ _{Non ho trovato un modo per sopprimere l'avviso. Potrebbe essere risolto in pipe / o request, ma gli sviluppatori indicano l'un l'altro come causa. Ho ricevuto la raccomandazione, spesso non realistica, di aggiornare la versione di Python che stavo usando all'ultima versione. Sono sicuro che questo si spezzerebbe, ad esempio la mia installazione di Linux Mint 17. Fortunatamente pipmemorizza nella cache i pacchetti, quindi l'avviso viene emesso una sola volta per installazione del pacchetto.}

Ci sono buone istruzioni sul sito ufficiale di Virtualenv. https://pypi.python.org/pypi/virtualenv

Fondamentalmente quello che ho fatto, è installare pipcon sudo easy_install pip, poi utilizzati sudo pip install virtualenvpoi creato un ambiente con: virtualenv my_env(nome è quello che si vuole), dopo che ho fatto: virtualenv --distribute my_env; quale installato distributee pipnel mio virtualenv.

Ancora una volta, segui le istruzioni sulla virtualenvpagina.

Una specie di seccatura, proveniente da Ruby; P

Ecco un bel modo per installare virtualenvwrapper (aggiornamento di questo ).

Scarica virtualenv-1.11.4 (puoi trovare le ultime novità qui ), decomprimilo, apriterminal

# 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

Che è, ora è possibile utilizzare mkvirtualenv env1, lsvirtualenv.etc

Nota: è possibile eliminare virtualenv-1.11.4e virtualenv-1.11.4.zipdalle cartelle Download.

La buona notizia è che se hai installato python3.4, pyvenv è già stato installato. Quindi

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

Ora in questo ambiente virtuale, puoi usare pip per installare i moduli per questo progetto.

Lascia questo env virtuale, giusto

deactivate