Conheça o UV: Guia Rápido

Se você trabalha com Python, especialmente em áreas como automação de redes, sabe que a velocidade e a eficiência na gestão de dependências e ambientes virtuais são cruciais. Ferramentas como pip e virtualenv são o padrão há anos, mas um novo competidor chamado uv.

Desenvolvido pela Astral, o uv é um gerenciador de pacotes e projetos Python escrito em Rust. Ele foi projetado para ser um substituto completo e veloz para os fluxos de trabalho de pip, pip-tools, pipx e virtualenv. A promessa é uma performance de 10 a 100 vezes mais rápida que as ferramentas tradicionais

Por que usar o `uv`?

Antes de entrarmos nos comandos, vale a pena entender os benefícios:

Velocidade Extrema: Graças ao Rust e a um resolvedor de dependências avançado, o uv instala e atualiza pacotes em uma fração do tempo do pip.
Tudo em Um: Ele unifica as funcionalidades de várias ferramentas em um único executável. Chega de instalar virtualenv, pip-tools e outros pacotes separadamente.
Cache Inteligente: O uv utiliza um cache global de pacotes, evitando downloads repetidos entre diferentes projetos.
Compatibilidade: É um substituto direto do pip, o que significa que você pode usá-lo com seus arquivos requirements.txt existentes sem nenhuma modificação.

Instalação

A instalação do uv é simples e não requer uma instalação prévia de Python.

Sistema Operacional	Comando
Linux / macOS	`curl -LsSf https://astral.sh/uv/install.sh

Após a instalação, verifique se tudo ocorreu bem com o comando:

uv --version

Guia de Comandos do `uv`

Vamos detalhar os comandos mais importantes para o seu fluxo de trabalho.

Ambientes Virtuais

O uv gerencia ambientes virtuais de forma nativa.

Comando	Descrição
`uv venv`	Cria um novo ambiente virtual no diretório `.venv`. É o equivalente a `python -m venv .venv`.
`uv venv --python <versao>`	Cria um ambiente virtual com uma versão específica do Python (ex: `uv venv --python 3.11`)

Uso:

# Cria o ambiente
uv venv

# Ativa o ambiente (Linux/macOS)
source .venv/bin/activate

# Ativa o ambiente (Windows)
.venv\Scripts\activate

Gerenciamento de Pacotes

Esta é a principal funcionalidade do uv. Os comandos são intuitivos e substituem diretamente o pip

Basicamente, se voce sabia trabalhar com o pip, nao tera dificuldades aqui.

Comando	Descrição
`uv pip install <pacote>`	Instala um ou mais pacotes
`uv pip install -r reqs.txt`	Instala pacotes a partir de um arquivo de requerimentos.
`uv pip uninstall <pacote>`	Remove um pacote.
`uv pip list`	Lista os pacotes instalados no ambiente.
`uv pip freeze > reqs.txt`	Gera um arquivo `requirements.txt` com os pacotes instalados.

Exemplo para Automação de Redes:

# Instala as bibliotecas essenciais para automação
uv pip install netmiko napalm nornir

# Verifica os pacotes instalados
uv pip list

Sincronização de Dependências (Estilo `pip-tools`)

Para projetos mais robustos, é uma boa prática fixar as versões das dependências para garantir a reprodutibilidade. O uv simplifica isso.

Comando	Descrição
`uv add <pacote>`	Adiciona um pacote ao seu `pyproject.toml` ou `requirements.txt` e o instala
`uv sync`	Instala as dependências de um arquivo de lock (`requirements.lock` ou `pyproject.toml`).
`uv pip compile pyproject.toml -o requirements.txt`	Gera um arquivo `requirements.txt` a partir das dependências de alto nível do seu projeto.

Executando Comandos e Ferramentas

O uv também substitui o pipx, permitindo executar ferramentas de linha de comando sem poluir seu ambiente global.

Comando	Descrição
`uv run <comando>`	Executa um comando dentro do ambiente virtual do projeto (ex: `uv run python script.py`)
`uvx <comando>`	Executa um comando em um ambiente efêmero, instalando as dependências necessárias temporariamente.

Exemplo Prático com uvx:

Imagine que você quer formatar seu código com o black sem instalá-lo no seu projeto.

# Formata todos os arquivos .py no diretório atual
uvx black .

O uv baixará o black em um ambiente temporário, o executará e depois o descartará. Simples assim!

Caso de Uso: Projeto de Automação de Rede

Vamos simular o início de um novo projeto para automatizar a coleta de fatos de dispositivos de rede usando nornir.

Crie o diretório do projeto e inicialize o ambiente:

 mkdir projeto-nornir
 cd projeto-nornir
 uv venv
 source .venv/bin/activate

Instale as dependências:

O nornir precisa de plugins para se conectar aos dispositivos. Vamos instalar o nornir e o plugin para netmiko.
```
 uv pip install nornir nornir-netmiko
```
A instalação será notavelmente mais rápida do que com o pip.

Crie seu script de automação (coleta_fatos.py):

 from nornir import InitNornir
 from nornir_netmiko import netmiko_send_command
 from nornir_utils.plugins.functions import print_result

 nr = InitNornir(config_file="config.yaml")

 result = nr.run(task=netmiko_send_command, command_string="show version")

 print_result(result)

Execute o script com uv run:
```
 uv run python coleta_fatos.py
```
Gere o arquivo de requerimentos para compartilhar o projeto:
```
 uv pip freeze > requirements.txt
```

Agora, qualquer colega de equipe pode recriar seu ambiente de forma rápida e determinística com uv venv e uv pip install -r requirements.txt.

Conclusão

O uv é uma melhoria na qualidade de vida para desenvolvedores Python ao unificar várias funcionalidades em uma única interface. Ele simplifica o fluxo de trabalho, reduz a complexidade e acelera o ciclo de desenvolvimento.

Para quem trabalha com automação de redes, onde a agilidade para testar scripts e gerenciar dependências é fundamental, adotar o uv é um passo natural.

Referências:

Astral, uv - Documentação Oficial