Python: Venv e Poetry para criar ambientes virtuais

No desenvolvimento de software, a virtualização é como criar "cópias" do seu computador dentro do próprio computador. Imagine que você tem uma cozinha onde prepara diferentes tipos de comida.

Para não misturar os ingredientes, você cria estações separadas para cada receita.

A virtualização faz algo similar: cria espaços separados para que diferentes projetos de software possam ser desenvolvidos e testados sem interferir entre si.

Essa técnica é importante porque, no desenvolvimento de software, cada projeto pode ter suas próprias necessidades e dependências.

Usar a mesma "cozinha" para tudo poderia causar muitos problemas. Por exemplo, um projeto pode precisar de uma versão específica de uma biblioteca que não é compatível com outra versão usada em outro projeto… e aí teremos problemas, certo?

A virtualização permite que você tenha múltiplos ambientes, cada um configurado com as versões e dependências exatas que cada projeto precisa.

Além disso, a virtualização facilita a colaboração entre desenvolvedores. Se todos os membros da equipe usarem ambientes virtuais idênticos, será mais fácil compartilhar e testar o código sem se preocupar com diferenças na configuração dos computadores individuais.

Isso é como se todos na sua cozinha tivessem as mesmas ferramentas e ingredientes à disposição, garantindo que qualquer pessoa possa continuar a receita exatamente de onde outro parou, sem surpresas desagradáveis.

Mas como isso funciona em Python? O objetivo desse artigo é justamente explicar como usar Venv e Poetry no Python para criar e gerenciar ambientes virtuais de desenvolvimento

O que é Venv?

O Venv é uma ferramenta integrada ao Python que permite criar ambientes virtuais isolados.

Esses ambientes são importantes porque permitem que cada projeto tenha suas próprias dependências, sem interferir em outros projetos.

Isso é crucial para evitar conflitos de versão e garantir que o software funcione de maneira consistente em diferentes máquinas e configurações.

Em um mundo onde os projetos podem exigir diferentes versões de bibliotecas, o Venv torna-se uma solução simples e eficaz para gerenciar essas dependências.

O uso de Venv é recomendado pelo PEP 405 (Python Enhancement Proposal), que descreve a padronização para a criação de ambientes virtuais no Python.

O PEP 405 destaca a necessidade de isolar o ambiente de desenvolvimento para evitar que as dependências de um projeto afetem outros projetos ou o sistema global.

Seguir essas diretrizes ajuda a manter um ambiente de desenvolvimento limpo e organizado, reduzindo o risco de erros e incompatibilidades que podem surgir ao usar diferentes versões de pacotes.

Este PEP propõe adicionar ao Python um mecanismo para “ambientes virtuais” leves com seus próprios diretórios de sites, opcionalmente isolados dos diretórios de sites do sistema.

Cada ambiente virtual tem seu próprio binário Python (permitindo a criação de ambientes com várias versões Python) e pode ter seu próprio conjunto independente de pacotes Python instalados em seus diretórios de sites, mas compartilha a biblioteca padrão com o Python básico instalado.

Para utilizar o Venv, você deve primeiro criar um novo ambiente virtual. Isso pode ser feito com o comando:

python -m venv nome_do_ambiente

Esse comando cria uma nova pasta com todos os arquivos necessários para o ambiente virtual. Para ativar o ambiente, em sistemas Unix ou MacOS, use:

source nome_do_ambiente/bin/activate

No Windows, o comando é:

nome_do_ambiente\Scripts\activate

Quando o ambiente virtual está ativo, qualquer pacote instalado com pip será isolado dentro desse ambiente, sem afetar o sistema global.

Para desativar o ambiente virtual, basta usar o comando deactivate. Isso retorna o terminal ao ambiente global do sistema.

A desativação é importante para garantir que você não instale pacotes acidentalmente no ambiente virtual quando você estiver trabalhando em outro projeto.

Com esses passos simples, você pode criar, ativar e desativar ambientes virtuais de forma eficiente, garantindo um desenvolvimento mais organizado e livre de conflitos de dependências.

Além de criar e gerenciar ambientes virtuais com env, existem alguns comandos importantes no Python que ajudam a manter o ambiente organizado e documentado.

Por exemplo, pip freeze é um comando que lista todas as dependências instaladas no ambiente virtual junto com suas versões.

Esse comando é útil para verificar rapidamente quais pacotes estão presentes no seu ambiente.

Outro comando essencial é pip freeze > requirements.txt, que redireciona a saída do pip freeze para um arquivo chamado requirements.txt.

Esse arquivo pode ser compartilhado com outros desenvolvedores para garantir que todos usem as mesmas versões de pacotes, tornando o ambiente de desenvolvimento replicável e consistente.

