pip install tomatopy

git clone https://github.com/tomatopy/tomatopy.git
cd tomatopy
pip install -e .

# Crea un ambiente virtuale
python -m venv tomatopy-env

# Activate the virtual environment
# On Windows:
tomatopy-env\Scripts\activate
# On macOS/Linux:
source tomatopy-env/bin/activate

# Install TomatoPy
pip install tomatopy

import tomatopy
print(tomatopy.__version__)  # Should print the installed version

from tomatopy import Ingredient

# Crea un ingrediente di base
tomato = Ingredient(
    name="tomato",
    amount=1,
    unit="whole",
    properties={
        "ripeness": 0.8,
        "water_content": 0.95,
        "sugar_content": 0.03
    }
)

from tomatopy import Kitchen

kitchen = Kitchen()
kitchen.set_temperature(180)  # Celsius
kitchen.set_humidity(65)      # Percentuale

from tomatopy import Recipe

# Crea una ricetta
marinara = Recipe("Marinara Classica")
marinara.add_ingredient(tomato)
marinara.set_cooking_method("sobbollire")
marinara.set_duration("30m")

# Accedi e modifica le proprietà
print(tomato.properties["water_content"])  # 0.95
tomato.properties["ripeness"] = 0.9

# Esegui operazioni di cottura
sauce = kitchen.cook(
    tomato,
    method="sobbollire",
    temperature=100,
    duration="30m"
)

# Controlla lo stato dell'ingrediente
print(tomato.state)  # "crudo"
sauce = kitchen.cook(tomato, method="sobbollire")
print(sauce.state)   # "cotto"

from tomatopy import TasteTester

tester = TasteTester()
profile = tester.analyze(sauce)

# Accedi ai componenti del sapore
print(profile.acidity)     # 0.7
print(profile.sweetness)   # 0.3
print(profile.umami)       # 0.8

# Converti tra unità
tomato.convert_to_imperial()  # Converte da metrico a imperiale
sauce.convert_volume("ml", "cups")  # Converte tra unità di volume

prova:
    kitchen.cook(tomato, temperature=1000)  # Troppo caldo!
eccetto TemperatureError come e:
    print(f"Errore: {e}")  # "La temperatura supera il range di cottura sicuro"

from tomatopy import KitchenHardware

# Inizializza l'hardware della cucina
hardware = KitchenHardware()

# Inizializza attrezzature specifiche
oven = hardware.get_oven()
stove = hardware.get_stove()
blender = hardware.get_blender()

# Controlla il forno
oven.set_temperature(180)  # Celsius
oven.set_mode("bake")
oven.set_timer("30m")

# Controlla il fornello
stove.set_burner(1, temperature=100)  # Celsius
stove.set_burner(2, temperature=200)

# Controlla il frullatore
blender.set_speed("high")
blender.set_duration("1m")

# Configura le impostazioni avanzate del forno
oven.configure(
    temperature=180,
    mode="convection",
    humidity=0.65,
    fan_speed="high",
    steam_injection=True,
    heat_zones={
        "top": 190,
        "bottom": 170,
        "rear": 180
    }
)

# Configura le impostazioni avanzate del fornello
stove.configure(
    burners={
        1: {"temperature": 100, "size": "small"},
        2: {"temperature": 200, "size": "large"},
        3: {"temperature": 150, "size": "medium"},
        4: {"temperature": 180, "size": "medium"}
    },
    griddle_temperature=200,
    ventilation="high"
)

# Configura le impostazioni avanzate del frullatore
blender.configure(
    speed="high",
    duration="1m",
    pulse_pattern="intermittent",
    container_size="1.5L",
    blade_type="multi-purpose"
)

# Monitora lo stato delle attrezzature
print(f"Temperatura del forno: {oven.get_temperature()}°C")
print(f"Stato del fornello 1: {stove.get_burner_status(1)}")
print(f"Velocità del frullatore: {blender.get_speed()}")

# Configura un monitoraggio completo
with hardware.monitor() as monitor:
    # Monitora più parametri
    monitor.track_temperature(oven)
    monitor.track_power_usage(stove)
    monitor.track_vibration(blender)
    
    # Ottieni i dati di monitoraggio
    data = monitor.get_data()
    print(f"Storico delle temperature: {data.temperature_history}")
    print(f"Consumo energetico: {data.power_usage}")
    print(f"Livelli di vibrazione: {data.vibration_levels}")

# Esegui controlli di sicurezza
if hardware.check_safety():
    # Procedi con l'operazione
    oven.start()
else:
    print("Controllo di sicurezza fallito")

# Configura il monitoraggio della sicurezza
hardware.set_safety_monitoring(
    temperature_limits={
        "max": 300,  # Celsius
        "min": 50
    },
    power_limits={
        "max": 5000,  # Watts
        "min": 0
    },
    ventilation_required=True,
    emergency_shutdown=True
)

# Controlla lo stato delle attrezzature
status = hardware.check_status()

# Esegui manutenzione di base
if status.needs_cleaning:
    hardware.clean_equipment()
if status.needs_calibration:
    hardware.calibrate_equipment()

# Pianifica la manutenzione
hardware.schedule_maintenance(
    oven,
    tasks=["clean", "calibrate", "inspect"],
    frequency="weekly"
)

# Ottieni la cronologia della manutenzione
history = hardware.get_maintenance_history()
print(f"Ultima pulizia: {history.last_cleaning}")
print(f"Ultima calibrazione: {history.last_calibration}")

