Instalo muchos de los mismos paquetes en diferentes entornos virtualenv . ¿Hay alguna manera de que pueda descargar un paquete una vez y luego instalar pip desde un caché local?

Esto reduciría el ancho de banda y el tiempo de descarga.

Respuesta actualizada 19-nov-15

De acuerdo con la documentación de Pip :

A partir de v6.0, pip proporciona una caché activada por defecto que funciona de manera similar a la de un navegador web. Mientras el caché está activado de forma predeterminada y está diseñado para hacer lo correcto de forma predeterminada, puede desactivar el caché y siempre acceder a PyPI utilizando la --no-cache-diropción.

Por lo tanto, la respuesta actualizada es simplemente usar pip con sus valores predeterminados si desea una caché de descarga.

Respuesta original

De las noticias de pip , versión 0.1.4:

Se agregó soporte para una variable ambiental $ PIP_DOWNLOAD_CACHE que almacenará en caché las descargas de paquetes, por lo que las instalaciones futuras no requerirán descargas grandes. Todavía se requiere acceso a la red, pero solo se evitarán algunas descargas al usar esto.

Para aprovechar esto, agregué lo siguiente a mi ~/.bash_profile:

export PIP_DOWNLOAD_CACHE=$HOME/.pip_download_cache

o, si estás en una Mac:

export PIP_DOWNLOAD_CACHE=$HOME/Library/Caches/pip-downloads

Notas

1. Si se detecta una versión más nueva de un paquete, se descargará y se agregará al PIP_DOWNLOAD_CACHEdirectorio. Por ejemplo, ahora tengo bastantes paquetes de Django.
2. Esto no elimina la necesidad de acceso a la red, como se indica en las noticias de pip , por lo que no es la respuesta para crear nuevos virtualenvsen el avión, pero sigue siendo genial.

En mi opinión, pip2pies una solución mucho más elegante y confiable para este problema.

De los documentos:

pip2pi crea un repositorio de paquetes compatible con PyPI a partir de los requisitos de pip

pip2pi le permite crear su propio índice PyPI utilizando dos comandos simples:

1. Para reflejar un paquete y todos sus requisitos, use pip2tgz:

   $ cd /tmp/; mkdir package/
   $ pip2tgz packages/ httpie==0.2
   ...
   $ ls packages/
   Pygments-1.5.tar.gz
   httpie-0.2.0.tar.gz
   requests-0.14.0.tar.gz
   

2. Para crear un índice de paquete desde el directorio anterior:

   $ ls packages/
   bar-0.8.tar.gz
   baz-0.3.tar.gz
   foo-1.2.tar.gz
   $ dir2pi packages/
   $ find packages/
   /httpie-0.2.0.tar.gz
   /Pygments-1.5.tar.gz
   /requests-0.14.0.tar.gz
   /simple
   /simple/httpie
   /simple/httpie/httpie-0.2.0.tar.gz
   /simple/Pygments
   /simple/Pygments/Pygments-1.5.tar.gz
   /simple/requests
   /simple/requests/requests-0.14.0.tar.gz
   

3. Para instalar desde el índice que creó en el paso 2., simplemente puede usar:

   pip install --index-url=file:///tmp/packages/simple/ httpie==0.2
   

Incluso puede reflejar su propio índice en un host remoto con pip2pi.

Para las nuevas versiones de Pip:

Las versiones más recientes de Pip ahora se descargan en caché de forma predeterminada. Ver esta documentación:

https://pip.pypa.io/en/stable/reference/pip_install/#caching

Para versiones anteriores de Pip:

Cree un archivo de configuración llamado ~/.pip/pip.confy agregue los siguientes contenidos:

[global]
download_cache = ~/.cache/pip

En OS X, una mejor ruta para elegir sería ~/Library/Caches/pipya que sigue la convención que usan otros programas de OS X.

PIP_DOWNLOAD_CACHE tiene algunos problemas serios. Lo más importante es que codifica el nombre de host de la descarga en el caché, por lo que es imposible usar espejos.

La mejor manera de administrar un caché de descargas de pip es separar el paso "descargar el paquete" del paso "instalar el paquete". Los archivos descargados se conocen comúnmente como "archivos sdist" (distribuciones de origen) y los voy a almacenar en un directorio $ SDIST_CACHE.

Los dos pasos terminan siendo:

pip install --no-install --use-mirrors -I --download=$SDIST_CACHE <package name>

Que descargará el paquete y lo colocará en el directorio señalado por $ SDIST_CACHE. No instalará el paquete. Y luego corres:

pip install --find-links=file://$SDIST_CACHE --no-index --index-url=file:///dev/null <package name> 

