07 - IA Generativa per lo Sviluppo: Code Generation e Assistenti AI

# Livello 1: Autocomplete in-line
# Scrivi un commento o l'inizio di una funzione, l'AI completa
def calculate_compound_interest(principal, rate, time, n=12):
    """Calculate compound interest with monthly compounding.

    Args:
        principal: Initial investment amount
        rate: Annual interest rate (as decimal, e.g., 0.05 for 5%)
        time: Time in years
        n: Number of compounding periods per year

    Returns:
        Final amount after compound interest
    """
    # L'AI genera automaticamente:
    amount = principal * (1 + rate / n) ** (n * time)
    interest = amount - principal
    return {
        "final_amount": round(amount, 2),
        "interest_earned": round(interest, 2),
        "total_return_pct": round((interest / principal) * 100, 2)
    }


# Livello 2: Generazione da docstring
# Descrivi cosa vuoi nella docstring, l'AI implementa
def validate_italian_fiscal_code(fiscal_code: str) -> dict:
    """Validate an Italian fiscal code (codice fiscale).

    Checks:
    - Length is exactly 16 characters
    - Format matches pattern: 6 letters + 2 digits + 1 letter + 2 digits + 1 letter + 3 digits + 1 letter
    - Check character is valid using MOD 26 algorithm

    Returns dict with 'valid' bool and 'errors' list.
    """
    # L'AI genera l'implementazione completa basandosi sulla docstring
    errors = []
    fiscal_code = fiscal_code.upper().strip()

    if len(fiscal_code) != 16:
        errors.append(f"Length must be 16, got {len(fiscal_code)}")

    import re
    pattern = r'^[A-Z]{6}[0-9]{2}[A-Z][0-9]{2}[A-Z][0-9]{3}[A-Z]$'
    if not re.match(pattern, fiscal_code):
        errors.append("Format does not match expected pattern")

    return {"valid": len(errors) == 0, "errors": errors}
      

# Prompt per generare test completi
# "Genera test pytest per la funzione calculate_compound_interest"

import pytest

class TestCalculateCompoundInterest:
    """Test suite generata dall'AI per calculate_compound_interest."""

    def test_basic_calculation(self):
        """Test con valori standard."""
        result = calculate_compound_interest(1000, 0.05, 1)
        assert result["final_amount"] == 1051.16
        assert result["interest_earned"] == 51.16

    def test_zero_principal(self):
        """Test con investimento iniziale zero."""
        result = calculate_compound_interest(0, 0.05, 1)
        assert result["final_amount"] == 0
        assert result["interest_earned"] == 0

    def test_zero_rate(self):
        """Test con tasso di interesse zero."""
        result = calculate_compound_interest(1000, 0, 5)
        assert result["final_amount"] == 1000
        assert result["interest_earned"] == 0

    def test_multiple_years(self):
        """Test su periodo pluriennale."""
        result = calculate_compound_interest(10000, 0.08, 10)
        assert result["final_amount"] > 10000
        assert result["total_return_pct"] > 100  # Più che raddoppiato in 10 anni

    def test_custom_compounding(self):
        """Test con compounding personalizzato (trimestrale)."""
        result = calculate_compound_interest(1000, 0.12, 1, n=4)
        assert result["final_amount"] == 1125.51

    def test_high_rate(self):
        """Test con tasso elevato."""
        result = calculate_compound_interest(1000, 1.0, 1)
        assert result["final_amount"] > 2000
      

# Esempio: chiedere una code review all'AI
# Prompt: "Fai code review di questa funzione, identifica problemi e suggerisci miglioramenti"

# Codice originale (con problemi)
def get_user_data(user_id):
    import requests
    r = requests.get(f"https://api.example.com/users/{user_id}")
    data = r.json()
    name = data["name"]
    email = data["email"]
    return name, email

# L'AI identifica:
# 1. Import dentro la funzione (spostare in alto)
# 2. Nessuna gestione errori HTTP
# 3. Nessun timeout nella richiesta
# 4. Nessuna validazione input
# 5. Ritorno tupla (meglio dict o dataclass)
# 6. Nessun type hint

# Versione migliorata suggerita dall'AI:
from dataclasses import dataclass
import requests
from requests.exceptions import RequestException

@dataclass
class UserData:
    name: str
    email: str

def get_user_data(user_id: int) -> UserData:
    """Fetch user data from the API.

    Args:
        user_id: The unique identifier of the user.

    Returns:
        UserData object with name and email.

    Raises:
        ValueError: If user_id is invalid.
        RequestException: If API call fails.
    """
    if not isinstance(user_id, int) or user_id <= 0:
        raise ValueError(f"Invalid user_id: {user_id}")

    try:
        response = requests.get(
            f"https://api.example.com/users/{user_id}",
            timeout=10
        )
        response.raise_for_status()
        data = response.json()
        return UserData(name=data["name"], email=data["email"])
    except RequestException as e:
        raise RequestException(f"Failed to fetch user {user_id}: {e}") from e
      

# Pattern per uso efficace dell'AI nello sviluppo

# 1. Skeleton + AI Fill: scrivi la struttura, l'AI riempie
class OrderProcessor:
    """Process e-commerce orders with validation and notifications."""

    def validate_order(self, order: dict) -> bool:
        # L'AI implementa la validazione completa
        pass

    def calculate_total(self, items: list, discount_code: str = None) -> float:
        # L'AI implementa il calcolo con sconti
        pass

    def send_confirmation(self, order_id: str, email: str) -> bool:
        # L'AI implementa l'invio email
        pass


# 2. Test-First + AI Implementation
# Scrivi i test prima, poi chiedi all'AI di implementare
def test_order_validation():
    """Questi test definiscono il comportamento atteso."""
    processor = OrderProcessor()
    assert processor.validate_order({"items": [{"id": 1, "qty": 2}]}) == True
    assert processor.validate_order({"items": []}) == False
    assert processor.validate_order({}) == False
    # "Implementa OrderProcessor.validate_order per far passare questi test"