J'installe un grand nombre des mêmes packages dans différents environnements virtualenv . Existe-t-il un moyen de télécharger un package une fois, puis d' installer pip à partir d'un cache local?

Cela réduirait la bande passante et le temps de téléchargement.

Réponse mise à jour 19-nov-15

Selon la documentation Pip :

À partir de la version 6.0, pip fournit un cache activé par défaut qui fonctionne de manière similaire à celui d'un navigateur Web. Alors que le cache est activé par défaut et conçu, faites ce qu'il faut par défaut, vous pouvez désactiver le cache et toujours accéder à PyPI en utilisant l' --no-cache-diroption.

Par conséquent, la réponse mise à jour consiste simplement à utiliser pip avec ses valeurs par défaut si vous voulez un cache de téléchargement.

Réponse originale

À partir des nouvelles de pip , version 0.1.4:

Ajout de la prise en charge d'une variable d'environnement $ PIP_DOWNLOAD_CACHE qui mettra en cache les téléchargements de paquets, de sorte que les futures installations ne nécessiteront pas de gros téléchargements. L'accès au réseau est toujours nécessaire, mais seuls quelques téléchargements seront évités lors de son utilisation.

Pour profiter de cela, j'ai ajouté ce qui suit à mon ~/.bash_profile:

export PIP_DOWNLOAD_CACHE=$HOME/.pip_download_cache

ou, si vous êtes sur un Mac:

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

Remarques

1. Si une version plus récente d'un package est détectée, elle sera téléchargée et ajoutée au PIP_DOWNLOAD_CACHErépertoire. Par exemple, j'ai maintenant pas mal de packages Django.
2. Cela ne supprime pas le besoin d'accès au réseau, comme indiqué dans les nouvelles de pip , ce n'est donc pas la solution pour créer de nouveaux virtualenvsdans l'avion, mais c'est toujours génial.

À mon avis, pip2piest une solution beaucoup plus élégante et fiable pour ce problème.

À partir de la documentation:

pip2pi construit un référentiel de packages compatible PyPI à partir des exigences de pip

pip2pi vous permet de créer votre propre index PyPI en utilisant deux commandes simples:

1. Pour mettre en miroir un package et toutes ses exigences, utilisez 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. Pour créer un index de package à partir du répertoire précédent:

   $ 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. Pour installer à partir de l'index que vous avez créé à l'étape 2., vous pouvez simplement utiliser:

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

Vous pouvez même mettre en miroir votre propre index sur un hôte distant avec pip2pi.

Pour les versions plus récentes de Pip:

Les nouvelles versions de Pip mettent désormais en cache les téléchargements par défaut. Consultez cette documentation:

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

Pour les anciennes versions de Pip:

Créez un fichier de configuration nommé ~/.pip/pip.confet ajoutez le contenu suivant:

[global]
download_cache = ~/.cache/pip

Sur OS X, un meilleur chemin à choisir serait ~/Library/Caches/pipcar il suit la convention que d'autres programmes OS X utilisent.

PIP_DOWNLOAD_CACHE a de sérieux problèmes. Plus important encore, il encode le nom d'hôte du téléchargement dans le cache, donc l'utilisation de miroirs devient impossible.

La meilleure façon de gérer un cache de téléchargements pip est de séparer l'étape "télécharger le package" de l'étape "installer le package". Les fichiers téléchargés sont communément appelés "fichiers sdist" (distributions sources) et je vais les stocker dans un répertoire $ SDIST_CACHE.

Les deux étapes finissent par être:

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

Ce qui va télécharger le package et le placer dans le répertoire pointé par $ SDIST_CACHE. Il n'installera pas le package. Et puis vous exécutez:

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

Pour installer le package dans votre environnement virtuel. Idéalement, $ SDIST_CACHE serait validé sous votre contrôle de code source. Lors du déploiement en production, vous n'exécuteriez que la deuxième commande pip pour installer les packages sans les télécharger.

À partir de la version 6.0 , fait pipmaintenant sa propre mise en cache:

• DEPRECATION pip install --download-cache et les pip wheel --download-cacheindicateurs de ligne de commande ont été abandonnés et la fonctionnalité supprimée. Puisque pip configure et utilise maintenant automatiquement son cache HTTP interne qui supplante les --download-cacheoptions existantes ont été rendues non fonctionnelles mais seront toujours acceptées jusqu'à leur suppression dans pip v8.0. Pour plus d'informations, veuillez consulter https://pip.pypa.io/en/latest/reference/pip_install.html#caching

Plus d'informations à partir du lien ci - dessus :

À partir de la version 6.0, pip fournit un cache activé par défaut qui fonctionne de manière similaire à celui d'un navigateur Web. Alors que le cache est activé par défaut et conçu, faites ce qu'il faut par défaut, vous pouvez désactiver le cache et toujours accéder à PyPI en utilisant l' --no-cache-diroption.

pip wheel est une excellente option qui fait ce que vous voulez avec la fonctionnalité supplémentaire de pré-compilation des packages. À partir des documents officiels :

Créez des roues pour une exigence (et toutes ses dépendances):

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

Maintenant, votre /tmp/wheelhouserépertoire a toutes vos dépendances précompilées, vous pouvez donc copier le dossier sur un autre serveur et tout installer avec cette commande:

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

Notez que tous les packages ne seront pas complètement portables sur les machines. Certains packages seront construits spécifiquement pour la version Python, la distribution du système d'exploitation et / ou l'architecture matérielle que vous utilisez. Cela sera spécifié dans le nom du fichier, comme -cp27-none-linux_x86_64pour CPython 2.7 sur un Linux 64 bits, etc.

En utilisant pip uniquement (ma version est 1.2.1), vous pouvez également créer un référentiel local comme celui-ci:

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

Lors du premier appel de pip, les packages du fichier des exigences sont recherchés dans le référentiel local (uniquement), puis installés à partir de là. En cas d'échec, pip récupère les packages à partir de leur emplacement habituel (par exemple PyPI) et les télécharge sur le PIP_SDIST_INDEX(mais n'installe rien!). Le premier appel est "répété" pour installer correctement le package à partir de l'index local.

( --download-cachecrée un nom de fichier local qui est l'URL complète (échappée), et pip ne peut pas l'utiliser comme index avec --find-links. --download-cacheutilisera le fichier mis en cache, s'il est trouvé. Nous pourrions ajouter cette option au deuxième appel de pip, mais depuis l'index fonctionne déjà comme une sorte de cache, cela n'apporte pas forcément beaucoup. Cela aiderait si votre index est vidé, par exemple.)

Il existe une nouvelle solution à cela appelée pip-accel , un remplacement de la pipmise en cache intégrée.

Le programme pip-accel est un wrapper pour pip, le gestionnaire de packages Python. Il accélère l'utilisation de pip pour initialiser les environnements virtuels Python en fonction d'un ou plusieurs fichiers d'exigences. Pour ce faire, il combine les deux approches suivantes:

• Les téléchargements de distribution source sont mis en cache et utilisés pour générer un index local des archives de distribution source.

• Les distributions binaires sont utilisées pour accélérer le processus d'installation des dépendances avec des composants binaires (comme M2Crypto et LXML). Au lieu de recompiler à nouveau ces dépendances pour chaque environnement virtuel, nous les compilons une fois et mettons le résultat en cache sous forme de distribution binaire * .tar.gz.

Paylogic utilise pip-accel pour initialiser rapidement et de manière fiable des environnements virtuels sur sa ferme d'esclaves d'intégration continue qui exécutent constamment des tests unitaires (c'était l'un des cas d'utilisation originaux pour lesquels pip-accel a été développé). Nous l'utilisons également sur nos serveurs de build.

Nous avons vu une accélération d'environ 10x du passage de pipà pip-accel.

Une option plus simple est basket.

Étant donné le nom d'un package, il le téléchargera ainsi que toutes les dépendances vers un emplacement central; sans aucun des inconvénients du cache pip. C'est idéal pour une utilisation hors ligne.

Vous pouvez ensuite utiliser ce répertoire comme source pour pip:

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

Ou easy_install:

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

Vous pouvez également l'utiliser pour mettre à jour le panier chaque fois que vous êtes en ligne.

Je pense que le package "pip-accel" doit être un bon choix.