Quais são os equivalentes em Python do empacotador de Ruby / embalagem de Perl?

Eu sei sobre virtualenv e pip. Mas eles são um pouco diferentes de empacotador / caixa.

Por exemplo:

• pip escreve o caminho absoluto para o shebang ou o script de ativação
• pip não tem o execsubcomando ( bundle exec bar)
• virtualenv copia o interpretador Python para um diretório local

Todo desenvolvedor Python usa virtualenv / pip? Existem outras ferramentas de gerenciamento de pacotes para Python?

Pelo que li sobre o bundler - pip sem virtualenv deve funcionar bem para você. Você pode pensar nisso como algo entre o comando gem regular e o bundler. Coisas comuns que você pode fazer com o pip:

1. Instalando pacotes (instalação gem)

   pip install mypackage

2. Dependências e instalação em massa (gemfile)

   Provavelmente, a maneira mais fácil é usar os arquivos requirements.txt do pip. Basicamente, é apenas uma lista simples de pacotes necessários com possíveis restrições de versão. Pode ser algo como:

   nose==1.1.2
   django<1.3
   PIL

   Posteriormente, quando quiser instalar essas dependências, você deve fazer:

   $ pip install -r requirements.txt

   Uma maneira simples de ver todos os seus pacotes atuais na sintaxe do arquivo de requisitos é fazer:

   $ pip freeze

   Você pode ler mais sobre isso aqui .

3. Execução (bundler exec)

   Todos os pacotes python que vêm com arquivos executáveis ​​geralmente estão disponíveis diretamente após a instalação (a menos que você tenha uma configuração personalizada ou seja um pacote especial). Por exemplo:

   $ pip install gunicorn
   $ gunicorn -h 

4. Empacote joias para instalação do cache (pacote bundler)

   Existe pip bundlee pip zip/unzip. Mas não tenho certeza se muitas pessoas o usam.

ps Se você se preocupa com o isolamento do ambiente, você também pode usar o virtualenv junto com o pip (eles são amigos próximos e funcionam perfeitamente juntos). Por padrão, o pip instala pacotes em todo o sistema que podem exigir direitos de administrador.

Você pode usar pipenv , que tem interface semelhante com bundler.

$ pip install pipenv

Pipenv cria virtualenv automaticamente e instala dependências de Pipfileou Pipfile.lock.

$ pipenv --three           # Create virtualenv with Python3
$ pipenv install           # Install dependencies from Pipfile
$ pipenv install requests  # Install `requests` and update Pipfile
$ pipenv lock              # Generate `Pipfile.lock`
$ pipenv shell             # Run shell with virtualenv activated

Você pode executar o comando com escopo virtualenv como bundle exec.

$ pipenv run python3 -c "print('hello!')"

Existe um clone pbundler .

A versão que está atualmente em pip simplesmente lê o requirements.txtarquivo que você já possui, mas está muito desatualizado. Também não é totalmente equivalente: ele insiste em fazer a virtualenv. O Bundler, eu noto, apenas instala os pacotes que estão faltando, e dá a você a opção de fornecer sua senha sudo para instalar em seus diretórios de sistema ou reiniciar, o que não parece ser um recurso do pbundler.

No entanto, a versão no git é uma reescrita quase completa para ficar muito mais próxima do comportamento do Bundler ... incluindo ter um "Cheesefile" e agora sem suporte para o arquivo requirements.txt. Isso é lamentável, uma vez que requirements.txt é o padrão de fato em pythonland, e há até trabalho oficial com carimbo BDFL para padronizá-lo . Quando isso entrar em vigor, você pode ter certeza de que algo como o pbundler se tornará o padrão de fato. Infelizmente, nada muito estável ainda que eu saiba (mas adoraria ser provado que estou errado).

Eu escrevi um - https://github.com/Deepwalker/pundler . No PIP épundle , o nome já foi citado.

Ele usa requirements(_\w+)?.txtarquivos como dependências desejadas e criafrozen(_\w+)?.txt arquivos com versões congeladas.

Sobre a (_\w+)?coisa - isso é envs. Você pode criar requirements_test.txt e depois usarPUNDLEENV=test para usar esses deps em sua execução com os de requirements.txt ao lado.

E sobre virtualenv - você não precisa de um, é o que pundle tira do bundler na primeira cabeça.

Eu diria que Shovel vale uma olhada. Ele foi desenvolvido especificamente para a versão Pythonish do Rake. Não há uma tonelada de atividades de commit no projeto, mas parece estável e útil.

Python Poetry é o mais próximo do bundler Ruby em 2020 (e já desde 2018). Já tem mais de dois anos, ainda está muito ativo, tem ótima documentação. Alguém pode reclamar que o curl-pipe-python-style é a maneira recomendada de instalação, mas existem alternativas, por exemplo, homebrew no macOS.

• Site principal: https://python-poetry.org/
• Github: https://github.com/python-poetry/poetry
• Documentação: https://python-poetry.org/docs/

Ele usa o virtualenvs nos bastidores (em contraste com o bundler), mas fornece e usa um arquivo de bloqueio, cuida das subdependências, adere às restrições de versão especificadas e permite a atualização automática de pacotes desatualizados. Há até mesmo autocompletar para seu shell favorito.

Com o uso de um arquivo pyproject.toml, ele também vai um pouco além do bundler (mais próximo de um gemspec. Também é comparável ao npm e yarn do JavaScript e do TypeScript).

Poetrify (um projeto complementar) ajuda a converter projetos de requirements.txt em pyproject.toml para Poesia.

O arquivo de bloqueio pode ser exportado para requirements.txt por poetry export -f requirements.txt > requirements.txt, se você precisar disso para outras ferramentas (ou no caso improvável de querer voltar).

Não, todos os desenvolvedores usam virtualenv e / ou pip, mas muitos desenvolvedores usam / preferem essas ferramentas

E agora, para ferramentas de desenvolvimento de pacotes e diferentes ambientes, essa é a sua verdadeira questão. Existem outras ferramentas como Buildout ( http://www.buildout.org/en/latest/ ) para o mesmo propósito, isole o sistema de compilação Python de seu ambiente para cada projeto que você gerencia. Há algum tempo eu uso isso, mas agora não.

Ambientes independentes por projeto, em Python são um pouco diferentes que a mesma situação em Ruby. No meu caso, eu uso pyenv ( https://github.com/yyuu/pyenv ) que é algo como rbenv, mas, para Python. diferentes versões de python e virtualenvs por projeto e, nesses ambientes isolados, posso usar pip ou easy-install (se necessário).