Além desses, comandos como pip install -r requirements.txt permitem instalar todas as dependências listadas em um arquivo requirements.txt de uma só vez, e pip list fornece uma lista detalhada de todos os pacotes instalados, facilitando a gestão e atualização dos pacotes no seu ambiente virtual.

Ponto de atenção sobre Venv

Um dos problemas comuns com Venv é a gestão de dependências e suas versões, especialmente em projetos grandes ou quando se trabalha em equipe.

Manter o arquivo requirements.txt atualizado manualmente pode ser trabalhoso e propenso a erros.

Além disso, lidar com conflitos de versão e garantir que todos na equipe estejam usando exatamente as mesmas dependências pode ser desafiador. É aqui que o Poetry entra em cena.

Durante muitos anos, o processo de empacotamento de pacotes em Python era dominado por três ferramentas essenciais: setuptools, venv e pip.

Setuptools era usado para criar os pacotes Python, virtualenv para estabelecer ambientes virtuais isolados, e pip para instalar os pacotes dentro desses ambientes. Essas eram as escolhas comuns e amplamente adotadas.

Entretanto, em torno de 2016 - coincidentemente, o ano em que o arquivo pyproject.toml se tornou o padrão - começaram a surgir mudanças significativas nesse cenário.

O que é Poetry

Em 2015, Thomas Kluyver deu início ao desenvolvimento do Flit, uma alternativa no cenário de construção de pacotes Python que visava criar e disponibilizar pacotes no repositório PyPI.

Em paralelo, em 2016, Donald Stufft, integrante da equipe de manutenção do pip, começou a explorar o conceito do Pipfile, uma proposta destinada a substituir os tradicionais arquivos de requisitos, introduzindo um formato de arquivo de bloqueio.

Esses esforços culminaram em 2017 com o lançamento do Pipenv por Kenneth Reitz, uma ferramenta que permitia gerenciar dependências e ambientes para aplicativos Python de forma reproduzível.

Notavelmente, o Pipenv não empacotava o aplicativo diretamente, mas sim possibilitava a organização de diversos módulos Python em um repositório Git.

No ano de 2018, Sébastien Eustace deu início ao desenvolvimento do Poetry, que se destacou como a primeira ferramenta a oferecer uma abordagem integrada para empacotamento, gerenciamento de dependências e ambientes.

Sua proposta inovadora rapidamente ganhou adoção generalizada na comunidade Python.

O Poetry (que significa poesia em inglês) é uma ferramenta para gerenciamento de dependências e empacotamento em Python.

Ele permite que você declare as bibliotecas das quais seu projeto depende e irá gerenciá-las (instalá-las/atualizá-las) para você.

Além disso, o Poetry oferece um arquivo de bloqueio para garantir instalações repetíveis e pode construir seu projeto para distribuição.

O Poetry foi criado como uma alternativa moderna ao tradicional pip e venv.

Seu objetivo principal é simplificar e unificar o processo de gerenciamento de dependências e ambientes virtuais, fornecendo uma experiência mais intuitiva e consistente para os desenvolvedores Python.

Uma das principais dores que Poetry visa solucionar é a falta de controle sobre as dependências do projeto, juntamente com a dificuldade de garantir a criação do ambiente de desenvolvimento em diferentes máquinas.

Através do uso de um arquivo pyproject.toml, Poetry permite que os desenvolvedores especifiquem suas dependências de forma declarativa, facilitando a instalação e a atualização das mesmas.

Além disso, Poetry automatiza a criação e gerenciamento de ambientes virtuais, eliminando a necessidade de ferramentas adicionais como Venv.

Com isso, os desenvolvedores podem criar e compartilhar projetos de forma mais eficiente, garantindo a consistência e a portabilidade do ambiente de desenvolvimento Python.

Em suma, Poetry representa um avanço significativo no gerenciamento de dependências para projetos Python, simplificando o processo de desenvolvimento e melhorando a experiência do desenvolvedor.

Enquanto o arquivo pyproject.toml é usado pelo Poetry para especificar as dependências e configurações do projeto em Python, o arquivo package.json é a contraparte no ecossistema Node.js.

Ambos os arquivos têm o objetivo de fornecer uma maneira estruturada de definir as dependências do projeto e suas versões, além de outras configurações relevantes.

Para começar a usar o Poetry, você precisa ter o Python 3.8+ instalado. Depois, você pode instalá-lo usando uma ferramenta chamada pipx, que garante que ele seja isolado do resto do sistema.

Aqui está um exemplo de como você pode instalar o Poetry usando pipx:

pipx install poetry

A principal diferença entre o pip e o pipx está na forma como eles lidam com a instalação de pacotes Python.

Enquanto o pip é a ferramenta padrão para instalar pacotes Python, o pipx é uma extensão que visa facilitar a instalação de aplicativos Python de linha de comando de forma isolada.

