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 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 il limite di sicurezza"

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 un 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 un profilo di consistenza dettagliato
texture_profile = tester.analyze_texture(
    test_tomato,
    include_mouthfeel=True,
    include_structural_analysis=True
)

# Accedi alle metriche di 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 Dolcezza:")
for tomato, score in comparison.get_rankings("sweetness"):
    print(f"- {tomato.variety}: {score}")

print("\nConfronto 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 Tomato

# Create a fresh tomato
my_tomato = Tomato(
    ripeness=0.8,  # 80% ripe
    variety="San Marzano",
    weight=150  # grams
)

# Check tomato properties
print(my_tomato.ripeness)  # 0.8
print(my_tomato.variety)   # "San Marzano"

from tomatopy import Kitchen

# Initialize your kitchen
kitchen = Kitchen()

# Configure kitchen settings
kitchen.set_temperature(180)  # Celsius
kitchen.set_humidity(65)      # Percentage

# Crea una salsa dal tuo pomodoro
sauce = kitchen.cook(
    my_tomato,
    method="simmer",
    duration="30m",
    temperature=100
)

# Check sauce properties
print(sauce.consistency)  # "smooth"
print(sauce.volume)       # 250  # ml

from tomatopy import Ingredient, Recipe

# Create additional ingredients
garlic = Ingredient("garlic", amount=3, unit="cloves")
basil = Ingredient("basil", amount=10, unit="leaves")

# Create a recipe
marinara = Recipe("Classic Marinara")
marinara.add_ingredient(my_tomato)
marinara.add_ingredient(garlic)
marinara.add_ingredient(basil)

# Cook the recipe
sauce = kitchen.cook_recipe(marinara)

from tomatopy import TasteTester

# Create a taste tester
tester = TasteTester()

# Analyze your sauce
profile = tester.analyze(sauce)

# Get taste metrics
print(profile.acidity)     # 0.7
print(profile.sweetness)   # 0.3
print(profile.umami)       # 0.8

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 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 Tomato, Garlic, Basil

# Crea ingredienti specializzati
san_marzano = Tomato(
    ripeness=0.8,
    variety="San Marzano",
    weight=150
)

fresh_garlic = Garlic(
    cloves=3,
    freshness=0.9,
    size="medium"
)

sweet_basil = Basil(
    leaves=10,
    freshness=0.95,
    variety="Genovese"
)

# Aggiorna le proprietà dell'ingrediente
tomato.properties["ripeness"] = 0.9
tomato.properties["water_content"] = 0.92

# Aggiornamento batch delle proprietà
tomato.update_properties({
    "ripeness": 0.9,
    "water_content": 0.92,
    "sugar_content": 0.04
})

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

# Ottieni misurazioni in diverse unità
print(tomato.get_weight("g"))  # 150
print(tomato.get_weight("oz"))  # 5.29

# Ottieni proprietà fisiche
print(tomato.get_density())  # 1.02 g/ml
print(tomato.get_volume())   # 147 ml
print(tomato.get_surface_area())  # 150 cm²

# Analizza le proprietà chimiche
print(tomato.get_ph())  # 4.5
print(tomato.get_water_content())  # 0.95
print(tomato.get_sugar_content())  # 0.03

# Taglia gli ingredienti
diced_tomato = tomato.cut(
    method="dice",
    size="medium",
    consistency="uniform"
)

# Tritura gli ingredienti
chopped_garlic = fresh_garlic.chop(
    fineness="medium",
    method="mince"
)

# Combina gli ingredienti
mixture = tomato.combine(
    fresh_garlic,
    sweet_basil,
    method="mix",
    consistency="chunky"
)

# Controlla la freschezza dell'ingrediente
if tomato.is_fresh():
    print("L'ingrediente è fresco")
else:
    print("L'ingrediente potrebbe essere scaduto")

# Ottieni punteggio di freschezza
freshness_score = tomato.get_freshness_score()  # 0.85

# Valuta la qualità dell'ingrediente
quality_report = tomato.assess_quality()
print(quality_report.overall_score)  # 0.92
print(quality_report.recommendations)  # ["Consider using within 2 days"]

try:
    # Tentativo di operazione non valida
    tomato.cut(method="invalid_method")
except IngredientError as e:
    print(f"Errore: {e}")  # "Metodo di taglio non valido"

try:
    # Tentativo di aggiornamento proprietà non valido
    tomato.update_properties({"invalid_property": 1.0})
except PropertyError as e:
    print(f"Errore: {e}")  # "Nome proprietà non valido"

from tomatopy import Kitchen, KitchenHardware

# Inizializza la cucina
cucina = Kitchen()

# Configura l'hardware
hardware = KitchenHardware()
fornello = hardware.get_stove()
frullatore = hardware.get_blender()

# Configura il fornello
fornello.configure(
    bruciatori={
        1: {"temperatura": 100, "dimensione": "media"},  # Per sobbollire
        2: {"temperatura": 200, "dimensione": "grande"}    # Per la cottura iniziale
    }
)

from tomatopy import Tomato, Garlic, Basil, OliveOil

# Crea pomodori San Marzano
pomodori = Tomato(
    maturazione=0.9,
    varietà="San Marzano",
    peso=800  # grammi
)

# Crea aglio fresco
aglio = Garlic(
    spicchi=4,
    freschezza=0.95,
    dimensione="media"
)

# Crea basilico fresco
basilico = Basil(
    foglie=20,
    freschezza=0.95,
    varietà="Genovese"
)

# Crea olio d'oliva
olio_d'oliva = OliveOil(
    quantità=60,  # ml
    qualità="extra_vergine",
    acidità=0.3  # %
)

