DEV Community: Carine Neris

Estratégias de Lançamento de Software Progressivo: Além do Simples If/Else com Feature Flags

Carine Neris — Thu, 19 Feb 2026 01:43:09 +0000

E aí, pessoal! Já se pegaram suando frio antes de um deploy, pensando: "Será que essa nova funcionalidade vai quebrar tudo?" Ou talvez, "Como vamos testar isso em produção sem impactar os usuários?" Se sim, preparem-se para conhecer seu novo super-poder: os Feature Toggles (também conhecidos como Feature Flags)!

Inspirada no clássico artigo de Pete Hodgson no site do Martin Fowler [1], resolvi falar um pouco sobre essa técnica poderosa que permite alterar o comportamento do sistema sem mudar uma linha de código! Vamos ver como aplicar isso com Python e FastAPI, de um jeito prático.

O Que São Feature Toggles? Mais que um Simples Liga/Desliga!

Imagine que você está construindo um foguete espacial (seu software, claro!). Você tem várias seções novas: um motor de dobra espacial, um sistema de entretenimento holográfico, e um robô assistente. Você não quer lançar o foguete com tudo isso de uma vez sem testar, certo? E se o motor de dobra espacial der problema, você quer poder desligá-lo rapidamente sem ter que pousar o foguete e trocar a peça.

Feature Toggles são exatamente isso: chaves de controle no seu código que permitem ligar ou desligar funcionalidades específicas em tempo de execução. Elas desacoplam o deploy de código do lançamento de funcionalidades. Isso significa que você pode enviar código novo para produção (com a funcionalidade desligada) e ativá-la apenas quando estiver pronto, para quem quiser, ou sob certas condições.

As Categorias de Toggles

Pete Hodgson categoriza os Feature Toggles com base em sua longevidade e dinamismo. Entender essas categorias é crucial para usar os toggles de forma eficaz e evitar a temida "dívida técnica" de toggles antigos.

Categoria	Longevidade	Dinamismo	Propósito Principal	Exemplo de Uso	Gerenciamento
Release Toggles	Curta (dias/semanas)	Baixo	Habilitar/desabilitar funcionalidades incompletas ou para lançamento coordenado.	Lançar uma nova interface de usuário para todos os clientes em uma data específica.	Remover após o lançamento completo.
Experiment Toggles	Média (semanas)	Alto	Testes A/B, multivariados.	Mostrar duas versões de um botão de compra para diferentes grupos de usuários para ver qual converte mais.	Remover após o experimento e decisão.
Ops Toggles	Curta/Longa	Alto	Controle operacional, "kill switches".	Desabilitar uma funcionalidade de alto consumo de recursos em caso de pico de tráfego.	Manter alguns "kill switches" essenciais, remover outros após estabilidade.
Permissioning Toggles	Longa (meses/anos)	Alto	Personalização de experiência para usuários/grupos específicos.	Funcionalidades "premium" para assinantes, acesso antecipado para beta testers.	Podem ser permanentes, parte da lógica de negócio.

Mão na Massa: Implementando um Release Toggle com FastAPI

Vamos criar um cenário simples: uma API FastAPI que tem uma nova funcionalidade de "cálculo de frete otimizado". Queremos fazer o deploy do código, mas só ativar essa funcionalidade para um grupo seleto de usuários ou em um momento específico.

1. Setup Básico do Projeto

Primeiro, crie um projeto FastAPI (usando Poetry, claro!):

poetry new feature-toggle-app
cd feature-toggle-app
poetry add fastapi uvicorn

Crie um arquivo main.py:

# main.py

from fastapi import FastAPI

app = FastAPI()

@app.get("/")
async def hello_world():
    return {"status": "ok"}

2. O Nosso "Gerenciador" de Toggles

Para simplificar, vamos usar um dicionário simples para gerenciar nossos toggles. Em um cenário real, isso viria de um serviço externo (como LaunchDarkly, Unleash, ou um banco de dados/config server).

Crie um arquivo feature_flags.py:

# feature_flags.py

FEATURE_TOGGLES = {
    "OTIMIZED_SHIPPING": False, # Nosso Release Toggle
    "NEW_DASHBOARD_BETA": False, # Exemplo de Permissioning/Experiment Toggle
}

def is_feature_enabled(feature_name: str) -> bool:
    return FEATURE_TOGGLES.get(feature_name, False)

3. Integrando o Toggle no FastAPI

Agora, vamos usar nosso toggle na API. Adicionaremos um endpoint para o cálculo de frete. Se o toggle OTIMIZED_SHIPPING estiver False, ele usará o cálculo antigo. Se estiver True, usará o novo.

Atualize main.py:

# main.py

from fastapi import FastAPI, HTTPException
from feature_flags import is_feature_enabled

app = FastAPI()

@app.get("/")
async def hello_world():
    return {"status": "ok"}

@app.get("/shipping_cost/{item_id}")
async def get_shipping_cost(item_id: int):
    if is_feature_enabled("OTIMIZED_SHIPPING"):
        # Lógica do novo cálculo de frete otimizado
        cost = item_id * 0.5 # Exemplo: cálculo mais barato
        return {"item_id": item_id, "cost": cost, "method": "optimized"}
    else:
        # Lógica do cálculo de frete antigo
        cost = item_id * 1.0 # Exemplo: cálculo padrão
        return {"item_id": item_id, "cost": cost, "method": "standard"}

# Exemplo de um endpoint que só aparece se o toggle estiver ativo
@app.get("/admin/new_dashboard")
async def new_admin_dashboard():
    if not is_feature_enabled("NEW_DASHBOARD_BETA"):
        raise HTTPException(status_code=404, detail="New dashboard not available")
    return {"message": "Bem-vindo ao novo painel de administração beta!"}

Para rodar a aplicação:

poetry run uvicorn main:app --reload

Agora, você pode testar:

Acesse http://127.0.0.1:8000/shipping_cost/10. Você verá o método "standard".
Altere OTIMIZED_SHIPPING para True em feature_flags.py e salve. O uvicorn recarregará.
Acesse novamente http://127.0.0.1:8000/shipping_cost/10. Agora você verá o método "optimized"!

Isso é um Release Toggle em ação! Você pode fazer o deploy do código com a funcionalidade "desligada" e ativá-la quando quiser, sem um novo deploy.

Boas Práticas: Evitando a "Dívida Técnica" dos Toggles

Feature Toggles são poderosos, mas com grandes poderes vêm grandes responsabilidades. Sem cuidado, seu código pode virar uma teia de if/elses. Aqui vão algumas dicas:

Nomeie Bem Seus Toggles: Nomes claros como OTIMIZED_SHIPPING são melhores que FEATURE_A. O nome deve indicar o propósito da funcionalidade.
Mantenha a Taxonomia: Use as categorias (Release, Experiment, Ops, Permissioning) para guiar a longevidade e o gerenciamento.
Remova Toggles Obsoletos: Toggles de Release e Experiment devem ser removidos assim que cumprirem seu propósito. Eles são dívida técnica! Agende a remoção.
Isolamento de Código: Tente isolar o código da funcionalidade por trás do toggle. Evite espalhar if is_feature_enabled(...) por todo o codebase.
Testes: Teste ambos os caminhos (toggle ligado e desligado). Seus testes devem cobrir todas as variações.
Ferramentas de Gerenciamento: Para projetos maiores, considere usar ferramentas dedicadas como LaunchDarkly, Unleash, ou Split.io. Elas oferecem dashboards, segmentação de usuários, e gerenciamento centralizado.

Gerenciamento: Quando e Como Dizer Adeus aos Toggles

O maior desafio dos Feature Toggles é o gerenciamento. Um toggle de Release que fica muito tempo no código se torna um toggle de Permissioning ou Ops por acidente, adicionando complexidade desnecessária.

Release Toggles: Remova-os assim que a funcionalidade for totalmente lançada e estabilizada. Faça um refactor para remover o if e o código antigo.
Experiment Toggles: Remova-os após a conclusão do experimento e a decisão de manter ou descartar a funcionalidade.
Ops Toggles: Mantenha apenas os "kill switches" essenciais. Revise-os periodicamente.
Permissioning Toggles: Podem ser de longa duração, mas devem ser bem documentados e tratados como parte da lógica de negócio.

Conclusão: O Futuro da Entrega de Software é Flexível!

Feature Toggles são uma ferramenta essencial para equipes que buscam Continuous Delivery e Agilidade. Eles permitem que você:

Reduza o risco de deploys.
Faça testes A/B e experimentos em produção.
Libere funcionalidades para subconjuntos de usuários.
Reaja rapidamente a problemas em produção.

Ao adotar essa técnica com sabedoria, você não apenas melhora a qualidade do seu software, mas também a confiança e a velocidade da equipe.

Referências

[1] Fowler, Martin. "Feature Toggles (aka Feature Flags)". MartinFowler.com, 2017. Disponível em: https://martinfowler.com/articles/feature-toggles.html

Agora da pra fazer pequenos post aqui no DEV.to. Amei a nova feature.

Carine Neris — Wed, 18 Feb 2026 21:07:50 +0000

Diga Adeus ao Caos: Gerenciando Dependências Python com Poetry

Carine Neris — Thu, 12 Feb 2026 23:22:12 +0000

Você já se viu em um labirinto de requirements.txt desatualizados, venv que não ativam, e conflitos de dependência que parecem saídos de um filme de terror? Se a resposta é sim, respire fundo, porque seus problemas estão prestes a acabar (ou pelo menos, a ficar muito mais fácil de resolver!).

Hoje, vamos entrar no mundo mágico do Poetry [1], a ferramenta que veio para salvar nossos projetos do caos das dependências.

O Fim da Era do `pip` e `venv` Manual

Antes do Poetry, a vida era... rústica. Criávamos um venv na mão, ativávamos, rodávamos pip install -r requirements.txt, e torcíamos para que nada explodisse. E quando explodia, era uma caçada por versões compatíveis que podia durar horas.

O Poetry chega com uma proposta revolucionária: gerenciar tudo para você! Ele cuida das dependências, cria e gerencia seu ambiente virtual, e ainda garante que todos os seus colaboradores (e até seu servidor de produção) usem exatamente as mesmas versões de bibliotecas.

Primeiros Passos: Instalando o Poetry

Instalar o Poetry é moleza. Esqueça o pip install poetry (sim, é irônico, eu sei). A forma recomendada é usar o instalador oficial, que garante que o Poetry seja isolado do seu ambiente Python principal.

No Linux/macOS/WSL:

curl -sSL https://install.python-poetry.org | python3 -

No Windows (PowerShell):