try:
    # Tentativo di temperatura non valida
    oven.set_temperature(1000)  # Troppo caldo!
except TemperatureError as e:
    print(f"Errore: {e}")  # "La temperatura supera il limite di sicurezza"

try:
    # Tentativo di operazione non valida
    blender.set_speed("invalid_speed")
except OperationError as e:
    print(f"Errore: {e}")  # "Impostazione della velocità non valida"

from tomatopy import Kitchen

# Inizializza una cucina
kitchen = Kitchen()

# Configura le impostazioni di base
kitchen.set_temperature(180)  # Celsius
kitchen.set_humidity(65)      # Percentuale
kitchen.set_pressure(101.3)   # kPa (pressione atmosferica)

# Configura impostazioni avanzate
kitchen.set_ventilation("high")
kitchen.set_lighting("bright")
kitchen.set_equipment({
    "stove": {"type": "gas", "burners": 4},
    "oven": {"type": "convection", "capacity": "large"},
    "blender": {"type": "high_speed", "capacity": "1.5L"}
})

# Cuocere gli ingredienti a fuoco lento
sauce = kitchen.cook(
    tomato,
    method="simmer",
    temperature=100,
    duration="30m",
    stirring_frequency="occasional"
)

# Bollire gli ingredienti
pasta = kitchen.cook(
    spaghetti,
    method="boil",
    temperature=100,
    duration="8m",
    salt_concentration=0.02  # 2% sale
)

# Arrostire gli ingredienti
roasted_tomatoes = kitchen.cook(
    tomatoes,
    method="roast",
    temperature=200,
    duration="45m",
    turning_frequency="every_15m"
)

# Cuocere a pressione gli ingredienti
beans = kitchen.cook(
    dried_beans,
    method="pressure_cook",
    pressure=103.4,  # kPa
    temperature=121,  # Celsius
    duration="30m"
)

# Cottura sous vide
steak = kitchen.cook(
    beef,
    method="sous_vide",
    temperature=55,
    duration="2h",
    vacuum_sealed=True
)

# Affumicare gli ingredienti
smoked_tomatoes = kitchen.cook(
    tomatoes,
    method="smoke",
    temperature=100,
    duration="4h",
    wood_type="hickory",
    smoke_intensity="medium"
)

from tomatopy import Recipe

# Crea una ricetta
marinara = Recipe("Marinara Classica")
marinara.add_ingredient(tomato)
marinara.add_ingredient(garlic)
marinara.add_ingredient(basil)

# Imposta i parametri di cottura
marinara.set_cooking_method("simmer")
marinara.set_duration("30m")
marinara.set_temperature(100)

# Cuocere più ricette
recipes = [marinara, pizza_sauce, tomato_soup]
results = kitchen.cook_batch(recipes)

# Elabora i risultati
for recipe, result in zip(recipes, results):
    print(f"{recipe.name}: {result.consistency}")

# Monitora la temperatura durante la cottura
with kitchen.temperature_monitor() as monitor:
    sauce = kitchen.cook(tomato, method="simmer")
    temperature_history = monitor.get_history()
    print(f"Temperatura media: {monitor.get_average()}°C")

# Imposta avvisi sulla temperatura
kitchen.set_temperature_alert(
    min_temp=95,
    max_temp=105,
    callback=lambda temp: print(f"Avviso temperatura: {temp}°C")
)

# Esegui controlli di sicurezza
se cucina.validate_cooking_parameters(
    temperatura=200,
    durata="2h",
    pressione=103.4
):
    # Procedi con la cottura
    risultato = cucina.cook(...)
altrimenti:
    print("Parametri di cottura non validi")

# Valuta i risultati della cottura
report_di_qualità = cucina.assess_cooking_result(salsa)
print(f"Qualità complessiva: {report_di_qualità.score}")
print(f"Raccomandazioni: {report_di_qualità.recommendations}")

prova:
    # Tenta un'operazione di cottura non valida
    cucina.cook(
        pomodoro,
        metodo="metodo_non_valido",
        temperatura=1000  # Troppo caldo!
    )
eccetto CookingError come e:
    print(f"Errore: {e}")  # "Metodo di cottura non valido"

prova:
    # Tenta una temperatura non sicura
    cucina.set_temperature(500)  # Troppo caldo!
eccetto TemperatureError come e:
    print(f"Errore: {e}")  # "La temperatura supera l'intervallo di sicurezza"

da tomatopy importare TasteTester

# Crea un tester di sapore
tester = TasteTester()

# Analizza un ingrediente di base
profile = tester.analyze(tomato)

# Ottieni metriche di sapore di base
print(f"Dolcezza: {profile.sweetness}")
print(f"Acidità: {profile.acidity}")
print(f"Umami: {profile.umami}")

# Ottieni profilo di sapore dettagliato
profile = tester.analyze(
    ingredient,
    depth="comprehensive",
    include_aroma=True,
    include_texture=True
)

# Accedi a metriche dettagliate
print(f"Dolcezza: {profile.sweetness}")
print(f"Acidità: {profile.acidity}")
print(f"Umami: {profile.umami}")
print(f"Intensità dell'aroma: {profile.aroma.intensity}")
print(f"Punteggio della consistenza: {profile.texture.score}")

# Confronta più ingredienti
comparison = tester.compare(
    [tomato1, tomato2, tomato3],
    metrics=["sweetness", "acidity", "umami"]
)

# Ottieni risultati del confronto
print(f"Il più dolce: {comparison.get_highest('sweetness')}")
print(f"Il più acido: {comparison.get_highest('acidity')}")
print(f"Il più umami: {comparison.get_highest('umami')}")

