Como faço para instalar a partir de um cache local com pip?

Eu instalo muitos dos mesmos pacotes em diferentes ambientes virtuais . Existe uma maneira que eu possa baixar um pacote uma vez e depois ter pip instalar a partir de um cache local?

Isso reduziria a largura de banda e o tempo de download.

Resposta Atualizada 19-Nov-15

De acordo com a documentação do Pip :

A partir da v6.0, o pip fornece um cache por padrão que funciona de maneira semelhante à de um navegador da web. Enquanto o cache está ativado por padrão e é projetado para fazer a coisa certa por padrão, você pode desativar o cache e sempre acessar o PyPI utilizando a opção --no-cache-dir .

Portanto, a resposta atualizada é apenas usar pip com seus padrões, se você quiser um cache de download.

Resposta Original

Das notícias pip , versão 0.1.4:

Adicionado suporte para uma variável de ambiente $ PIP_DOWNLOAD_CACHE que armazenará em cache os downloads de pacotes, para que futuras instalações não exijam grandes downloads. O access à rede ainda é necessário, mas apenas alguns downloads serão evitados ao usá-lo.

Para aproveitar isso, adicionei o seguinte ao meu ~/.bash_profile :

 export PIP_DOWNLOAD_CACHE=$HOME/.pip_download_cache 

ou, se você estiver em um Mac:

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

Notas

  1. Se uma nova versão de um pacote for detectada, ela será baixada e adicionada ao diretório PIP_DOWNLOAD_CACHE . Por exemplo, agora tenho alguns pacotes do Django.
  2. Isso não elimina a necessidade de access à rede, como afirma o pip , então não é a resposta para criar novos virtualenvs no avião, mas ainda é ótimo.

Na minha opinião, o pip2pi é uma solução muito mais elegante e confiável para esse problema.

Dos docs:

O pip2pi constrói um repository de pacotes compatível com PyPI a partir dos requisitos de pip

pip2pi permite que você crie seu próprio índice PyPI usando dois comandos simples:

  1. Para espelhar um pacote e todos os seus 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 construir um índice de pacote do diretório 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 a partir do índice que você criou na etapa 2., você pode simplesmente usar:

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

Você pode até mesmo espelhar seu próprio índice em um host remoto com pip2pi .

Para versões mais recentes do Pip:

Novas versões do Pip agora armazenam em cache os downloads por padrão. Veja esta documentação:

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

Para versões antigas do Pip:

Crie um arquivo de configuração chamado ~/.pip/pip.conf e adicione o seguinte conteúdo:

 [global] download_cache = ~/.cache/pip 

No OS X, um caminho melhor para escolher seria ~/Library/Caches/pip já que segue a convenção usada por outros programas do OS X.

PIP_DOWNLOAD_CACHE tem alguns problemas sérios. Mais importante ainda, ele codifica o nome do host do download no cache, portanto, o uso de espelhos torna-se impossível.

A melhor maneira de gerenciar um cache de downloads de pip é separar a etapa “download do pacote” da etapa “instalar o pacote”. Os arquivos baixados são comumente referidos como “arquivos sdist” (distribuições de origem) e eu vou armazená-los em um diretório $ SDIST_CACHE.

Os dois passos acabam sendo:

 pip install --no-install --use-mirrors -I --download=$SDIST_CACHE  

Que irá baixar o pacote e colocá-lo no diretório apontado por $ SDIST_CACHE. Não instalará o pacote. E então você corre:

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

Para instalar o pacote em seu ambiente virtual. Idealmente, $ SDIST_CACHE seria confirmado sob o controle de origem. Ao implantar na produção, você executaria apenas o segundo comando pip para instalar os pacotes sem baixá-los.