(Invoke-WebRequest -Uri https://install.python-poetry.org -UseBasicParsing).Content | python -

Após a instalação, você pode precisar adicionar o diretório de binários do Poetry ao seu PATH. O instalador geralmente te informa o caminho. Depois, reinicie seu terminal e digite poetry --version para confirmar que tudo está funcionando.

Iniciando um Projeto Poetry: A Magia Começa!

Para começar um novo projeto com Poetry, é tão simples quanto:

poetry new meu_projeto_incrivel
cd meu_projeto_incrivel

Isso cria uma estrutura básica de projeto com um arquivo pyproject.toml, que é onde toda a mágica das dependências acontece. Se você já tem um projeto existente, pode inicializar o Poetry nele:

cd meu_projeto_existente
poetry init

O poetry init fará algumas perguntas sobre seu projeto e criará o pyproject.toml para você.

O Coração do Projeto: `pyproject.toml`

Este arquivo é o seu manifesto. Ele substitui o requirements.txt, setup.py, setup.cfg e MANIFEST.in (ufa!). Aqui você define metadados do projeto, dependências e até scripts. Veja um exemplo simplificado:

# pyproject.toml

[tool.poetry]
name = "meu-projeto-incrivel"
version = "0.1.0"
description = "Um projeto Python que vai mudar o mundo!"
authors = ["Seu Nome <seu.email@example.com>"]
readme = "README.md"

[tool.poetry.dependencies]
python = "^3.9" # Versão do Python que seu projeto usa
requests = "^2.28.1" # Uma dependência de produção
fastapi = "^0.100.0"
uvicorn = {extras = ["standard"], version = "^0.23.2"}

[tool.poetry.group.dev.dependencies]
pytest = "^7.4.0" # Uma dependência de desenvolvimento
ipdb = "^0.13.13"

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

Gerenciando Dependências: Adicionar, Remover, Atualizar

Adicionando Novas Bibliotecas

Para adicionar uma nova dependência de produção (aquela que seu código precisa para rodar em produção), use poetry add:

poetry add requests
# Ou com uma versão específica
poetry add beautifulsoup4@^4.12.2

O Poetry fará a mágica: ele encontra a melhor versão compatível, instala a biblioteca e suas sub-dependências, e atualiza o pyproject.toml e o poetry.lock.

Dependências de Desenvolvimento

Ferramentas como pytest, black, flake8 são essenciais para o desenvolvimento, mas não precisam ir para produção. Para elas, usamos a flag --group dev (ou -D):

poetry add pytest --group dev
# Ou a forma curta
poetry add black -D

Elas serão listadas na seção [tool.poetry.group.dev.dependencies] do seu pyproject.toml.

Removendo uma Biblioteca

Não precisa mais de uma biblioteca? Sem problemas:

poetry remove requests
# Para remover uma dependência de desenvolvimento
poetry remove pytest --group dev

O Poetry desinstala a biblioteca e atualiza seus arquivos de configuração.

Atualizando Dependências

Para atualizar todas as dependências para as versões mais recentes compatíveis com seu pyproject.toml:

poetry update

Se quiser atualizar uma biblioteca específica:

poetry update requests

O Segredo da Consistência: `poetry.lock`

Quando você adiciona ou atualiza uma dependência, o Poetry cria (ou atualiza) um arquivo chamado poetry.lock. Este arquivo é um tesouro! Ele registra exatamente quais versões de todas as dependências (diretas e transitivas) foram instaladas e funcionaram juntas.

Por que isso é incrível?

Reprodutibilidade: Garante que, não importa onde seu projeto seja clonado ou implantado, ele sempre terá as mesmas versões de bibliotecas.
Estabilidade: Evita que atualizações inesperadas de sub-dependências quebrem seu código.

Regra de Ouro: Sempre comite o poetry.lock no seu controle de versão (Git)! Ele é tão importante quanto seu código.

Ambientes Virtuais: Onde o Poetry Brilha

O Poetry cria e gerencia automaticamente ambientes virtuais para seus projetos. Você não precisa mais de python -m venv .venv ou source .venv/bin/activate! O Poetry faz isso nos bastidores.

Para executar um comando dentro do ambiente virtual do seu projeto:

poetry run python meu_script.py
poetry run pytest

Se você realmente quiser entrar no ambiente virtual (para depuração, por exemplo):

poetry shell

Isso ativa o ambiente virtual na sua sessão do terminal. Para sair, digite exit.

Comandos Essenciais para o Dia a Dia

Comando	Descrição	Exemplo
`poetry install`	Instala todas as dependências listadas no `poetry.lock` (ou `pyproject.toml` se o lockfile não existir). Ideal para configurar um projeto pela primeira vez.	`poetry install`
`poetry install --no-root`	Instala apenas as dependências, sem instalar o próprio projeto como um pacote. Útil em ambientes de produção.	`poetry install --no-root`
`poetry install --only main`	Instala apenas as dependências de produção.	`poetry install --only main`
`poetry install --only dev`	Instala apenas as dependências de desenvolvimento.	`poetry install --only dev`
`poetry show`	Lista todas as dependências instaladas no projeto.	`poetry show`
`poetry show --tree`	Mostra as dependências em formato de árvore.	`poetry show --tree`
`poetry env list`	Lista os ambientes virtuais associados ao projeto.	`poetry env list`
`poetry env use python3.10`	Define qual interpretador Python usar para o ambiente virtual.	`poetry env use python3.10`

Conclusão: Sua Vida Python Nunca Mais Será a Mesma!

O Poetry não é apenas uma ferramenta; é uma filosofia de gerenciamento de projetos Python. Ele simplifica o fluxo de trabalho, aumenta a reprodutibilidade e permite que você se concentre no que realmente importa: escrever código incrível.

Então, da próxima vez que você iniciar um projeto Python, dê uma chance ao Poetry. Seu eu do futuro (e seus colegas de equipe) agradecerão! Diga adeus ao caos.

Referências

[1] Poetry Documentation: https://python-poetry.org/docs/
[2] PEP 518 – Specifying build system dependencies for Python projects: https://peps.python.org/pep-0518/

Alembic: Versionamento de Banco de Dados (Parte 2)

Carine Neris — Thu, 12 Feb 2026 23:07:36 +0000

Na Parte 1 deste artigo, aprendemos um pouco sobre os fundamentos do Alembic, como inicializar o ambiente de migração e como criar migrações manuais. Agora, vamos elevar o nível e descobrir como automatizar esse processo e como lidar com bancos de dados que já possuem dados e tabelas.

Automatizando Migrações com `--autogenerate`

Um dos recursos mais poderosos do Alembic é a sua capacidade de detectar automaticamente as mudanças nos seus modelos SQLAlchemy e gerar os scripts de migração correspondentes. Isso economiza tempo e reduz erros humanos ao escrever DDL manualmente.

1. Configurando o `target_metadata`

Para que o recurso de autogeração funcione, o Alembic precisa saber onde encontrar a definição dos seus modelos (o objeto MetaData). Isso é configurado no arquivo migrations/env.py.

Localize a variável target_metadata e importe o seu objeto Base.metadata (ou equivalente):

# migrations/env.py

# Importe o seu objeto Base ou os seus modelos
from my_app.models import Base 

# ...

# Defina o target_metadata
target_metadata = Base.metadata

# ...

Dica: Certifique-se de que todos os seus modelos foram importados antes de definir o target_metadata, caso contrário, o Alembic não conseguirá detectá-los.

2. Gerando a Migração Automática

Com o target_metadata configurado, você pode usar a flag --autogenerate ao criar uma nova revisão:

alembic revision --autogenerate -m "add_profile_column_to_users"

O Alembic irá comparar o estado atual do banco de dados com a definição nos seus modelos SQLAlchemy e gerará automaticamente as funções upgrade() e downgrade() com as alterações detectadas (ex: op.add_column, op.create_table).

Atenção: Sempre revise o arquivo gerado! O Alembic é excelente, mas algumas mudanças complexas (como renomear colunas) podem exigir ajustes manuais no script gerado[1].

Começando com um Banco de Dados Existente

Um cenário muito comum é querer introduzir o Alembic em um projeto que já está em andamento e possui um banco de dados populado com tabelas. Se você simplesmente rodar upgrade head, o Alembic tentará criar tabelas que já existem, resultando em erro.

Para resolver isso, usamos o processo de Baselining[2].

Passo 1: Criar a Migração de "Estado Zero"

Primeiro, gere uma migração que represente o estado atual do seu banco de dados:

alembic revision --autogenerate -m "baseline_initial_state"

Se seus modelos SQLAlchemy estiverem em sincronia com o banco de dados atual, o script gerado pode vir quase vazio. Se houver discrepâncias, ele conterá os comandos para criar as tabelas existentes.

Passo 2: O Comando `stamp`

Em vez de executar essa migração (que falharia ao tentar criar o que já existe), você deve dizer ao Alembic que o banco de dados já está naquela versão. Para isso, usamos o comando stamp:

alembic stamp head

O comando stamp cria a tabela alembic_version no seu banco de dados e insere o ID da revisão mais recente (o head), sem executar nenhum código de migração. A partir deste momento, o Alembic "sabe" onde o banco está e você pode começar a criar novas migrações normalmente para as próximas alterações.

Melhores Práticas e Arquitetura

Ao trabalhar com Alembic e SQLAlchemy Core, considere estas diretrizes para manter uma arquitetura de banco de dados saudável:

Prática	Descrição
Scripts Atômicos	Cada migração deve focar em uma única alteração lógica (ex: adicionar uma tabela ou um conjunto de colunas relacionadas).
Teste de Downgrade	Sempre teste se o comando `downgrade` funciona corretamente para evitar ficar "preso" em uma versão quebrada.
Integração no CI/CD	Automatize o comando `alembic upgrade head` no seu pipeline de deploy para garantir que o banco de dados esteja sempre sincronizado com o código.
Cuidado com Dados	Migrações DDL alteram estrutura. Se precisar migrar dados (ex: transformar uma string em um JSON), você pode usar `op.execute()` dentro do script de migração.

Conclusão

O Alembic transforma o gerenciamento de banco de dados de uma tarefa manual e arriscada em um processo versionado e automatizado. Seja começando um projeto do zero ou organizando um legado, ele é a ferramenta indispensável para qualquer desenvolvedor Python que preza por agilidade e segurança na arquitetura de dados.

Referências

[1] Alembic Autogenerate Guide: https://alembic.sqlalchemy.org/en/latest/autogenerate.html
[2] Handling Existing Databases with Alembic: https://alembic.sqlalchemy.org/en/latest/tutorial.html#stamping-the-database

Alembic: Versionamento de Banco de Dados

Carine Neris — Thu, 12 Feb 2026 23:03:50 +0000

A Dor da Evolução do Banco de Dados em Projetos Ágeis

Em projetos de desenvolvimento de software, especialmente aqueles que adotam metodologias ágeis, a arquitetura do banco de dados está em constante evolução. Refatorar o esquema do banco de dados no meio do projeto pode se tornar uma grande dor de cabeça, impactando diretamente as entregas e a estabilidade da aplicação. Mudanças em tabelas, colunas ou relacionamentos precisam ser coordenadas cuidadosamente entre os desenvolvedores e aplicadas de forma consistente em diferentes ambientes (desenvolvimento, homologação, produção).

É nesse cenário que o versionamento de banco de dados se torna não apenas uma boa prática, mas uma necessidade crítica. Assim como versionamos o código-fonte da nossa aplicação para rastrear alterações, reverter para versões anteriores e colaborar de forma eficiente, precisamos de uma abordagem similar para o esquema do nosso banco de dados.

Alembic: A Solução para Evolução Controlada do Banco de Dados

O Alembic[1] é uma ferramenta de migração de banco de dados leve, desenvolvida para o SQLAlchemy[2], o popular toolkit SQL e Object-Relational Mapper (ORM). Ele permite que você evolua o esquema do seu banco de dados de forma incremental e controlada, garantindo que as alterações sejam aplicadas de maneira previsível e reversível.

O Alembic trabalha diretamente com a camada de Data Definition Language (DDL), ou seja, as operações que definem a estrutura do banco de dados (criar tabelas, adicionar colunas, etc.). Ele gera scripts de migração que podem ser executados para upgrade (aplicar mudanças) ou downgrade (reverter mudanças), proporcionando um controle total sobre o estado do seu esquema.

Configurando o Alembic em Seu Projeto

Para começar a usar o Alembic em seu projeto Python, siga os passos abaixo:

1. Instalação

Primeiro, adicione o Alembic como uma dependência do seu projeto. Se você estiver usando poetry para gerenciamento de dependências, execute:

poetry add alembic

Ou, se preferir pip:

pip install alembic

2. Inicialização do Ambiente de Migração

Após a instalação, você precisa inicializar o ambiente de migração do Alembic. Isso criará uma estrutura de diretórios e arquivos de configuração essenciais. O comando alembic init cria uma pasta onde suas migrações serão armazenadas e um arquivo de configuração principal.

alembic init migrations

Este comando criará um diretório migrations (ou o nome que você especificar) e um arquivo alembic.ini na raiz do seu projeto. O diretório migrations conterá:

env.py: O ambiente de execução do Alembic, onde você configura como o Alembic interage com seu banco de dados e modelos SQLAlchemy.
script.py.mako: Um template para novos scripts de migração.
versions/: Um diretório onde os arquivos de migração gerados serão armazenados.

3. Configuração do `alembic.ini`

O arquivo alembic.ini é o coração da configuração do Alembic. Ele contém configurações gerais, como a URL de conexão com o banco de dados. Por padrão, ele é configurado para um único banco de dados.

Localize a linha sqlalchemy.url e atualize-a com a string de conexão do seu banco de dados. Por exemplo:

# alembic.ini

[alembic]
...
sqlalchemy.url = postgresql://user:password@host:port/database_name
# ou para SQLite
# sqlalchemy.url = sqlite:///./sql_app.db
...

Importante: Para ambientes de produção, é uma boa prática usar variáveis de ambiente para a string de conexão do banco de dados, em vez de codificá-la diretamente no alembic.ini. Você pode configurar isso no arquivo env.py para ler a URL de uma variável de ambiente.

Criando Sua Primeira Migração (Manual)

Com o Alembic configurado, você pode criar sua primeira migração. Uma migração é um script Python que descreve as alterações no esquema do banco de dados. Cada migração possui duas funções principais:

upgrade(): Contém o código para aplicar as alterações no banco de dados.
downgrade(): Contém o código para reverter as alterações feitas por upgrade().

Para criar um novo arquivo de migração, use o comando alembic revision:

alembic revision -m "create_initial_tables"

Este comando gerará um novo arquivo Python no diretório versions/ (ex: xxxxxxxxxxxx_create_initial_tables.py). O nome do arquivo incluirá um identificador único e a mensagem que você forneceu. O conteúdo será similar a este:

# versions/xxxxxxxxxxxx_create_initial_tables.py

from alembic import op
import sqlalchemy as sa


# revision identifiers, used by Alembic.
revision = 'xxxxxxxxxxxx'
down_revision = None
branch_labels = None
depends_on = None

def upgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
    pass
    # ### end Alembic commands ###

def downgrade() -> None:
    # ### commands auto generated by Alembic - please adjust! ###
    pass
    # ### end Alembic commands ###

Neste ponto, você preencheria as funções upgrade() e downgrade() com as operações DDL necessárias, usando as construções do SQLAlchemy Core. Por exemplo, para criar uma tabela users:

# versions/xxxxxxxxxxxx_create_initial_tables.py

from alembic import op
import sqlalchemy as sa


# revision identifiers, used by Alembic.
revision = 'xxxxxxxxxxxx'
down_revision = None
branch_labels = None
depends_on = None

def upgrade() -> None:
    op.create_table(
        'users',
        sa.Column('id', sa.Integer, primary_key=True),
        sa.Column('name', sa.String(50), nullable=False),
        sa.Column('email', sa.String(100), unique=True, nullable=False)
    )

def downgrade() -> None:
    op.drop_table('users')

Para aplicar esta migração ao seu banco de dados, execute:

alembic upgrade head

O comando head instrui o Alembic a aplicar todas as migrações pendentes até a mais recente. Se você precisar reverter a última migração, use:

alembic downgrade -1

Próximos Passos: Migrações Automáticas e Bancos Existentes

Na Parte 2 deste artigo, exploraremos como o Alembic pode gerar migrações automaticamente com base nas mudanças detectadas em seus modelos SQLAlchemy, um recurso que agiliza significativamente o processo de desenvolvimento. Também abordaremos o desafio de integrar o Alembic a um banco de dados que já possui tabelas existentes, um cenário comum em projetos legados ou em andamento.

Referências

[1] Alembic Documentation: https://alembic.sqlalchemy.org/en/latest/
[2] SQLAlchemy Documentation: https://www.sqlalchemy.org/

Como Baixar, Quantizar e Rodar um Modelo LLM Localmente com Ollama

Carine Neris — Tue, 11 Nov 2025 23:09:51 +0000

Rodar um modelo de linguagem grande (LLM) no seu próprio computador pode parecer coisa de outro mundo — e, pra ser sincera, eu também achava isso 😅. Mas a curiosidade falou mais alto, e eu decidi tentar rodar o modelo Jurema-7B (baseado no LLaMA 3), só por estudo... e deu certo!
Consegui fazer todo o processo e colocar o modelo pra conversar comigo localmente, direto do meu computador.

Neste guia, eu vou te mostrar o passo a passo que segui pra fazer isso funcionar:

Baixar um modelo no Hugging Face — no meu caso, usei o Jurema-7B.
Converter o modelo para .gguf, o formato compatível com o Ollama.
Compilar o llama.cpp para ter acesso à ferramenta de quantização.
Quantizar o modelo pra economizar memória da GPU e CPU.
Adicionar o modelo ao Ollama e começar a conversar com ele, tudo rodando localmente.

Todo o processo foi feito no Windows, mas se você usa Linux ou macOS, a lógica é praticamente a mesma — muda só o jeito de instalar algumas dependências.

🧰 Pré-requisitos

Antes de começar, tenha instalado:

  choco install mingw

Ollama

💡 Dica: depois de instalar o MinGW, adicione C:\mingw64\bin ao seu PATH.
Se você instalou via Chocolatey, o caminho é adicionado automaticamente. 😉

📥 1️⃣ Baixando o modelo Jurema-7B

Para este exemplo, usei o Jurema-7B, o mesmo modelo que explorei durante meus estudos.
Ele é um LLM especializado no domínio jurídico brasileiro, criado a partir de um fine-tuning do Qwen2.5-7B-Instruct.

Você pode baixá-lo diretamente do Hugging Face com o comando:

git clone https://huggingface.co/Jurema-br/Jurema-7B

⚠️ Se aparecer um erro de autenticação, basta usar o Access Token do Hugging Face em vez da senha.

Isso vai criar uma pasta:

Jurema-7B/
 ├── config.json
 ├── model.safetensors
 ├── tokenizer.json
 └── ...

🧠 2️⃣ Baixando e compilando o llama.cpp

O llama.cpp é o projeto que permite rodar e quantizar modelos LLaMA em praticamente qualquer hardware.

Clone o repositório:

git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp

Agora, compile o projeto:

cmake -S . -B build -G "MinGW Makefiles"
cmake --build build --config Release

Isso vai gerar vários binários dentro da pasta build/bin, incluindo o quantize.exe, que é o executável responsável por quantizar o modelo (ou seja, reduzir o tamanho e o consumo de memória sem perder muita qualidade).

⚙️ 3️⃣ Convertendo e Quantizando o modelo

Primeiro, converta o modelo para o formato .gguf, que é o formato usado pelo Ollama para rodar modelos localmente:

python convert_hf_to_gguf.py "path_para_llm\Jurema-7B" --outfile "jurema-7b-fp16.gguf"

Agora vamos quantizar o modelo para reduzir tamanho e uso de memória.

Exemplo: Q4_K_M (boa precisão com economia de RAM).

llama.cpp\build\bin\quantize.exe jurema-7b-fp16.gguf jurema-7b-q4.gguf Q4_K_M

🔹 O arquivo jurema-7b-q4.gguf é o modelo quantizado final que usaremos no Ollama.

💬 4️⃣ Adicionando ao Ollama

Crie um arquivo chamado Modelfile:

FROM path_para_llm\Jurema-7B\jurema-7b-q4.gguf

TEMPLATE """### Instrução: {{ .Prompt }} ### Resposta: """
PARAMETER temperature 0.3
PARAMETER top_p 0.8
PARAMETER num_predict 512
PARAMETER stop ["<|im_end|>", "</s>", "User:", "Human:", "###"]

Agora, crie o modelo no Ollama:

ollama create jurema -f Modelfile

E rode:

ollama run jurema

Pronto 🎉
Você agora tem o Jurema-7B rodando localmente no Ollama!

🧠 5️⃣ Evitando loops infinitos nas respostas

Alguns modelos podem acabar “entrando em loop”, ou seja, continuar gerando texto indefinidamente sem concluir a resposta.
Aconteceu isso comigo ao testar o Jurema-7B, mas pesquisando um pouco encontrei a solução no próprio repositório do modelo

Adicione stop tokens no Modelfile.
Use num_predict para limitar o número de tokens.
Mantenha temperature baixa (0.3~0.5).

Exemplo de chamada via CLI com limite de tokens:

ollama run jurema --num-predict 300

⚡ 6️⃣ Dicas extras

Use Q4_K_M ou Q5_K_S para bom equilíbrio entre desempenho e precisão.
Se sua GPU for poderosa (ex: RTX 4070+) e você tiver boa quantidade de RAM, teste Q6 ou até Q8.

Esse processo não serve apenas para o Jurema-7B — você pode usar o mesmo passo a passo para qualquer modelo disponível no Hugging Face que precise ser convertido para rodar no Ollama ou quantizado para otimizar desempenho e consumo de memória

🧠 Referências

Precisamos falar sobre o Hugging Face: o GitHub da Inteligência Artificial

Carine Neris — Tue, 11 Nov 2025 01:27:12 +0000

Nos últimos anos, o termo Hugging Face começou a aparecer em quase todas as conversas sobre inteligência artificial.
Ele está por trás de muitos dos modelos que usamos — desde análise de sentimentos até geração de imagens com IA.

Mas afinal, o que é o Hugging Face?
E por que ele é considerado o GitHub da IA?

Neste artigo, você vai entender de forma simples o que é o Hugging Face, como ele funciona e por que ele se tornou essencial para quem desenvolve com machine learning e IA generativa. 🚀

🤔 O que é o Hugging Face?

O Hugging Face é uma plataforma open source que reúne modelos, datasets e ferramentas para desenvolvimento de inteligência artificial.

Se o GitHub é onde os desenvolvedores compartilham código, o Hugging Face é onde eles compartilham modelos de IA prontos para uso.

Ele começou em 2016 como um simples chatbot, mas rapidamente se transformou em um ecossistema completo de machine learning, apoiado por empresas como Google, Meta e Microsoft.

🧠 O coração do Hugging Face: o Model Hub

O Model Hub é o repositório principal da plataforma, onde você encontra milhares de modelos treinados em diferentes tarefas de IA.

Alguns exemplos populares:

🗣️ bert-base-uncased — modelo BERT da Google para NLP
💬 gpt2 — modelo de linguagem da OpenAI
🖼️ stable-diffusion — geração de imagens
🎧 whisper — transcrição de áudio

Você pode testar qualquer um desses modelos com apenas duas linhas de código.

from transformers import pipeline

# Exemplo: análise de sentimentos
analisador = pipeline("sentiment-analysis")
resultado = analisador("Eu adoro programar com Python!")
print(resultado)

Saída:

[{'label': 'POSITIVE', 'score': 0.9995}]

Simples, direto e sem precisar treinar nada! 💡

🧰 Principais bibliotecas do ecossistema Hugging Face

A força do Hugging Face está nas suas bibliotecas open source, que cobrem desde processamento de texto até geração de imagens:

🔹 `transformers`

Permite acessar e usar milhares de modelos pré-treinados para texto, visão e áudio.

🔹 `datasets`

Facilita o download e a manipulação de datasets prontos para IA.

🔹 `tokenizers`

Responsável por converter texto em números — um passo essencial para qualquer modelo de linguagem.

🔹 `diffusers`

Biblioteca usada em geração de imagens, como o Stable Diffusion.

🔹 `accelerate`

Ajuda a treinar modelos em múltiplas GPUs, TPUs ou até em nuvem com pouquíssimas alterações no código.

☁️ Hugging Face Hub e APIs

Além das bibliotecas open source, o Hugging Face também oferece uma plataforma em nuvem.

Com ela, você pode:

Hospedar seus próprios modelos
Criar APIs de inferência com um clique
Integrar modelos de IA em sistemas web, mobile ou backend

Tudo isso sem precisar configurar servidores ou infraestrutura complexa.

O Hugging Face é muito mais do que uma biblioteca — é uma comunidade global que está democratizando o acesso à Inteligência Artificial.
Se você quer aprender NLP, treinar modelos ou criar aplicações com IA generativa, o Hugging Face é um bom ponto de partida.

🔗 Recursos úteis

Manus AI: Transform Ideas into Action with Your New Autonomous Workmate (Invite Code)

Carine Neris — Tue, 05 Aug 2025 12:39:53 +0000

Imagine having an assistant that not only understands your needs but also executes complex tasks completely autonomously. We're not talking about another chatbot or text generation tool – we're talking about Manus AI, the world's first general artificial intelligence agent that truly connects thought and action.

Whether you're a developer, analyst, content creator, or simply someone looking to optimize your workflow, this article will show you how Manus AI can revolutionize the way you work and live.

What Is Manus AI?

Manus AI is an autonomous artificial intelligence agent developed by the Chinese startup Monica, based in Singapore [1]. The name "Manus" comes from Latin and means "hands," perfectly symbolizing its purpose: to be the hands that execute what your mind conceives.

Unlike other AI tools that are limited to generating text or answering questions, Manus AI is capable of:

Planning and executing complex tasks completely autonomously
Interacting with multiple tools and platforms simultaneously
Making decisions based on defined context and objectives
Producing tangible results such as websites, reports, analyses, and much more

What makes Manus AI truly special is its ability to function as a general agent – this means it's not specialized in a single task but can adapt and learn to perform practically any activity you need to carry out on a computer connected to the internet.

What Can Manus AI Do for You?

Development and Programming

For developers, Manus AI is like having a senior colleague available 24/7. It can:

Create complete applications from planning to deployment
Debug code and identify complex problems
Generate detailed and updated technical documentation
Implement APIs and integrations between systems
Optimize performance of existing applications

Research and Data Analysis

Manus AI excels at tasks requiring deep research and critical analysis:

Conduct comprehensive research across multiple sources
Analyze large volumes of data and extract insights
Create executive reports with visualizations and recommendations
Monitor market and technology trends
Validate information through automated fact-checking

Content Creation and Design

Whether for marketing, education, or entertainment, Manus AI can:

Produce long and well-structured technical articles
Create professional presentations with attractive designs
Develop responsive and functional websites
Generate personalized images and videos
Write clear and accessible documentation

Process Automation

One of Manus AI's greatest strengths is its ability to automate complex workflows:

Schedule and execute tasks at specific times
Integrate different tools and platforms
Monitor systems and alert about problems
Process forms and input data
Manage communications and follow-ups

Why Use Manus AI?

1. True Autonomy

While other AI tools require constant supervision and detailed prompts, Manus AI works genuinely autonomously. You define the objective, and it plans and executes all necessary steps to achieve it [2].

2. Unprecedented Versatility

As a general agent, Manus AI is not limited to specific domains. It can switch between programming, design, research, data analysis, and content creation as needed to complete its tasks.

3. Exponential Efficiency

Manus AI can work 24 hours a day, 7 days a week, without breaks or fatigue. This means you can literally wake up to completed projects that were developed while you slept [3].

4. Professional Quality

The results produced by Manus AI meet high professional standards, with attention to detail, logical structure, and polished presentation.

5. Continuous Learning

The system learns from each interaction, becoming more efficient and aligned with your preferences and specific needs over time.

How to Use Manus AI: A Practical Guide

Getting Started

Access the platform via the official website (manus.im) or mobile app
Define your objective clearly and specifically
Provide relevant context about your preferences and requirements
Let Manus AI work while you focus on other activities

Tips for Maximizing Results

Be Specific, But Don't Micromanage

❌ "Create a website"
✅ "Create a portfolio website for a frontend developer, with sections on projects, skills, and contact, using a modern and responsive design"

Provide Relevant Context

Mention your target audience
Specify style or technology preferences
Include examples or references when possible

Leverage Planning Capability
Manus AI excels at multi-step projects. Don't hesitate to request complex tasks that would normally take days or weeks to complete.

Advanced Use Cases

For Startups:

Complete MVP development
Market research and competitive analysis
Creation of pitch decks and marketing materials

For Businesses:

Automation of periodic reports
Sales and performance data analysis
Development of internal tools

For Freelancers:

Management of multiple projects simultaneously
Creation of proposals and quotes
Development of customized solutions for clients

The Future of Work with AI

Manus AI represents a milestone in the evolution of artificial intelligence applied to work. We are witnessing the transition from tools that help us work to agents that work with us – and sometimes for us.

This change does not mean human replacement but rather an amplification of our capabilities. With Manus AI handling operational and repetitive tasks, we can focus on what truly matters: strategy, creativity, relationships, and innovation.

Impact on Productivity

Users report productivity increases of 300% to 500% in tasks that Manus AI can execute autonomously [4]. This is not just about doing things faster – it's about doing more things, better things, and having time to think strategically.

Democratization of Skills

Manus AI democratizes advanced technical skills. You don't need to be an experienced developer to create a functional web application, nor a designer to produce professional visual materials.

Conclusion: Your Journey with Manus AI Starts Now

Manus AI is not just another tool – it's a new work paradigm. It represents the fulfillment of the promise that technology should free us to focus on what we do best: thinking, creating, and innovating.

If you're ready to experience the future of work today, Manus AI is waiting to become your most productive new team member. The only question left is: what will you create first?

Want to try Manus AI? Start your journey today and see how AI can transform the way you work.

👉 Create your account using this link to get extra credits

Manus AI: O que é? + Invitation Code

Carine Neris — Tue, 05 Aug 2025 02:14:49 +0000

Imagine ter um assistente que não apenas entende suas necessidades, mas também executa tarefas complexas de forma completamente autônoma. Não estamos falando de mais um chatbot ou ferramenta de geração de texto — estamos falando do Manus AI, o primeiro agente de inteligência artificial geral do mundo que verdadeiramente conecta pensamento e ação. (Se quiser experimentar, você pode se cadastrar neste link e ganhar créditos extras).

Se você é desenvolvedor, analista, criador de conteúdo ou simplesmente alguém que busca otimizar seu fluxo de trabalho, este artigo vai mostrar como o Manus AI pode revolucionar a forma como você trabalha e vive.

O Que É o Manus AI?

O Manus AI é um agente de inteligência artificial autônomo desenvolvido pela startup chinesa Monica, sediada em Singapura [1]. O nome "Manus" vem do latim e significa "mãos", simbolizando perfeitamente sua proposta: ser as mãos que executam aquilo que sua mente concebe.

Diferentemente de outras ferramentas de IA que se limitam a gerar texto ou responder perguntas, o Manus AI é capaz de:

Planejar e executar tarefas complexas de forma completamente autônoma
Interagir com múltiplas ferramentas e plataformas simultaneamente
Tomar decisões baseadas em contexto e objetivos definidos
Produzir resultados tangíveis como websites, relatórios, análises e muito mais

O que torna o Manus AI verdadeiramente especial é sua capacidade de funcionar como um agente geral - isso significa que ele não é especializado em uma única tarefa, mas pode adaptar-se e aprender a executar praticamente qualquer atividade que você precise realizar em um computador conectado à internet.

O Que o Manus AI Pode Fazer Por Você?

Desenvolvimento e Programação

Para desenvolvedores, o Manus AI é como ter um colega sênior disponível 24/7. Ele pode:

Criar aplicações completas desde o planejamento até o deploy
Debuggar código e identificar problemas complexos
Gerar documentação técnica detalhada e atualizada
Implementar APIs e integrações entre sistemas
Otimizar performance de aplicações existentes

Pesquisa e Análise de Dados

O Manus AI excele em tarefas que exigem pesquisa profunda e análise crítica:

Conduzir pesquisas abrangentes em múltiplas fontes
Analisar grandes volumes de dados e extrair insights
Criar relatórios executivos com visualizações e recomendações
Monitorar tendências de mercado e tecnologia
Validar informações através de fact-checking automatizado

Criação de Conteúdo e Design

Seja para marketing, educação ou entretenimento, o Manus AI pode:

Produzir artigos técnicos longos e bem estruturados
Criar apresentações profissionais com design atrativo
Desenvolver websites responsivos e funcionais
Gerar imagens e vídeos personalizados
Escrever documentação clara e acessível

Automação de Processos

Uma das maiores forças do Manus AI é sua capacidade de automatizar fluxos de trabalho complexos:

Agendar e executar tarefas em horários específicos
Integrar diferentes ferramentas e plataformas
Monitorar sistemas e alertar sobre problemas
Processar formulários e dados de entrada
Gerenciar comunicações e follow-ups

Por Que Usar o Manus AI?

1. Autonomia Verdadeira

Enquanto outras ferramentas de IA requerem supervisão constante e prompts detalhados, o Manus AI trabalha de forma genuinamente autônoma. Você define o objetivo, e ele planeja e executa todas as etapas necessárias para alcançá-lo [2].

2. Versatilidade Sem Precedentes

Como um agente geral, o Manus AI não está limitado a domínios específicos. Ele pode alternar entre programação, design, pesquisa, análise de dados e criação de conteúdo conforme necessário para completar suas tarefas.

3. Eficiência Exponencial

O Manus AI pode trabalhar 24 horas por dia, 7 dias por semana, sem pausas ou fadiga. Isso significa que você pode literalmente acordar com projetos completos que foram desenvolvidos enquanto você dormia [3].

4. Qualidade Profissional

Os resultados produzidos pelo Manus AI atendem a padrões profissionais elevados, com atenção a detalhes, estrutura lógica e apresentação polida.

5. Aprendizado Contínuo

O sistema aprende com cada interação, tornando-se mais eficiente e alinhado com suas preferências e necessidades específicas ao longo do tempo.

Como Usar o Manus AI: Guia Prático

Primeiros Passos

Acesse a plataforma através do site oficial (manus.im) ou aplicativo móvel
Defina seu objetivo de forma clara e específica
Forneça contexto relevante sobre suas preferências e requisitos
Deixe o Manus AI trabalhar enquanto você foca em outras atividades

Dicas Para Maximizar Resultados

Seja Específico, Mas Não Microgerencie

❌ "Crie um site"
✅ "Crie um site de portfólio para um desenvolvedor frontend, com seções sobre projetos, habilidades e contato, usando design moderno e responsivo"

Forneça Contexto Relevante

Mencione seu público-alvo
Especifique preferências de estilo ou tecnologia
Inclua exemplos ou referências quando possível

Aproveite a Capacidade de Planejamento
O Manus AI excele em projetos de múltiplas etapas. Não hesite em solicitar tarefas complexas que normalmente levariam dias ou semanas para completar.

Casos de Uso Avançados

Para Startups:

Desenvolvimento de MVP completo
Pesquisa de mercado e análise competitiva
Criação de pitch decks e materiais de marketing

Para Empresas:

Automação de relatórios periódicos
Análise de dados de vendas e performance
Desenvolvimento de ferramentas internas

Para Freelancers:

Gestão de múltiplos projetos simultaneamente
Criação de propostas e orçamentos
Desenvolvimento de soluções personalizadas para clientes

O Futuro do Trabalho com IA

O Manus AI representa um marco na evolução da inteligência artificial aplicada ao trabalho. Estamos testemunhando a transição de ferramentas que nos ajudam a trabalhar para agentes que trabalham conosco - e às vezes por nós.

Esta mudança não significa substituição humana, mas sim amplificação das nossas capacidades. Com o Manus AI cuidando das tarefas operacionais e repetitivas, podemos focar no que realmente importa: estratégia, criatividade, relacionamentos e inovação.

Impacto na Produtividade

Usuários relatam aumentos de produtividade de 300% a 500% em tarefas que o Manus AI pode executar autonomamente [4]. Isso não é apenas sobre fazer as coisas mais rápido - é sobre fazer mais coisas, melhores coisas, e ter tempo para pensar estrategicamente.

Democratização de Habilidades

O Manus AI democratiza habilidades técnicas avançadas. Você não precisa ser um desenvolvedor experiente para criar uma aplicação web funcional, nem um designer para produzir materiais visuais profissionais.

Conclusão: Sua Jornada com o Manus AI Começa Agora

O Manus AI não é apenas mais uma ferramenta - é um novo paradigma de trabalho. Ele representa a realização da promessa de que a tecnologia deveria nos libertar para focar no que fazemos de melhor: pensar, criar e inovar.

Se você está pronto para experimentar o futuro do trabalho hoje, o Manus AI está esperando para se tornar seu novo colega de equipe mais produtivo. A única pergunta que resta é: o que você vai criar primeiro?

Quer experimentar o Manus AI?

Comece sua jornada hoje mesmo clicando no link abaixo para se cadastrar e ganhar créditos extras para utilizar a IA:

👉 Acesse o Manus AI e ganhe créditos extras

Referências

[1] Wikipedia - Manus (AI agent): https://en.wikipedia.org/wiki/Manus_(AI_agent)
[2] Manus Official Website: https://manus.im/
[3] Veja - O que é Manus, a nova inteligência artificial que promete fazer tudo: https://veja.abril.com.br/tecnologia/o-que-e-manus-a-nova-inteligencia-artificial-que-promete-fazer-tudo/
[4] Canaltech - O que é Manus AI? Agente de IA chinês funciona de forma autônoma: https://canaltech.com.br/inteligencia-artificial/o-que-e-manus-ai-agente-de-ia-chines-funciona-de-forma-autonoma/

🐍 Gerenciando Múltiplas Versões do Python com Pyenv e Virtualenv

Carine Neris — Tue, 05 Aug 2025 01:49:07 +0000

Você já se deparou com a mensagem Python 3.11 required, but you are using 3.12 ao tentar rodar um projeto? Ou teve dores de cabeça com conflitos de pacotes entre diferentes projetos Python?

Se a resposta for sim, você precisa conhecer o pyenv e entender como ele, em conjunto com ambientes virtuais, pode revolucionar seu fluxo de trabalho de desenvolvimento Python.

💡 O que é o `pyenv`?

O pyenv é uma ferramenta de linha de comando que permite instalar e gerenciar múltiplas versões do Python no mesmo sistema, sem precisar mexer na instalação padrão do Python do seu sistema operacional. Ele funciona criando um ambiente isolado onde cada versão do Python é instalada em seu próprio diretório. Isso significa que você pode ter Python 3.8, 3.9, 3.10 e 3.11 instalados simultaneamente e alternar entre eles com facilidade. [1]

✅ Por que usar o `pyenv`?

Gerenciar múltiplas versões do Python pode ser um desafio, mas o pyenv simplifica esse processo, oferecendo vantagens significativas:

📦 Isolamento: Permite que você use versões diferentes do Python para projetos diferentes, sem que uma interfira na outra. Isso é crucial quando projetos legados dependem de versões mais antigas, enquanto novos projetos exigem as mais recentes.
🔄 Facilidade de troca: Alterne rapidamente entre as versões do Python usando comandos simples como pyenv global (para definir a versão padrão do sistema) ou pyenv local (para definir a versão específica de um projeto).
🧪 Testes em versões diferentes: É uma ferramenta excelente para testar a compatibilidade do seu código em diversas versões do Python, garantindo que sua aplicação funcione como esperado em diferentes ambientes.
🚫 Evita conflitos com o Python do sistema: Em muitos sistemas operacionais, o Python é usado por ferramentas internas. O pyenv instala versões do Python em um ambiente de usuário, evitando que você acidentalmente quebre o sistema ao instalar pacotes ou alterar a versão padrão.

🛠️ Instalando o Pyenv

A instalação do pyenv geralmente envolve alguns passos, que podem variar ligeiramente dependendo do seu sistema operacional, mas a lógica é a mesma:

1. Dependências

Antes de instalar o pyenv, é importante ter as dependências de compilação necessárias para que ele possa instalar diferentes versões do Python a partir do código-fonte. Embora os nomes dos pacotes variem entre distribuições Linux (e não sejam aplicáveis a Windows/macOS da mesma forma), geralmente você precisará de ferramentas como make, gcc, zlib-devel, openssl-devel, entre outras. Consulte a documentação oficial do pyenv para a lista exata de dependências para o seu sistema.

2. Instale o `pyenv`

A forma mais comum de instalar o pyenv é clonando seu repositório Git para um diretório específico (geralmente ~/.pyenv). Uma alternativa popular é usar o script pyenv-installer para uma instalação mais automatizada:

curl https://pyenv.run | bash

3. Configure seu Shell

Para que o pyenv funcione corretamente, você precisa adicionar algumas linhas ao seu arquivo de configuração de shell (como .bashrc, .zshrc ou .profile). Essas linhas configuram as variáveis de ambiente necessárias e inicializam o pyenv.

Exemplo de configuração (adicione ao final do seu arquivo de configuração de shell):

export PYENV_ROOT="$HOME/.pyenv"
export PATH="$PYENV_ROOT/bin:$PATH"
eval "$(pyenv init --path)"
eval "$(pyenv init -)"

Nota: A linha eval "$(pyenv init -)" é importante para a integração com o shell. Se você planeja usar o pyenv-virtualenv, também precisará adicionar eval "$(pyenv virtualenv-init -)".

4. Recarregue o Terminal

Após adicionar as linhas de configuração, salve o arquivo e recarregue seu terminal para que as alterações entrem em vigor. Você pode fazer isso fechando e reabrindo o terminal, ou executando source ~/.bashrc (ou o arquivo de configuração do seu shell).

🚀 Como usar o Pyenv

Com o pyenv instalado e configurado, gerenciar suas versões do Python se torna muito simples:

🔽 Instalar uma nova versão do Python:

Para instalar uma versão específica do Python, use o comando install:

pyenv install 3.11.8

Você pode listar todas as versões disponíveis para instalação com pyenv install --list.

🌍 Definir a versão global (para todo o sistema do usuário):

Esta versão será a padrão para todos os seus projetos, a menos que uma versão local seja definida:

pyenv global 3.11.8

📁 Definir versão local (por projeto):

Navegue até o diretório raiz do seu projeto e defina a versão específica para ele. Isso criará um arquivo .python-version no diretório:

cd meu_projeto
pyenv local 3.9.7

Sempre que você estiver neste diretório, o pyenv usará automaticamente a versão 3.9.7.

🐚 Definir versão de shell (temporária):

Para usar uma versão específica do Python apenas na sessão atual do seu terminal, sem afetar as configurações globais ou locais:

pyenv shell 3.8.5

📋 Listar versões instaladas:

Para ver todas as versões do Python que você tem instaladas e qual está ativa:

pyenv versions

🧹 Como remover uma versão:

Se você não precisa mais de uma versão específica do Python, pode desinstalá-la para liberar espaço:

pyenv uninstall 3.9.7

🧪 Isolamento de Dependências com Ambientes Virtuais (`virtualenv`)

Enquanto o pyenv gerencia as versões do interpretador Python, os ambientes virtuais (criados com ferramentas como virtualenv ou o módulo venv do Python) são essenciais para isolar as dependências de cada projeto.

O que é um Ambiente Virtual?

Um ambiente virtual é um diretório que contém uma instalação isolada do Python e suas próprias cópias de pip, setuptools e wheel. Isso significa que as bibliotecas instaladas em um ambiente virtual não afetam o ambiente global do Python ou outros ambientes virtuais. [2]

Por que usar Ambientes Virtuais?

Evitar Conflitos: Diferentes projetos podem usar diferentes versões da mesma biblioteca sem interferir uns nos outros.
Ambiente Limpo: As dependências de um projeto ficam contidas em seu próprio ambiente, evitando a poluição do ambiente global.
Reprodução Fácil: Facilita a recriação do ambiente de um projeto em outra máquina, garantindo que todos os desenvolvedores (e servidores de produção) usem as mesmas dependências.

Pyenv-virtualenv: A Combinação Perfeita

Para quem usa pyenv, o plugin pyenv-virtualenv é a solução ideal. Ele integra a funcionalidade de criação e gerenciamento de ambientes virtuais diretamente nos comandos do pyenv, tornando o fluxo de trabalho ainda mais suave e intuitivo. Com ele, você pode criar ambientes virtuais vinculados a versões específicas do Python gerenciadas pelo pyenv.

Comandos Essenciais do `pyenv-virtualenv`

Criar um ambiente virtual: Para criar um ambiente virtual para uma versão específica do Python (que já deve estar instalada via pyenv):
```
pyenv virtualenv 3.10.9 meu-projeto-env
```
Isso criará um ambiente virtual chamado meu-projeto-env baseado no Python 3.10.9.
Ativar um ambiente virtual: Você pode ativar um ambiente virtual manualmente:
```
pyenv activate meu-projeto-env
```
O nome do ambiente virtual aparecerá no seu prompt de comando, indicando que ele está ativo.
Desativar um ambiente virtual: Para sair do ambiente virtual e retornar ao ambiente Python anterior:
```
pyenv deactivate
```
Remover um ambiente virtual: Se não precisar mais de um ambiente virtual:
```
pyenv uninstall meu-projeto-env
```

🎯 Vantagens e Desvantagens do `pyenv`

Vantagem	Descrição
🔄 Versões múltiplas	Gerencie facilmente várias versões do Python em um único sistema.
🧼 Sem `sudo`	Evita a necessidade de usar `sudo pip`, o que pode quebrar o Python do sistema.
🧩 Integração com `virtualenv`	Crie ambientes isolados para cada projeto, garantindo a consistência das dependências.
📂 Local por projeto	Torna o ambiente de desenvolvimento portátil e reproduzível através do arquivo `.python-version`.

Desvantagem	Como contornar
📦 Instalação inicial	A instalação inicial pode ser um pouco demorada, mas uma vez feita, funciona para sempre.
🐢 Compilação de versões	A compilação de novas versões do Python pode levar alguns minutos, dependendo do seu hardware.

🤔 Quando não usar o `pyenv`?

Se você só usa uma versão do Python e não precisa alternar entre projetos com diferentes requisitos de versão.
Se você já usa conda e está satisfeito com seu ecossistema de gerenciamento de pacotes e ambientes.
Se você está em um ambiente muito restrito (como servidores compartilhados) onde não tem permissão para instalar novas ferramentas ou compilar software.

✨ Conclusão

O pyenv, combinado com o pyenv-virtualenv, é uma ferramenta poderosa e leve para qualquer desenvolvedor Python que trabalha com múltiplos projetos, versões ou ambientes. Ele evita dores de cabeça com conflitos de dependência e oferece controle total sobre seu ambiente de desenvolvimento.

Comece instalando, experimente com diferentes versões e veja como seu fluxo de trabalho se torna mais limpo, organizado e eficiente.

📚 Referências

[1] https://github.com/pyenv/pyenv
[2] https://realpython.com/python-virtual-environments-a-primer/

WebRTC - One Byte Explainer

Carine Neris — Thu, 21 Mar 2024 12:39:17 +0000

This is a submission for DEV Challenge v24.03.20, One Byte Explainer: Browser API or Feature.

Explainer

WebRTC (Web Real-time Communication) is like turning your browser into a Swiss Army knife: make video/audio calls without downloading anything extra. It's just like having a toolbox in your browser, all through the internet!

Additional Context

I used MDN as a reference.

Precisamos falar sobre ipdb: Uma Jornada para um debugger mais Eficiente em Python

Carine Neris — Wed, 20 Mar 2024 23:00:35 +0000

Bugs e erros são inevitáveis no desenvolvimento de software. No entanto, enfrentar esses problemas pode ser uma experiência frustrante e demorada. Felizmente, existem ferramentas poderosas disponíveis para nos ajudar a depurar nossos programas de forma mais eficiente. Uma dessas ferramentas é o ipdb, um depurador interativo para Python que pode simplificar e agilizar o processo de identificação e correção de bugs. Vamos descobrir por que precisamos debuggar com ipdb e como essa ferramenta pode tornar nossa jornada de depuração mais eficiente.

Mas o que é ipdb?

O ipdb é uma ferramenta de depuração interativa para Python, projetada para ajudar a inspecionar e depurar programas de forma eficiente. Ele oferece uma interface de linha de comando intuitiva e fácil de usar, juntamente com recursos avançados que facilitam a identificação e correção de bugs.

Principais Recursos do ipdb:

Interface amigável e interativa.
Suporte a autocompletar.
Navegação fácil entre frames de pilha.
Suporte a expressões regulares durante a pesquisa.
Compatibilidade total com o pdb, o depurador padrão do Python.

Como Usar o ipdb:

Usar o ipdb é simples. Basta instalar e adicionar a linha import ipdb; ipdb.set_trace() em seu código onde deseja iniciar a depuração. Isso define um ponto de interrupção no código e permite que você inspecione variáveis, execute comandos e navegue pelo stack trace(histórico de eventos que levou ao erro) durante a execução do programa.

Vamos a um passo a passo de como usar o ipdb:

Instalação: Podemos instalar o ipdb facilmente usando o pip:

   pip install ipdb

Definindo Pontos de interrupção: Podemos definir pontos de interrupção em nosso código onde queremos iniciar a depuração, usando o seguinte import:

   import ipdb; ipdb.set_trace()

Explorando e Depurando: Depois de definir os pontos de interrupção, podemos executar nosso código e começar a explorar e depurar a execução interativamente usando os comandos do ipdb.

Comandos do ipdb

Comandos de Navegação:
- n ou next: Executa a próxima linha de código.
- s ou step: Entra em funções e métodos, permitindo que você acompanhe a execução linha por linha.
- c ou continue: Continua a execução até encontrar o próximo ponto de interrupção ou o final do programa.
Comandos de Inspeção de Variáveis:
- p <variável>: Imprime o valor de uma variável.
- pp <variável>: Imprime o valor de uma variável de forma mais bonita e legível.
- whatis <variável>: Exibe o tipo de uma variável.
- list <linha>: Exibe as linhas de código ao redor de uma linha específica.
Comandos de Stack Trace e Escopo:
- w ou where: Exibe o stack trace atual, mostrando onde você está no código.
- u ou up: Move-se para o frame de pilha anterior, permitindo que você inspecione o escopo de chamadas de funções anteriores.
- d ou down: Move-se para o frame de pilha seguinte.
Comandos de Controle de Execução:
- return: Simula o retorno imediato da função em que você está, permitindo que você teste diferentes caminhos de execução.
- jump <linha>: Move a execução para uma linha específica do código.
- disable <número>: Desativa um ponto de interrupção específico.
Outros Comandos Úteis:
- q ou quit: Sai do depurador ipdb.
- h ou help: Exibe a lista de comandos disponíveis e fornece informações de ajuda sobre como usá-los.

Exemplo de código:

Aqui vai um exemplo de como usar o ipdb para depurar um programa:


def calcular_fatorial(numero):
    import ipdb; ipdb.set_trace()
    if numero == 0:
        return 1
    else:
        return numero * calcular_fatorial(numero - 1)

resultado = calcular_fatorial(5)
print("O fatorial de 5 é:", resultado)

Neste exemplo, estamos calculando o fatorial de 5 usando uma função recursiva. Ao iniciar o programa com o ipdb, podemos inspecionar o valor da variável numero em cada chamada recursiva e entender como o cálculo do fatorial é realizado.

É isto, quis mostrar aqui essa ferramenta que facilita bastante nossa vida e como ela pode ajudar a depurar nossos programas de forma mais eficiente e eficaz. Então, da próxima vez que você se deparar com um bug em seu código, don't worry, use o ipdb para depurar e encontrar a solução do erro de forma mais rápida.

DEV Community: Carine Neris

Estratégias de Lançamento de Software Progressivo: Além do Simples If/Else com Feature Flags

O Que São Feature Toggles? Mais que um Simples Liga/Desliga!

As Categorias de Toggles

Mão na Massa: Implementando um Release Toggle com FastAPI

1. Setup Básico do Projeto

2. O Nosso "Gerenciador" de Toggles

3. Integrando o Toggle no FastAPI

Boas Práticas: Evitando a "Dívida Técnica" dos Toggles

Gerenciamento: Quando e Como Dizer Adeus aos Toggles

Conclusão: O Futuro da Entrega de Software é Flexível!

Referências

Agora da pra fazer pequenos post aqui no DEV.to. Amei a nova feature.

Diga Adeus ao Caos: Gerenciando Dependências Python com Poetry

O Fim da Era do pip e venv Manual

Primeiros Passos: Instalando o Poetry

Iniciando um Projeto Poetry: A Magia Começa!

O Coração do Projeto: pyproject.toml

Gerenciando Dependências: Adicionar, Remover, Atualizar

Adicionando Novas Bibliotecas

Dependências de Desenvolvimento

Removendo uma Biblioteca

Atualizando Dependências

O Segredo da Consistência: poetry.lock

Ambientes Virtuais: Onde o Poetry Brilha

Comandos Essenciais para o Dia a Dia

Conclusão: Sua Vida Python Nunca Mais Será a Mesma!

Referências

Alembic: Versionamento de Banco de Dados (Parte 2)

Automatizando Migrações com --autogenerate

1. Configurando o target_metadata

2. Gerando a Migração Automática

Começando com um Banco de Dados Existente

Passo 1: Criar a Migração de "Estado Zero"

Passo 2: O Comando stamp

Melhores Práticas e Arquitetura

Conclusão

Referências

Alembic: Versionamento de Banco de Dados

A Dor da Evolução do Banco de Dados em Projetos Ágeis

Alembic: A Solução para Evolução Controlada do Banco de Dados

Configurando o Alembic em Seu Projeto

1. Instalação

2. Inicialização do Ambiente de Migração

3. Configuração do alembic.ini

Criando Sua Primeira Migração (Manual)

Próximos Passos: Migrações Automáticas e Bancos Existentes

Referências

Como Baixar, Quantizar e Rodar um Modelo LLM Localmente com Ollama

🧰 Pré-requisitos

📥 1️⃣ Baixando o modelo Jurema-7B

🧠 2️⃣ Baixando e compilando o llama.cpp

⚙️ 3️⃣ Convertendo e Quantizando o modelo

💬 4️⃣ Adicionando ao Ollama

🧠 5️⃣ Evitando loops infinitos nas respostas

⚡ 6️⃣ Dicas extras

🧠 Referências

Precisamos falar sobre o Hugging Face: o GitHub da Inteligência Artificial

🤔 O que é o Hugging Face?

🧠 O coração do Hugging Face: o Model Hub

🧰 Principais bibliotecas do ecossistema Hugging Face

🔹 transformers

🔹 datasets

🔹 tokenizers

🔹 diffusers

🔹 accelerate

☁️ Hugging Face Hub e APIs

🔗 Recursos úteis

Manus AI: Transform Ideas into Action with Your New Autonomous Workmate (Invite Code)

What Is Manus AI?

What Can Manus AI Do for You?

Development and Programming

Research and Data Analysis

Content Creation and Design

Process Automation

Why Use Manus AI?

1. True Autonomy

2. Unprecedented Versatility

3. Exponential Efficiency

4. Professional Quality

O Fim da Era do `pip` e `venv` Manual

O Coração do Projeto: `pyproject.toml`

O Segredo da Consistência: `poetry.lock`

Automatizando Migrações com `--autogenerate`

1. Configurando o `target_metadata`

Passo 2: O Comando `stamp`

3. Configuração do `alembic.ini`

🔹 `transformers`

🔹 `datasets`

🔹 `tokenizers`

🔹 `diffusers`

🔹 `accelerate`

💡 O que é o `pyenv`?

✅ Por que usar o `pyenv`?

2. Instale o `pyenv`

🧪 Isolamento de Dependências com Ambientes Virtuais (`virtualenv`)

Comandos Essenciais do `pyenv-virtualenv`

🎯 Vantagens e Desvantagens do `pyenv`

🤔 Quando não usar o `pyenv`?