# Analizza l'equilibrio del sapore
balance = tester.analyze_balance(sauce)

# Ottieni metriche di equilibrio
print(f"Equilibrio complessivo: {balance.overall_score}")
print(f"Rapporto dolce-acido: {balance.sweet_sour_ratio}")
print(f"Miglioramento umami: {balance.umami_enhancement}")

# Analizza l'aroma
aroma_profile = tester.analyze_aroma(tomato)

# Ottieni metriche dell'aroma
print(f"Intensità dell'aroma: {aroma_profile.intensity}")
print(f"Complessità dell'aroma: {aroma_profile.complexity}")
print(f"Note primarie: {aroma_profile.primary_notes}")

# Ottieni profilo di aroma dettagliato
aroma_profile = tester.analyze_aroma(
    ingredient,
    include_secondary_notes=True,
    include_tertiary_notes=True
)

# Accedi a metriche dettagliate dell'aroma
print(f"Note primarie: {aroma_profile.primary_notes}")
print(f"Note secondarie: {aroma_profile.secondary_notes}")
print(f"Note terziarie: {aroma_profile.tertiary_notes}")

# Analizza la consistenza
texture_profile = tester.analyze_texture(tomato)

# Ottieni metriche della consistenza
print(f"Firmezza: {texture_profile.firmness}")
print(f"Succosità: {texture_profile.juiciness}")
print(f"Consistenza complessiva: {texture_profile.overall_score}")

# Ottieni profilo di consistenza dettagliato
texture_profile = tester.analyze_texture(
    ingredient,
    include_mouthfeel=True,
    include_structural_analysis=True
)

# Accedi a metriche dettagliate della consistenza
print(f"Firmezza: {texture_profile.firmness}")
print(f"Succosità: {texture_profile.juiciness}")
print(f"Sensazione in bocca: {texture_profile.mouthfeel}")
print(f"Integrità strutturale: {texture_profile.structural_integrity}")

# Valuta la qualità
quality = tester.assess_quality(tomato)

# Ottieni metriche di qualità
print(f"Qualità complessiva: {quality.overall_score}")
print(f"Freschezza: {quality.freshness}")
print(f"Maturazione: {quality.ripeness}")

# Ottieni valutazione della qualità completa
quality = tester.assess_quality(
    ingredient,
    include_safety=True,
    include_shelf_life=True
)

# Accedi a metriche dettagliate di qualità
print(f"Qualità complessiva: {quality.overall_score}")
print(f"Punteggio di sicurezza: {quality.safety_score}")
print(f"Stima della durata di conservazione: {quality.shelf_life}")

# Crea visualizzazione del profilo di sapore
viz = tester.visualize_profile(profile)

# Mostra visualizzazione
viz.show()

# Crea una visualizzazione dettagliata
viz = tester.visualize_profile(
    profilo,
    include_aroma=True,
    include_texture=True,
    style="radar"
)

# Personalizza la visualizzazione
viz.set_color_scheme("pomodoro")
viz.set_scale("logaritmica")
viz.show()

try:
    # Attempt invalid analysis
    tester.analyze("invalid_ingredient")
except TasteError as e:
    print(f"Error: {e}")  # "Invalid ingredient type"

try:
    # Attempt invalid comparison
    tester.compare([], metrics=["sweetness"])
except ComparisonError as e:
    print(f"Error: {e}")  # "No ingredients provided for comparison"

from tomatopy import TasteTester, TasteProfile

# Inizializza il tester del gusto
tester = TasteTester()

# Configura l'ambiente di test
tester.configure(
    temperature=22,  # Celsius
    humidity=0.65,
    lighting="standard",
    background_noise="minimal"
)

# Crea un ingrediente di test
from tomatopy import Tomato

test_tomato = Tomato(
    ripeness=0.9,
    variety="San Marzano",
    weight=150  # grammi
)

# Esegui un'analisi completa
profile = tester.analyze(
    test_tomato,
    depth="comprehensive",
    include_aroma=True,
    include_texture=True
)

# Accedi alle metriche di base
print(f"Dolcezza: {profile.sweetness}")
print(f"Acidità: {profile.acidity}")
print(f"Umami: {profile.umami}")

# Ottieni il profilo aromatico dettagliato
aroma_profile = tester.analyze_aroma(
    test_tomato,
    include_secondary_notes=True,
    include_tertiary_notes=True
)

# Accedi alle metriche aromatiche
print("Note Primarie:")
for note in aroma_profile.primary_notes:
    print(f"- {note.name}: {note.intensity}")

print("\nNote Secondarie:")
for note in aroma_profile.secondary_notes:
    print(f"- {note.name}: {note.intensity}")

print("\nNote Terziarie:")
for note in aroma_profile.tertiary_notes:
    print(f"- {note.name}: {note.intensity}")

# Ottieni il profilo della consistenza dettagliato
texture_profile = tester.analyze_texture(
    test_tomato,
    include_mouthfeel=True,
    include_structural_analysis=True
)

# Accedi alle metriche della consistenza
print(f"Fermità: {texture_profile.firmness}")
print(f"Succosità: {texture_profile.juiciness}")
print(f"Sensazione in bocca: {texture_profile.mouthfeel}")
print(f"Integrità strutturale: {texture_profile.structural_integrity}")

# Analizza l'equilibrio dei sapori
balance = tester.analyze_balance(test_tomato)

