`Standardul Modern de Packaging și Tooling în Python: uv, Pyproject.toml și Docker` în Python

Module și importuri Standard Modern 2026

Ghid complet pentru standardul modern de tooling în Python în 2026: configurarea unificată cu pyproject.toml, viteza revoluționară a lui uv și Ruff scrise în Rust și containere Docker multi-stage optimizate.

Sintaxă

uv pip install -r pyproject.toml; ruff check .; ruff format .

Ecosistemul Python a trecut printr-o transformare radicală în ultimii ani. Vechiul mozaic fragmentat și lent compus din setup.py, requirements.txt, virtualenv, flake8, black și isort a fost înlocuit de un standard unificat și ultra-rapid bazat pe pyproject.toml (PEP 621) și unelte moderne native scrise în Rust (în special uv și Ruff de la Astral).

1. Fișierul unificat pyproject.toml (Standardul PEP 621)

[project]
name = "dexblog-api"
version = "1.0.0"
description = "Microserviciu de producție pentru dexblog.ro"
requires-python = ">=3.11"
dependencies = [
    "fastapi>=0.110.0",
    "uvicorn[standard]>=0.28.0",
    "pydantic>=2.6.0",
    "httpx>=0.27.0"
]

[project.optional-dependencies]
dev = [
    "pytest>=8.0.0",
    "ruff>=0.3.0",
    "mypy>=1.9.0"
]

[tool.ruff]
line-length = 100
target-version = "py312"

[tool.ruff.lint]
select = ["E", "F", "I", "UP", "B"] # Erori, Flake8, Isort, PyUpgrade, Bugbear

De ce uv și Ruff domină dezvoltarea Python în 2026?

Instrument Clasic	Alternativă Modernă (Rust)	Diferență de Performanță
`pip` + `virtualenv`	uv	De 10 până la 100 de ori mai rapid la rezolvarea și instalarea dependențelor. Creează un mediu virtual complet în sub 10 milisecunde!
`black` + `flake8` + `isort`	Ruff	Un singur binar înlocuiește 3 unelte separate, formatând și analizând un milion de linii de cod în sub o secundă.

Comenzi de bază cu uv și Ruff

# Crearea și activarea instantanee a unui mediu virtual cu uv:
uv venv .venv
source .venv/bin/activate

# Instalarea dependențelor direct din pyproject.toml:
uv pip install -e ".[dev]"

# Linting și formatare automată a întregului proiect într-o fracțiune de secundă:
ruff check --fix .
ruff format .

Optimizarea Imaginilor Docker de Producție (Multi-Stage Build)

O imagine Docker de Python configurată greșit poate depăși cu ușurință 1.5 GB și poate conține compilatoare C inutile (gcc) care reprezintă breșe de securitate. Modelul recomandat folosește Multi-Stage Builds:

Dockerfile de producție cu uv și utilizator non-root

# --- Etapa 1: Builder ---
FROM python:3.12-slim AS builder

WORKDIR /app
# Instalăm binarul pre-compilat uv:
COPY --from=ghcr.io/astral-sh/uv:latest /uv /bin/uv

COPY pyproject.toml .
# Creăm mediul virtual și instalăm exclusiv dependențele de producție:
RUN uv venv /opt/venv && \
    uv pip install --no-cache --python /opt/venv/bin/python .

# --- Etapa 2: Runtime Final ---
FROM python:3.12-slim AS runtime

# Prevenim scrierea fișierelor .pyc și forțăm output-ul nebuferat în loguri:
ENV PYTHONDONTWRITEBYTECODE=1 \
    PYTHONUNBUFFERED=1 \
    PATH="/opt/venv/bin:$PATH"

WORKDIR /app

# Copiem doar mediul virtual curat gata compilat din etapa de builder:
COPY --from=builder /opt/venv /opt/venv
COPY ./src /app/src

# Rulăm ca utilizator non-root pentru securitate strictă:
RUN useradd -u 1001 appuser && chown -R appuser:appuser /app
USER appuser

EXPOSE 8000
CMD ["uvicorn", "src.main:app", "--host", "0.0.0.0", "--port", "8000"]