Il Nuovo Paradigma - Python Edition

📌 Introduzione

Il contesto Python-AI

Python non è solo il linguaggio dominante per AI/ML - è l’ecosistema nativo in cui l’intera rivoluzione AI sta accadendo. Ogni major LLM SDK, framework, e tool è Python-first.

🐍 Perché Python Governa l’AI

I Numeri Parlano Chiaro

Vantaggi per AI Development

Python Moderno (2025)

Il Python di oggi è molto diverso da quello di 5-10 anni fa:

• Type hints obbligatori (PEP 484+)
• Pattern matching (Python 3.10+)
• Async/await maturo e diffuso
• Dataclasses e Pydantic per data validation
• uv e rye - package manager velocissimi
• Ruff - linter 100x più veloce di pylint

🛠️ Tool per Python AI Development

IDE & Coding Assistants

Python-Specific AI Tools

Notebooks AI-Enhanced

⚙️ Setup Python Moderno su Mac

Opzione A: pyenv (Raccomandato)

# Installa pyenv
brew install pyenv

# Setup shell (zsh)
echo 'export PYENV_ROOT="$HOME/.pyenv"' >> ~/.zshrc
echo 'command -v pyenv >/dev/null || export PATH="$PYENV_ROOT/bin:$PATH"' >> ~/.zshrc
echo 'eval "$(pyenv init -)"' >> ~/.zshrc

# Reload shell
source ~/.zshrc

# Installa Python 3.12 (LTS attuale)
pyenv install 3.12

# Set come default
pyenv global 3.12

# Verifica
python --version  # deve essere 3.12.x

Opzione B: uv (Nuovo, Velocissimo)

# uv è un package manager Python scritto in Rust - 10-100x più veloce
brew install uv

# Installa Python
uv python install 3.12

# Crea virtual environment
uv venv

# Attiva
source .venv/bin/activate

Poetry (Opzione Moderna)

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

# Aggiungi a PATH
echo 'export PATH="$HOME/.local/bin:$PATH"' >> ~/.zshrc
source ~/.zshrc

# Verifica
poetry --version

Setup nuovo progetto con Poetry

# Crea nuovo progetto
poetry new my-ai-project
cd my-ai-project

# Oppure in progetto esistente
poetry init

# Aggiungi dependencies
poetry add anthropic openai langchain fastapi

# Dev dependencies
poetry add --group dev pytest ruff mypy black

# Attiva virtual environment
poetry shell

# Estensioni essenziali
code --install-extension ms-python.python
code --install-extension ms-python.vscode-pylance
code --install-extension continue.continue
code --install-extension charliermarsh.ruff
code --install-extension ms-toolsai.jupyter

# Opzionali ma utili
code --install-extension GitHub.copilot
code --install-extension GitHub.copilot-chat
code --install-extension tamasfe.even-better-toml

# Già installato? Usa quello
aider --version

# Oppure installa con uv (più veloce)
uv tool install aider-chat

# Config per Python
touch ~/.aider.conf.yml

.cursorrules (o .continuerules) per Python

# .cursorrules

You are an expert Python developer working with modern Python 3.12+.

Tech stack:
- Python 3.12+
- FastAPI for APIs
- SQLAlchemy 2.0 for ORM
- Pydantic v2 for validation
- pytest for testing
- Type hints everywhere

Code style:
- ALWAYS use type hints (mypy strict mode)
- Use dataclasses or Pydantic models
- Prefer async/await for I/O operations
- Follow PEP 8 (enforced by ruff)
- Max line length: 100
- Use descriptive variable names

Security:
- Never commit API keys or secrets
- Validate all inputs with Pydantic
- Use parameterized queries with SQLAlchemy
- Follow OWASP Python Security
- Use secrets module for random values

# .env file
ANTHROPIC_API_KEY=your_key_here
OPENAI_API_KEY=your_key_here
DATABASE_URL=postgresql://localhost/mydb
ENVIRONMENT=development

# Python version
python --version  # >= 3.12

# Poetry
poetry --version

# Virtual env attivo?
which python  # deve puntare a .venv

# Packages installati?
poetry show

# Ruff funziona?
ruff check .

# mypy funziona?
mypy --version

# pytest funziona?
pytest --version

🔒 Security Python-Specific

1. Secrets Management

.gitignore per Python

# Secrets
.env
.env.local
*.key
*.pem
config/secrets.py

# Virtual environments
.venv/
venv/
env/

# Python
__pycache__/
*.py[cod]
*.egg-info/

# AI tools
.aider*
.cursor/
.continue/

# Testing
.pytest_cache/
.coverage
htmlcov/

2. Security Scanning Tools

# Installa security tools
poetry add --group dev bandit safety pip-audit

# Bandit - scan per vulnerabilità
bandit -r src/

# Safety - check dependencies vulnerabili
safety check

# pip-audit - audit dependencies
pip-audit

3. Input Validation con Pydantic

from pydantic import BaseModel, EmailStr, Field, validator
from typing import Optional

class UserCreate(BaseModel):
    email: EmailStr  # valida email automaticamente
    username: str = Field(..., min_length=3, max_length=50)
    age: Optional[int] = Field(None, ge=0, le=150)

    @validator('username')
    def username_alphanumeric(cls, v):
        if not v.isalnum():
            raise ValueError('must be alphanumeric')
        return v