# Accedi alle metriche di equilibrio
print(f"Equilibrio complessivo: {balance.overall_score}")
print(f"Rapporto dolce-acido: {balance.sweet_sour_ratio}")
print(f"Miglioramento umami: {balance.umami_enhancement}")
print(f"Complessità del sapore: {balance.complexity}")

# Crea più ingredienti di test
tomato1 = Tomato(ripeness=0.8, variety="San Marzano")
tomato2 = Tomato(ripeness=0.9, variety="Roma")
tomato3 = Tomato(ripeness=0.7, variety="Cherry")

# Esegui un'analisi comparativa
comparison = tester.compare(
    [tomato1, tomato2, tomato3],
    metrics=["sweetness", "acidity", "umami", "aroma"]
)

# Accedi ai risultati del confronto
print("\nConfronto della dolcezza:")
for tomato, score in comparison.get_rankings("sweetness"):
    print(f"- {tomato.variety}: {score}")

print("\nConfronto dell'acidità:")
for tomato, score in comparison.get_rankings("acidity"):
    print(f"- {tomato.variety}: {score}")

# Crea un profilo target
target_profile = TasteProfile(
    sweetness=0.7,
    acidity=0.6,
    umami=0.8,
    aroma_intensity=0.75
)

# Analizza il profilo attuale
current_profile = tester.analyze(test_tomato)

# Ottieni raccomandazioni per l'ottimizzazione
recommendations = tester.get_optimization_recommendations(
    current_profile,
    target_profile
)

# Stampa le raccomandazioni
print("\nRaccomandazioni per l'ottimizzazione:")
for rec in recommendations:
    print(f"- {rec}")

# Crea una visualizzazione di base
viz = tester.visualize_profile(profile)

# Personalizza la visualizzazione
viz.set_color_scheme("tomato")
viz.set_scale("logarithmic")
viz.set_style("radar")

# Aggiungi metriche aggiuntive
viz.add_metrics(["aroma", "texture"])

# Mostra la visualizzazione
viz.show()

# Esegui analisi multidimensionale
analisi = tester.analyze_multi_dimensional(
    test_tomato,
    dimensions=[
        "gusto",
        "aroma",
        "texture",
        "sensazione in bocca",
        "retrogusto"
    ]
)

# Accedi ai risultati multidimensionali
print("\nAnalisi Multidimensionale:")
for dimension, metrics in analisi.items():
    print(f"\n{dimension.upper()}:")
    for metric, value in metrics.items():
        print(f"- {metric}: {value}")

# Analyze flavor development over time
# Esegui analisi statistica
stats = tester.analyze_statistics(
    [tomato1, tomato2, tomato3],
    metrics=["dolcezza", "acidità", "umami"]
)

# Accedi ai risultati statistici
print("\nAnalisi Statistica:")
print(f"Media dolcezza: {stats.mean('sweetness')}")

# Perform statistical analysis
stats = tester.analyze_statistics(
    [tomato1, tomato2, tomato3],
    metrics=["sweetness", "acidity", "umami"]
)

# Access statistical results
print("\nStatistical Analysis:")
print(f"Mean sweetness: {stats.mean('sweetness')}")
print(f"Standard deviation: {stats.std('sweetness')}")
print(f"Correlation matrix: {stats.correlation_matrix}")

from tomatopy import Kitchen, KitchenHardware

# Initialize kitchen
kitchen = Kitchen()

# Set up hardware
hardware = KitchenHardware()
stove = hardware.get_stove()
blender = hardware.get_blender()

# Configure stove
stove.configure(
    burners={
        1: {"temperature": 100, "size": "medium"},  # For simmering
        2: {"temperature": 200, "size": "large"}    # For initial cooking
    }
)

from tomatopy import Tomato, Garlic, Basil, OliveOil

# Create San Marzano tomatoes
tomatoes = Tomato(
    ripeness=0.9,
    variety="San Marzano",
    weight=800  # grams
)

# Create fresh garlic
garlic = Garlic(
    cloves=4,
    freshness=0.95,
    size="medium"
)

# Create fresh basil
basil = Basil(
    leaves=20,
    freshness=0.95,
    variety="Genovese"
)

# Create olive oil
olive_oil = OliveOil(
    amount=60,  # ml
    quality="extra_virgin",
    acidity=0.3  # %
)

from tomatopy import Recipe

# Create marinara recipe
marinara = Recipe("Classic Marinara")

# Add ingredients
marinara.add_ingredient(tomatoes)
marinara.add_ingredient(garlic)
marinara.add_ingredient(basil)
marinara.add_ingredient(olive_oil)

# Set cooking parameters
marinara.set_cooking_method("simmer")
marinara.set_duration("45m")
marinara.set_temperature(100)  # Celsius

# Passo 1: Riscalda olio e aglio
garlic_oil = kitchen.cook(
    [olive_oil, garlic],
    method="sauté",
    temperature=160,
    duration="5m",
    stirring_frequency="constant"
)

# Step 2: Add and cook tomatoes
tomato_mixture = kitchen.cook(
    [garlic_oil, tomatoes],
    method="simmer",
    temperature=100,
    duration="30m",
    stirring_frequency="occasional"
)

# Step 3: Blend the sauce
sauce = blender.blend(
    tomato_mixture,
    speed="medium",
    duration="1m",
    consistency="smooth"
)

# Step 4: Add basil and finish
final_sauce = kitchen.cook(
    [sauce, basil],
    method="simmer",
    temperature=90,
    duration="10m",
    stirring_frequency="occasional"
)