A partir da versão 6.0 , o pip agora faz seu próprio armazenamento em cache:

  • DEPRECATION pip install --download-cache e pip wheel --download-cache sinalizadores de linha de comando foram reprovados e a funcionalidade removida. Como o pip agora configura e usa automaticamente o cache HTTP interno que substitui o --download-cache as opções existentes foram tornadas não funcionais, mas ainda serão aceitas até a remoção delas no pip v8.0. Para mais informações, consulte https://pip.pypa.io/en/latest/reference/pip_install.html#caching

Mais informações no link acima :

A partir da v6.0, o pip fornece um cache por padrão que funciona de maneira semelhante à de um navegador da web. Enquanto o cache está ativado por padrão e é projetado para fazer a coisa certa por padrão, você pode desativar o cache e sempre acessar o PyPI utilizando a opção --no-cache-dir .

O pip wheel é uma excelente opção que faz o que você quer com o recurso extra de pré-compilar os pacotes. Dos documentos oficiais :

Construa rodas para um requisito (e todas as suas dependencies):

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

Agora seu /tmp/wheelhouse tem todas as suas dependencies pré-compiladas, então você pode copiar a pasta para outro servidor e instalar tudo com este comando:

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

Note que nem todos os pacotes serão totalmente portáteis entre as máquinas. Alguns pacotes serão criados especificamente para a versão do Python, distribuição de SO e / ou arquitetura de hardware que você está usando. Isso será especificado no nome do arquivo, como -cp27-none-linux_x86_64 para o CPython 2.7 em um Linux de 64 bits, etc.

Usando somente pip (minha versão é 1.2.1), você também pode construir um repository local como este:

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

Na primeira chamada do pip, os pacotes do arquivo de requisitos são procurados no repository local (apenas) e, em seguida, instalados a partir de lá. Se isso falhar, o pip recupera os pacotes do seu local habitual (por exemplo, PyPI) e faz o download para o PIP_SDIST_INDEX (mas não instala nada!). A primeira chamada é “repetida” para instalar corretamente o pacote do índice local.

( --download-cache cria um nome de arquivo local que é o URL completo (com escape), e o pip não pode usar isso como um índice com --find-links . --download-cache usará o arquivo em cache, se encontrado. poderia adicionar essa opção à segunda chamada do pip, mas como o índice já funciona como um tipo de cache, isso não necessariamente traz muita coisa. Isso ajudaria se o índice fosse esvaziado, por exemplo.)

Uma opção mais simples é a basket .

Dado um nome de pacote, ele irá baixá-lo e todas as dependencies para um local central; sem nenhuma das desvantagens do cache pip. Isso é ótimo para uso offline.

Você pode então usar este diretório como uma fonte para pip :

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

Ou easy_install :

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

Você também pode usá-lo para atualizar a cesta sempre que estiver online.

Existe uma nova solução para este chamado pip-accel , um substituto para o pip com caching embutido.

O programa pip-accel é um wrapper para o pip, o gerenciador de pacotes Python. Ele acelera o uso do pip para inicializar os ambientes virtuais do Python, considerando um ou mais arquivos de requisitos. Isso é feito combinando as duas abordagens a seguir:

  • Os downloads de distribuição de origem são armazenados em cache e usados ​​para gerar um índice local de arquivos de distribuição de origem.

  • Distribuições binárias são usadas para acelerar o processo de instalação de dependencies com componentes binários (como M2Crypto e LXML). Em vez de recompilar essas dependencies novamente para cada ambiente virtual, nós as compilamos uma vez e armazenamos em cache o resultado como uma distribuição binária * .tar.gz.

O Paylogic usa pip-accel para inicializar de forma rápida e confiável ambientes virtuais em seu farm de escravos de continuous integration que estão constantemente executando testes de unidade (este foi um dos casos de uso originais para os quais o pip-accel foi desenvolvido). Nós também usamos em nossos servidores de compilation.

Vimos uma aceleração em torno de 10x com a mudança de pip para pip-accel .

Eu acho que o pacote “pip-accel” deve ser uma boa escolha.