Para instalar el paquete en su entorno virtual. Idealmente, $ SDIST_CACHE se comprometería bajo su control de origen. Cuando se implementa en producción, solo ejecuta el segundo comando pip para instalar los paquetes sin descargarlos.

A partir de la versión 6.0 , pipahora realiza su propio almacenamiento en caché:

• DEPRECATION pip install --download-cache y las pip wheel --download-cachebanderas de línea de comando han quedado en desuso y se ha eliminado la funcionalidad. Dado que pip ahora configura y usa automáticamente su caché HTTP interno que reemplaza --download-cachelas opciones existentes se han convertido en no funcionales, pero aún se aceptarán hasta su eliminación en pip v8.0. Para obtener más información, consulte https://pip.pypa.io/en/latest/reference/pip_install.html#caching

Más información en el enlace de arriba :

A partir de v6.0, pip proporciona una caché activada por defecto que funciona de manera similar a la de un navegador web. Mientras el caché está activado de forma predeterminada y está diseñado para hacer lo correcto de forma predeterminada, puede desactivar el caché y siempre acceder a PyPI utilizando la --no-cache-diropción.

pip wheel es una excelente opción que hace lo que quiere con la característica adicional de precompilar los paquetes. De los documentos oficiales :

Construya ruedas para un requisito (y todas sus dependencias):

$ pip wheel --wheel-dir=/tmp/wheelhouse SomePackage

Ahora su /tmp/wheelhousedirectorio tiene todas sus dependencias precompiladas, por lo que puede copiar la carpeta a otro servidor e instalar todo con este comando:

$ pip install --no-index --find-links=/tmp/wheelhouse SomePackage

Tenga en cuenta que no todos los paquetes serán completamente portátiles en todas las máquinas. Algunos paquetes se construirán específicamente para la versión de Python, la distribución del sistema operativo y / o la arquitectura de hardware que está utilizando. Eso se especificará en el nombre del archivo, como -cp27-none-linux_x86_64para CPython 2.7 en un Linux de 64 bits, etc.

Usando solo pip (mi versión es 1.2.1), también puede construir un repositorio local como este:

if ! pip install --find-links="file://$PIP_SDIST_INDEX" --no-index <package>; then
    pip install --download-directory="$PIP_SDIST_INDEX" <package>
    pip install --find-links="file://$PIP_SDIST_INDEX" --no-index <package>
fi

En la primera llamada de pip, los paquetes del archivo de requisitos se buscan en el repositorio local (solo) y luego se instalan desde allí. Si eso falla, pip recupera los paquetes de su ubicación habitual (por ejemplo, PyPI) y los descarga en el PIP_SDIST_INDEX(¡pero no instala nada!). La primera llamada se "repite" para instalar correctamente el paquete desde el índice local.

( --download-cachecrea un nombre de archivo local que es el URL completo (escapado), y pip no puede usar esto como índice con --find-links. --download-cacheUtilizará el archivo en caché, si se encuentra. Podríamos agregar esta opción a la segunda llamada de pip, pero desde el índice ya funciona como una especie de caché, no necesariamente trae mucho. Ayudaría si su índice se vacía, por ejemplo).

Hay una nueva solución para esto llamada pip-accel , un reemplazo directo para el pipalmacenamiento en caché incorporado.

El programa pip-accel es un contenedor para pip, el administrador de paquetes Python. Acelera el uso de pip para inicializar entornos virtuales de Python dados uno o más archivos de requisitos. Lo hace combinando los dos enfoques siguientes:

• Las descargas de distribución de origen se almacenan en caché y se utilizan para generar un índice local de archivos de distribución de origen.

• Las distribuciones binarias se utilizan para acelerar el proceso de instalación de dependencias con componentes binarios (como M2Crypto y LXML). En lugar de volver a compilar estas dependencias para cada entorno virtual, las compilamos una vez y almacenamos el resultado en caché como una distribución binaria * .tar.gz.

Paylogic utiliza pip-accel para inicializar de manera rápida y confiable entornos virtuales en su granja de esclavos de integración continua que constantemente ejecutan pruebas unitarias (este fue uno de los casos de uso originales para los que se desarrolló pip-accel). También lo usamos en nuestros servidores de compilación.

Hemos visto alrededor de 10 veces la aceleración al cambiar de pipa pip-accel.

Una opción más simple es basket.

Dado un nombre de paquete, lo descargará y todas las dependencias a una ubicación central; sin ninguno de los inconvenientes de la caché de pip. Esto es genial para usar sin conexión.

Luego puede usar este directorio como fuente para pip:

pip install --no-index -f file:///path/to/basket package

O easy_install:

easy_install -f ~/path/to/basket -H None package

También puede usarlo para actualizar la cesta cada vez que esté en línea.

Creo que el paquete "pip-accel" debe ser una buena opción.