from tomatopy import TasteTester

# Create taste tester
tester = TasteTester()

# Analyze sauce
profile = tester.analyze(final_sauce)

# Check quality metrics
print(f"Sweetness: {profile.sweetness}")
print(f"Acidity: {profile.acidity}")
print(f"Umami: {profile.umami}")
print(f"Overall balance: {profile.balance}")

# Get texture analysis
texture = tester.analyze_texture(final_sauce)
print(f"Consistency: {texture.consistency}")
print(f"Smoothness: {texture.smoothness}")

# Se troppo acida, aggiungi un pizzico di zucchero
if profile.acidity > 0.7:
    final_sauce = kitchen.adjust(
        final_sauce,
        ingredient="sugar",
        amount=5,  # grams
        method="stir"
    )

# If too thick, add some water
if texture.consistency > 0.8:
    final_sauce = kitchen.adjust(
        final_sauce,
        ingredient="water",
        amount=50,  # ml
        method="stir"
    )

# Ottieni rapporto di qualità completo
quality_report = tester.assess_quality(final_sauce)

# Print quality metrics
print(f"Overall quality: {quality_report.overall_score}")
print(f"Balance score: {quality_report.balance_score}")
print(f"Texture score: {quality_report.texture_score}")

# Get recommendations
print("Recommendations:")
for rec in quality_report.recommendations:
    print(f"- {rec}")

from tomatopy import Pizza, PizzaDough, PizzaSauce

# Crea componenti della pizza
dough = PizzaDough(
    thickness="medium",
    size="12inch",
    style="neapolitan"
)

sauce = PizzaSauce(
    base="tomato",
    consistency="smooth",
    seasoning_level="medium"
)

# Crea una pizza
pizza = Pizza(
    dough=dough,
    sauce=sauce,
    size="12inch",
    style="neapolitan"
)

from tomatopy import Topping

# Crea condimenti
mozzarella = Topping(
    name="mozzarella",
    amount=200,  # grammi
    distribution="even"
)

basil = Topping(
    name="basil",
    amount=10,  # foglie
    distribution="scattered"
)

# Aggiungi condimenti alla pizza
pizza.add_topping(mozzarella)
pizza.add_topping(basil)

# Crea pasta personalizzata
custom_dough = PizzaDough(
    thickness="thin",
    size="14inch",
    style="new_york",
    hydration=0.65,  # 65% idratazione
    fermentation_time="24h",
    flour_type="00",
    salt_content=0.02  # 2% sale
)

# Crea salsa personalizzata
custom_sauce = PizzaSauce(
    base="tomato",
    consistency="chunky",
    seasoning_level="high",
    herbs=["basil", "oregano"],
    garlic_content=0.05,  # 5% aglio
    sugar_content=0.02    # 2% zucchero
)

from tomatopy import PizzaOven

# Configura il forno per la pizza
oven = PizzaOven(
    temperature=450,  # Celsius
    heat_source="wood",
    humidity=0.65
)

# Cuoci la pizza
baked_pizza = oven.bake(
    pizza,
    duration="2m",
    rotation_frequency="30s"
)

# Configura cottura avanzata
baked_pizza = oven.bake(
    pizza,
    duration="2m",
    rotation_frequency="30s",
    heat_zones={
        "center": 450,
        "edges": 480,
        "top": 460
    },
    steam_injection=True,
    crust_development="high"
)

# Analizza la qualità della pizza
analysis = pizza.analyze()
print(f"Crispness della crosta: {analysis.crust_crispness}")
print(f"Fusione del formaggio: {analysis.cheese_melt}")
print(f"Distribuzione dei condimenti: {analysis.topping_distribution}")

# Ottieni metriche di qualità dettagliate
metrics = pizza.get_quality_metrics()
print(f"Punteggio complessivo: {metrics.overall_score}")
print(f"Punteggio di equilibrio: {metrics.balance_score}")
print(f"Punteggio di consistenza: {metrics.texture_score}")

# Crea pizza napoletana autentica
neapolitan = Pizza.create_neapolitan(
    size="12inch",
    toppings=["san_marzano_tomatoes", "mozzarella", "basil"]
)

# Crea pizza in stile New York
ny_style = Pizza.create_ny_style(
    size="18inch",
    thickness="thin",
    toppings=["tomato_sauce", "mozzarella", "pepperoni"]
)

# Crea deep dish di Chicago
chicago = Pizza.create_chicago_style(
    size="10inch",
    thickness="deep",
    toppings=["tomato_sauce", "mozzarella", "sausage"]
)

# Taglia la pizza in fette
fette = pizza.taglia(
    metodo="standard",
    fette=8,
    dimensione_fetta="uguale"
)

# Taglio personalizzato della pizza
fette = pizza.taglia(
    metodo="personalizzato",
    dimensioni_fette=["grande", "media", "piccola"],
    modello="radiale"
)

prova:
    # Tentativo di aggiungere un condimento non valido
    pizza.aggiungi_condimento("condimento_non_valido")
eccetto ToppingError come e:
    print(f"Errore: {e}")  # "Tipo di condimento non valido"

prova:
    # Tentativo di impostare una temperatura di cottura non valida
    forno.imposta_temperatura(1000)  # Troppo caldo!
eccetto TemperatureError come e:
    print(f"Errore: {e}")  # "La temperatura supera il limite di sicurezza"

from tomatopy import Kitchen, KitchenHardware

# Inizializza la cucina con impostazioni di base
kitchen = Kitchen(
    temperature=22,  # Celsius
    humidity=0.65,
    ventilation="standard",
    lighting="bright"
)