from tomatopy import Recipe

# Crea la ricetta marinara
marinara = Recipe("Marinara Classica")

# Aggiungi ingredienti
marinara.add_ingredient(pomodori)
marinara.add_ingredient(aglio)
marinara.add_ingredient(basilico)
marinara.add_ingredient(olio_d'oliva)

# Imposta i parametri di cottura
marinara.set_cooking_method("sobbollire")
marinara.set_duration("45m")
marinara.set_temperature(100)  # Celsius

# Passo 1: Riscalda olio e aglio
olio_aglio = cucina.cook(
    [olio_d'oliva, aglio],
    metodo="sauté",
    temperatura=160,
    durata="5m",
    frequenza_mescolamento="costante"
)

# Passo 2: Aggiungi e cuoci i pomodori
miscela_di_pomodoro = cucina.cook(
    [olio_aglio, pomodori],
    metodo="sobbollire",
    temperatura=100,
    durata="30m",
    frequenza_mescolamento="occasionale"
)

# Passo 3: Frulla la salsa
salsa = frullatore.blend(
    miscela_di_pomodoro,
    velocità="media",
    durata="1m",
    consistenza="liscia"
)

# Passo 4: Aggiungi basilico e termina
salsa_finale = cucina.cook(
    [salsa, basilico],
    metodo="sobbollire",
    temperatura=90,
    durata="10m",
    frequenza_mescolamento="occasionale"
)

from tomatopy import TasteTester

# Crea un assaggiatore
tester = TasteTester()

# Analizza la salsa
profilo = tester.analyze(salsa_finale)

# Controlla le metriche di qualità
print(f"Dolcezza: {profilo.sweetness}")
print(f"Acidità: {profilo.acidity}")
print(f"Umami: {profilo.umami}")
print(f"Equilibrio complessivo: {profilo.balance}")

# Ottieni analisi della consistenza
texture = tester.analyze_texture(salsa_finale)
print(f"Consistenza: {texture.consistency}")
print(f"Liscihezza: {texture.smoothness}")

# Se è troppo acida, aggiungi un pizzico di zucchero
if profilo.acidity > 0.7:
    salsa_finale = cucina.adjust(
        salsa_finale,
        ingrediente="zucchero",
        quantità=5,  # grammi
        metodo="mescola"
    )

# Se è troppo densa, aggiungi un po' d'acqua
if texture.consistency > 0.8:
    salsa_finale = cucina.adjust(
        salsa_finale,
        ingrediente="acqua",
        quantità=50,  # ml
        metodo="mescola"
    )

# Ottieni rapporto di qualità completo
rapporto_di_qualità = tester.assess_quality(salsa_finale)

# Stampa le metriche di qualità
print(f"Qualità complessiva: {rapporto_di_qualità.overall_score}")
print(f"Punteggio equilibrio: {rapporto_di_qualità.balance_score}")
print(f"Punteggio consistenza: {rapporto_di_qualità.texture_score}")

# Ottieni raccomandazioni
print("Raccomandazioni:")
for rec in rapporto_di_qualità.recommendations:
    print(f"- {rec}")

from tomatopy import 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 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 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"]
)

# Tagliare la pizza a 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"