O pip instala pacotes no ambiente global do Python, o que pode causar conflitos entre versões e dependências de diferentes projetos.

Por outro lado, o pipx cria ambientes virtuais isolados para cada aplicativo instalado, garantindo que eles não interfiram uns com os outros e simplificando a gestão de pacotes Python em ambientes compartilhados. Você pode instalar o pipx seguindo o passo a passo deste link.

Para atualizar ou desinstalar o Poetry, você pode usar comandos semelhantes:

pipx upgrade poetry
pipx uninstall poetry

Exemplo prático

Vou guiá-lo pelo processo de criar um novo projeto usando Poetry e Flask, incluindo a criação de uma rota "hello world".

Com o poetry instalado, execute o comando:

poetry new flask_hello

A seguinte estrutura foi criada:

├── flask_hello
│   ├── flask_hello
│   └── tests

Além disso, temos a criação do pyproject.toml:

[tool.poetry]
name = "flask-hello"
version = "0.1.0"
description = ""
authors = ["guilhermelima <[email protected]>"]
readme = "README.md"

[tool.poetry.dependencies]
python = "^3.12"

[build-system]
requires = ["poetry-core"]
build-backend = "poetry.core.masonry.api"

Este arquivo pyproject.toml é usado pelo Poetry para configurar um projeto chamado "flask-hello". Ele especifica metadados como nome, versão e descrição do projeto.

O autor do projeto é listado como "guilhermelima" com o endereço de e-mail.

Além disso, o arquivo indica que o projeto depende do Python versão 3.12. Essa seção também inclui uma referência ao arquivo README.md para a documentação do projeto.

O arquivo também contém uma seção de configuração para o sistema de construção, que especifica que o Poetry Core é necessário e que a backend de construção é fornecida pelo módulo poetry.core.masonry.api.

Agora, basta entrar no diretório do projeto:

cd flask_hello

Diferente da venv, podemos adicionar o Flask como dependência do projeto através do Poetry:

poetry add flask

Observe que o arquivo pyproject.toml foi atualizado incluindo o Flask como dependência do projeto e especificando sua versão:

[tool.poetry.dependencies]
python = "^3.12"
flask = "^3.0.3"

Vamos criar um arquivo Python, chamado app:

touch app.py

Abra o arquivo app.py em um editor de texto e adicione o seguinte código para criar um aplicativo Flask simples com uma rota "hello world":

from flask import Flask

app = Flask(__name__)

@app.route('/')
def hello_world():
    return 'Hello, World!'

if __name__ == '__main__':
    app.run(debug=True)

Vamos executar o aplicativo Flask?

poetry run python app.py

Agora você pode acessar a rota "hello world" em seu navegador ou usando ferramentas como cURL ou Postman, indo para http://127.0.0.1:5000/. Deverá ver a mensagem "Hello, World!" exibida.

Este é um aplicativo Flask básico configurado e executado usando Poetry.

O Poetry simplificou o processo de gerenciamento de dependências, permitindo que o Flask fosse adicionado ao projeto com um único comando, garantindo também a criação de um ambiente virtual isolado para o projeto.

Além disso, a execução do programa Flask foi feita usando o ambiente gerenciado pelo Poetry, garantindo que não houvesse conflitos com outras dependências ou projetos Python no sistema.

Essa abordagem demonstra a eficácia e a conveniência do Poetry como uma ferramenta abrangente para desenvolvimento de projetos Python.

Conclusão

Os usos do Venv e do Poetry desempenham papeis complementares no ecossistema de desenvolvimento Python.

O venv, uma ferramenta padrão do Python, é vital para criar ambientes virtuais isolados, o que garante que as dependências de um projeto não entrem em conflito com outras instalações de pacotes no sistema.

Isso é especialmente importante quando se trabalha em vários projetos Python simultaneamente, pois cada ambiente virtual mantém sua própria configuração de pacotes.

O venv é uma escolha pragmática para desenvolvedores que desejam controle direto sobre o gerenciamento de dependências e ambientes de desenvolvimento.

Por outro lado, o Poetry eleva o gerenciamento de dependências a um nível mais alto, simplificando significativamente o processo de criação, distribuição e manutenção de projetos Python.

Ao consolidar a lista de dependências em um único arquivo pyproject.toml, o Poetry facilita a declaração e a atualização das bibliotecas necessárias para um projeto.

Além disso, seu suporte integrado para a criação de pacotes distribuíveis e a garantia de instalações repetíveis tornam o Poetry uma escolha valiosa para equipes de desenvolvimento que valorizam a consistência e a criação de seus ambientes de desenvolvimento.

Ao combinar Venv e Poetry, os desenvolvedores podem desfrutar de um ecossistema Python robusto e eficiente, garantindo um fluxo de trabalho harmonioso desde o desenvolvimento até a produção.