# Configura l'hardware
hardware = KitchenHardware()
hardware.configure(
    oven={"type": "convection", "capacity": "large"},
    stove={"burners": 4, "type": "gas"},
    refrigerator={"capacity": "medium", "temperature": 4}
)

# Configura impostazioni avanzate
kitchen.configure(
    temperature_control={
        "precision": 0.1,
        "zones": ["prep", "cooking", "storage"]
    },
    humidity_control={
        "precision": 0.05,
        "zones": ["prep", "cooking", "storage"]
    },
    ventilation={
        "type": "smart",
        "zones": ["prep", "cooking", "storage"],
        "filters": ["grease", "smoke", "odor"]
    }
)

# Buono: Assegnazione efficiente delle attrezzature
class KitchenManager:
    def __init__(self):
        self.equipment_pool = {}
        self.allocations = {}

    def allocate_equipment(self, recipe):
        required = recipe.get_required_equipment()
        available = self.get_available_equipment()
        
        for item in required:
            if item in available:
                self.allocations[recipe.id] = item
                return True
        return False

# Cattivo: Nessuna gestione delle attrezzature
def cook_recipe(recipe):
    # Nessuna assegnazione delle attrezzature
    pass

# Buono: Ottimizza lo spazio in cucina
class KitchenLayout:
    def __init__(self):
        self.workstations = {}
        self.workflow = {}

    def optimize_layout(self, recipes):
        for recipe in recipes:
            required_space = recipe.get_required_space()
            available_space = self.get_available_space()
            
            if self.can_fit(required_space, available_space):
                self.allocate_space(recipe, available_space)

# Cattivo: Nessuna ottimizzazione dello spazio
def prepare_recipe(recipe):
    # Nessuna gestione dello spazio
    pass

# Buono: Pianificazione efficiente delle attività
class KitchenScheduler:
    def __init__(self):
        self.tasks = []
        self.resources = {}

    def schedule_tasks(self, recipes):
        for recipe in recipes:
            tasks = recipe.get_tasks()
            for task in tasks:
                if self.can_schedule(task):
                    self.tasks.append(task)
                else:
                    self.handle_scheduling_conflict(task)

# Cattivo: Nessuna pianificazione delle attività
def process_recipes(recipes):
    for recipe in recipes:
        # Nessuna pianificazione
        process_recipe(recipe)

# Buono: Ottimizza il flusso di lavoro
class WorkflowOptimizer:
    def optimize_workflow(self, tasks):
        # Ordina le attività per priorità e dipendenze
        sorted_tasks = self.topological_sort(tasks)
        
        # Raggruppa le attività compatibili
        task_groups = self.group_tasks(sorted_tasks)
        
        # Pianifica i gruppi in modo efficiente
        return self.schedule_groups(task_groups)

# Cattivo: Nessuna ottimizzazione del flusso di lavoro
def process_tasks(tasks):
    for task in tasks:
        # Nessuna ottimizzazione
        process_task(task)

# Buono: Gestisci le zone di temperatura
class TemperatureManager:
    def __init__(self):
        self.zones = {}
        self.controllers = {}

    def manage_zones(self):
        for zone, settings in self.zones.items():
            current_temp = self.get_zone_temperature(zone)
            target_temp = settings["target"]
            
            if abs(current_temp - target_temp) > settings["tolerance"]:
                self.adjust_zone_temperature(zone, target_temp)

# Cattivo: Nessuna gestione delle zone
def set_temperature(temp):
    # Nessun controllo delle zone
    pass

# Buono: Monitora le temperature
class TemperatureMonitor:
    def __init__(self):
        self.sensors = {}
        self.alerts = []

    def monitor_temperatures(self):
        for zone, sensor in self.sensors.items():
            temp = sensor.read()
            if self.is_temperature_unsafe(temp, zone):
                self.trigger_alert(zone, temp)

# Cattivo: Nessun monitoraggio della temperatura
def check_temperature():
    # Nessun monitoraggio
    pass

# Buono: Implementa protocolli di sicurezza
class SafetyManager:
    def __init__(self):
        self.protocols = {}
        self.violations = []

    def enforce_safety(self, operation):
        if not self.check_safety_protocols(operation):
            self.handle_safety_violation(operation)
            return False
        return True

# Cattivo: Nessun protocollo di sicurezza
def perform_operation(operation):
    # Nessun controllo di sicurezza
    pass

# Buono: Gestisci le emergenze
class EmergencyManager:
    def __init__(self):
        self.procedures = {}
        self.emergency_contacts = []

    def handle_emergency(self, emergency_type):
        if emergency_type in self.procedures:
            self.execute_procedure(emergency_type)
            self.notify_emergency_contacts(emergency_type)

# Cattivo: Nessuna gestione delle emergenze
def handle_problem(problem):
    # Nessuna procedura di emergenza
    pass

# Buono: Gestisci la manutenzione delle attrezzature
class MaintenanceManager:
    def __init__(self):
        self.schedule = {}
        self.maintenance_history = []

    def schedule_maintenance(self, equipment):
        if equipment.needs_maintenance():
            self.add_to_schedule(equipment)
            self.notify_maintenance_team(equipment)

# Cattivo: Nessuna pianificazione della manutenzione
def fix_equipment(equipment):
    # Nessuna gestione della manutenzione
    pass

