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"

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 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

# 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

# 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 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}")

# 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: Memorizza calcoli costosi
@lru_cache(maxsize=128)
def analyze_ingredient(ingredient):
    return TasteTester().analyze(ingredient)

# Cattivo: Ricalcolare ogni volta
def analyze_ingredient(ingredient):
    return TasteTester().analyze(ingredient)  # Nessuna memorizzazione

# 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 processo in una funzione
    validate_ingredient(ingredient)
    prepare_ingredient(ingredient)
    analyze_ingredient(ingredient)

# Buono: Design dell'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 degli errori 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 degli 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():
    cucina = Cucina()
    try:
        # Usa la cucina
        pass
    finally:
        cucina.cleanup()

# Buono: test delle prestazioni
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

# Cattivo: nessun test delle prestazioni
def operation():
    # Nessun monitoraggio delle prestazioni
    pass

# Buono: profilazione della memoria
from memory_profiler import profile

@profile
def memory_intensive_operation():
    # Operazione da profilare
    pass

# Cattivo: nessuna profilazione della memoria
def memory_intensive_operation():
    # Nessun monitoraggio della memoria
    pass

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