4. SQL Injection Prevention

# ❌ MAI COSÌ (SQL injection vulnerability)
query = f"SELECT * FROM users WHERE email = '{email}'"
db.execute(query)

# ✅ SEMPRE COSÌ (SQLAlchemy ORM)
from sqlalchemy import select
stmt = select(User).where(User.email == email)
result = await session.execute(stmt)

5. Secure Random Values

# ❌ MAI random module per security
import random
token = random.randint(1000, 9999)  # INSICURO!

# ✅ SEMPRE secrets module
import secrets
token = secrets.token_urlsafe(32)
api_key = secrets.token_hex(32)

🧪 Testing Python Moderno

1. Setup pytest

poetry add --group dev pytest pytest-cov pytest-asyncio pytest-mock

# pyproject.toml
[tool.pytest.ini_options]
testpaths = ["tests"]
python_files = ["test_*.py", "*_test.py"]
addopts = [
    "-v",
    "--cov=src",
    "--cov-report=html",
    "--cov-fail-under=80"
]
asyncio_mode = "auto"

2. Test Structure

# tests/test_user_service.py

import pytest
from src.services.user import UserService

@pytest.fixture
async def user_service():
    """Setup user service for tests."""
    service = UserService()
    await service.initialize()
    yield service
    await service.cleanup()

class TestUserService:
    """Tests for UserService."""

    async def test_create_user_success(
        self,
        user_service: UserService,
        sample_user_data: dict
    ):
        """Test successful user creation."""
        # Arrange
        email = sample_user_data["email"]

        # Act
        user = await user_service.create_user(**sample_user_data)

        # Assert
        assert user.email == email
        assert user.id is not None

3. Testing AI-Generated Code

Property-Based Testing con Hypothesis

from hypothesis import given, strategies as st

@given(st.emails())
def test_email_validation_property(email: str):
    """Property test: all valid emails should be accepted."""
    user_data = {"email": email, "username": "test"}
    validate_user(user_data)

🔄 Workflow Python + AI

Scenario 1: Data Science / ML Prototyping

# In VSCode
# 1. Apri .ipynb file
# 2. GitHub Copilot attivo
# 3. Type hints anche nei notebook!

import pandas as pd

def clean_data(df: pd.DataFrame) -> pd.DataFrame:
    """Clean and preprocess data."""
    # Copilot suggerisce i passi comuni
    ...

Scenario 2: FastAPI Development

from fastapi import FastAPI, Depends
from sqlalchemy.ext.asyncio import AsyncSession
from typing import List

app = FastAPI()

@app.get("/users", response_model=List[UserResponse])
async def get_users(
    skip: int = 0,
    limit: int = 100,
    db: AsyncSession = Depends(get_db)
) -> List[UserResponse]:
    """Get list of users."""
    # AI genera con type hints corretti
    ...

Tool Selection Matrix (Python)

🤖 AI Frameworks Python

LLM SDKs

from anthropic import Anthropic

client = Anthropic()

message = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Hello, Claude!"}
    ]
)

print(message.content[0].text)

Orchestration Frameworks

from langchain_anthropic import ChatAnthropic
from langchain_core.prompts import ChatPromptTemplate

llm = ChatAnthropic(
    model="claude-sonnet-4-20250514",
    temperature=0
)

prompt = ChatPromptTemplate.from_messages([
    ("system", "You are a helpful assistant."),
    ("user", "{input}")
])

chain = prompt | llm
response = chain.invoke({"input": "Hello!"})

from llama_index.core import VectorStoreIndex, SimpleDirectoryReader
from llama_index.llms.anthropic import Anthropic

llm = Anthropic(model="claude-sonnet-4-20250514")

documents = SimpleDirectoryReader("data").load_data()
index = VectorStoreIndex.from_documents(documents)

query_engine = index.as_query_engine(llm=llm)
response = query_engine.query("What is this about?")

import instructor
from anthropic import Anthropic
from pydantic import BaseModel

class User(BaseModel):
    name: str
    age: int
    email: str

client = instructor.from_anthropic(Anthropic())

user = client.messages.create(
    model="claude-sonnet-4-20250514",
    max_tokens=1024,
    messages=[
        {"role": "user", "content": "Extract: John Doe, 30, john@example.com"}
    ],
    response_model=User
)

print(user.name)  # "John Doe" - type-safe!

📋 Python Development Policy

Type Hints Policy

# ❌ Rifiutato in PR
def process_data(data):
    return data.upper()

# ✅ Accettato
def process_data(data: str) -> str:
    return data.upper()

Diff Size Limits (Python specific)

Pre-commit Checklist

• ruff check . --fix
• ruff format .
• mypy . (must pass strict mode)
• pytest --cov=src --cov-fail-under=80
• bandit -r src/ (no security issues)
• No secrets in code
• All type hints present
• Docstrings for public functions

📚 Risorse Python + AI

Documentazione Ufficiale

• Anthropic Python SDK: GitHub
• LangChain Python: python.langchain.com
• FastAPI: fastapi.tiangolo.com
• Pydantic: docs.pydantic.dev

Tools & Libraries

• Poetry: python-poetry.org
• Ruff: docs.astral.sh/ruff
• pytest: docs.pytest.org
• mypy: mypy.readthedocs.io

🎯 Conclusioni Python Edition