# Buono: Implementare protocolli di pulizia
class CleaningManager:
    def __init__(self):
        self.protocols = {}
        self.cleaning_schedule = []

    def manage_cleaning(self):
        for area in self.get_areas():
            if area.needs_cleaning():
                self.schedule_cleaning(area)
                self.notify_cleaning_staff(area)

# Cattivo: Nessuna gestione della pulizia
def clean_area(area):
    # Nessun protocollo di pulizia
    pass

# Buono: Crea ingredienti con un uso minimo della memoria
tomato = Tomato(
    ripeness=0.8,
    variety="San Marzano",
    weight=150
)

# Cattivo: Creare copie non necessarie
tomato_copy = tomato.copy()  # Uso di memoria non necessario

# Buono: Elabora ingredienti in batch
def process_ingredients(ingredients, batch_size=100):
    for i in range(0, len(ingredients), batch_size):
        batch = ingredients[i:i + batch_size]
        process_batch(batch)

# Cattivo: Elaborazione uno alla volta
for ingredient in ingredients:
    process_single(ingredient)  # Meno efficiente

from functools import lru_cache

# Buono: Cache delle computazioni costose
@lru_cache(maxsize=128)
def analyze_ingredient(ingredient):
    return TasteTester().analyze(ingredient)

# Cattivo: Ricalcolare ogni volta
def analyze_ingredient(ingredient):
    return TasteTester().analyze(ingredient)  # Nessun caching

# Buono: Usa strutture dati appropriate
from collections import defaultdict

class Recipe:
    def __init__(self):
        self.ingredients = defaultdict(float)  # Efficiente per il tracciamento degli ingredienti

# Cattivo: Uso di strutture inefficienti
class Recipe:
    def __init__(self):
        self.ingredients = []  # Meno efficiente per le ricerche

# Buono: Usa gestori di contesto per la pulizia delle risorse
with kitchen.temperature_monitor() as monitor:
    result = kitchen.cook(ingredient)
    data = monitor.get_data()

# Cattivo: Gestione manuale delle risorse
monitor = kitchen.temperature_monitor()
try:
    result = kitchen.cook(ingredient)
    data = monitor.get_data()
finally:
    monitor.cleanup()  # Più soggetto a errori

# Buono: Usa il pooling delle connessioni
from tomatopy import ConnectionPool

pool = ConnectionPool(max_connections=10)
with pool.get_connection() as conn:
    conn.execute_operation()

# Cattivo: Creare nuove connessioni ogni volta
conn = create_connection()  # Meno efficiente
conn.execute_operation()
conn.close()

# Buono: Usa la ricerca binaria per dati ordinati
def find_optimal_temperature(sorted_temps, target):
    left, right = 0, len(sorted_temps) - 1
    while left <= right:
        mid = (left + right) // 2
        if sorted_temps[mid] == target:
            return mid
        elif sorted_temps[mid] < target:
            left = mid + 1
        else:
            right = mid - 1
    return -1

# Cattivo: Ricerca lineare
def find_optimal_temperature(temps, target):
    for i, temp in enumerate(temps):
        if temp == target:
            return i
    return -1

from concurrent.futures import ThreadPoolExecutor

# Buono: Elabora più ingredienti in parallelo
def process_ingredients_parallel(ingredients):
    with ThreadPoolExecutor(max_workers=4) as executor:
        results = list(executor.map(process_ingredient, ingredients))
    return results

# Cattivo: Elaborazione sequenziale
def process_ingredients_sequential(ingredients):
    results = []
    for ingredient in ingredients:
        results.append(process_ingredient(ingredient))
    return results

# Buono: Struttura del codice modulare
class IngredientProcessor:
    def process(self, ingredient):
        self.validate(ingredient)
        self.prepare(ingredient)
        self.analyze(ingredient)

# Cattivo: Funzioni monolitiche
def process_ingredient(ingredient):
    # Tutto il processamento in una funzione
    validate_ingredient(ingredient)
    prepare_ingredient(ingredient)
    analyze_ingredient(ingredient)

# Buono: Design di interfaccia pulita
class Kitchen:
    def cook(self, ingredient, **kwargs):
        self._validate_parameters(kwargs)
        self._prepare_environment()
        return self._execute_cooking(ingredient, kwargs)

# Cattivo: Interfaccia complessa
def cook(ingredient, temperature=None, duration=None, method=None, 
         stirring_frequency=None, humidity=None, pressure=None):
    # Troppi parametri
    pass

# Buono: Recupero dagli errori in modo elegante
def process_recipe(recipe):
    try:
        result = kitchen.cook_recipe(recipe)
        return result
    except TemperatureError:
        # Gestisci l'errore di temperatura
        return adjust_temperature(recipe)
    except IngredientError:
        # Gestisci l'errore di ingrediente
        return substitute_ingredients(recipe)
    finally:
        cleanup_resources()

# Cattivo: Nessun recupero dagli errori
def process_recipe(recipe):
    result = kitchen.cook_recipe(recipe)
    return result  # Nessuna gestione degli errori

# Buono: Pulizia adeguata delle risorse
classe Cucina:
    def __init__(self):
        self.resources = []

    def __enter__(self):
        return self

    def __exit__(self, exc_type, exc_val, exc_tb):
        self.cleanup()

# Cattivo: Pulizia manuale
def use_kitchen():
    kitchen = Cucina()
    try:
        # Usa la cucina
        pass
    finally:
        kitchen.cleanup()

# Good: Performance testing
import time
import cProfile

def profile_operation(func):
    def wrapper(*args, **kwargs):
        profiler = cProfile.Profile()
        result = profiler.runcall(func, *args, **kwargs)
        profiler.print_stats()
        return result
    return wrapper

# Bad: No performance testing
def operation():
    # No performance monitoring
    pass

# Good: Memory profiling
from memory_profiler import profile

@profile
def memory_intensive_operation():
    # Operation to profile
    pass

# Bad: No memory profiling
def memory_intensive_operation():
    # No memory monitoring
    pass

from tomatopy import Kitchen, KitchenHardware

# Inizializza la cucina
cucina = Kitchen()

# Configura l'hardware
hardware = KitchenHardware()
forno = hardware.get_oven()

# Configura il forno per la pizza
forno.configure(
    temperatura=450,  # Celsius
    fonte_di_calore="legna",
    umidità=0.65,
    zone_di_calore={
        "centro": 450,
        "bordo": 480,
        "cima": 460
    }
)

from tomatopy import PizzaDough

# Crea l'impasto per pizza
impasto = PizzaDough(
    spessore="medio",
    dimensione="14pollici",
    stile="napoletano",
    idratazione=0.65,  # 65% di idratazione
    tempo_di_fermentazione="24h",
    tipo_di_farina="00",
    contenuto_di_sale=0.02  # 2% di sale
)

# Controlla le proprietà dell'impasto
print(f"Idratazione dell'impasto: {impasto.get_hydration()}")
print(f"Stato di fermentazione: {impasto.get_fermentation_status()}")

from tomatopy import PizzaSauce, Tomato, Garlic, Basil

# Crea gli ingredienti della salsa
pomodori = Tomato(
    maturazione=0.9,
    varietà="San Marzano",
    peso=400  # grammi
)

aglio = Garlic(
    spicchi=3,
    freschezza=0.95,
    dimensione="media"
)

basilico = Basil(
    foglie=10,
    freschezza=0.95,
    varietà="Genovese"
)
# Crea la salsa per pizza
salsa = PizzaSauce(
    base="pomodoro",
    consistenza="liscia",
    livello_di_condimento="medio",
    erbe=["basilico", "origano"],
    contenuto_di_aglio=0.05,  # 5% di aglio
    contenuto_di_zucchero=0.02    # 2% di zucchero
)
)

from tomatopy import Topping

# Crea i condimenti
mozzarella = Topping(
    nome="mozzarella",
    quantità=200,  # grammi
    distribuzione="uniforme",
    contenuto_di_umidità=0.52
)

pepperoni = Topping(
    nome="pepperoni",
    quantità=100,  # grammi
    distribuzione="sparsa",
    piccantezza="media"
)

basilico = Topping(
    nome="basilico",
    quantità=10,  # foglie
    distribuzione="sparsa",
    freschezza=0.95
)

from tomatopy import Pizza

# Crea la pizza
pizza = Pizza(
    impasto=impasto,
    salsa=salsa,
    dimensione="14pollici",
    stile="napoletano"
)

# Aggiungi i condimenti
pizza.add_topping(mozzarella)
pizza.add_topping(pepperoni)
pizza.add_topping(basilico)

# Controlla la distribuzione dei condimenti
distribuzione = pizza.get_topping_distribution()
print(f"Punteggio di distribuzione dei condimenti: {distribuzione}")

# Preriscalda il forno
forno.preheat(
    temperatura=450,
    durata="30m",
    zone_di_calore={
        "centro": 450,
        "bordo": 480,
        "cima": 460
    }
)
# Cuoci la pizza
pizza_cotta = forno.bake(
    pizza,
    durata="2m",
    frequenza_di_rotazione="30s",
    iniezione_di_vapore=True,
    sviluppo_della_crosta="alto"
)
)
# Monitora il processo di cottura
with forno.temperature_monitor() as monitor:
    print(f"Temperatura centrale: {monitor.get_center_temp()}°C")
    print(f"Temperatura bordo: {monitor.get_edge_temp()}°C")
    print(f"Edge temperature: {monitor.get_edge_temp()}°C")

from tomatopy import TasteTester

# Crea il tester di gusto
tester = TasteTester()

# Analizza la pizza
profilo = tester.analyze(pizza_cotta)

# Controlla le metriche di qualità
print(f"Croccantezza della crosta: {profilo.crust_crispness}")
print(f"Fusione del formaggio: {profilo.cheese_melt}")
print(f"Distribuzione dei condimenti: {profilo.topping_distribution}")

# Ottieni l'analisi della consistenza
consistenza = tester.analyze_texture(pizza_cotta)
print(f"Consistenza della crosta: {consistenza.crust_texture}")
print(f"Consistenza del formaggio: {consistenza.cheese_texture}")

# Taglia la pizza in fette
fette = pizza_cotta.cut(
    metodo="standard",
    fette=8,
    dimensione_fetta="uguale"
)

# Analizza la qualità delle fette
for i, fetta in enumerate(fette):
    print(f"Qualità della fetta {i+1}: {fetta.get_quality_score()}")

# Crea un lotto di pizze
Sviluppo di Crosta Personalizzata
    Pizza.create_neapolitan(size="12inch"),
    Pizza.create_ny_style(size="18inch"),
    Pizza.create_chicago_style(size="10inch")
]

# Bake batch
baked_pizzas = oven.bake_batch(
    pizzas,
    rotation_frequency="30s",
    steam_injection=True
)

# Configure advanced crust development
baked_pizza = oven.bake(
    pizza,
    crust_development={
        "bottom": "crispy",
        "edges": "chewy",
        "top": "golden"
    }
)