# Classic Dishes

{% hint style="info" %}
[PizzaStack](https://tomatopy.pizza/docs) is TomatoPy's pizza-making HTTP API. Acquire, prepare, cook, and assemble virtual pizzas programmatically.
{% endhint %}

A collection of classic tomato-based recipes implemented in TomatoPy. Each recipe includes detailed instructions, ingredient specifications, and quality control measures.

## Classic Marinara Sauce

### Ingredients

```python
from tomatopy import Tomato, Garlic, Basil, OliveOil

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

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

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

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

### Instructions

```python
from tomatopy import Kitchen, Recipe

# Initialize kitchen
kitchen = Kitchen()

# Create recipe
marinara = Recipe("Classic Marinara")
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

# Execute recipe
sauce = kitchen.cook_recipe(marinara)
```

### Quality Control

```python
from tomatopy import TasteTester

# Analyze sauce
tester = TasteTester()
profile = tester.analyze(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}")
```

## Classic Pizza Sauce

### Ingredients

```python
# Create ingredients
tomatoes = Tomato(
    ripeness=0.9,
    variety="San Marzano",
    weight=400  # grams
)

garlic = Garlic(
    cloves=3,
    freshness=0.95,
    size="medium"
)

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

oregano = Oregano(
    amount=5,  # grams
    freshness=0.9,
    variety="Mediterranean"
)
```

### Instructions

```python
# Create recipe
pizza_sauce = Recipe("Classic Pizza Sauce")
pizza_sauce.add_ingredient(tomatoes)
pizza_sauce.add_ingredient(garlic)
pizza_sauce.add_ingredient(basil)
pizza_sauce.add_ingredient(oregano)

# Set cooking parameters
pizza_sauce.set_cooking_method("simmer")
pizza_sauce.set_duration("30m")
pizza_sauce.set_temperature(90)  # Celsius

# Execute recipe
sauce = kitchen.cook_recipe(pizza_sauce)
```

### Quality Control

```python
# Analyze sauce
profile = tester.analyze(sauce)

# Check quality metrics
print(f"Consistency: {profile.consistency}")
print(f"Herb balance: {profile.herb_balance}")
print(f"Overall quality: {profile.overall_score}")
```

## Classic Tomato Soup

### Ingredients

```python
# Create ingredients
tomatoes = Tomato(
    ripeness=0.85,
    variety="Roma",
    weight=1000  # grams
)

onion = Onion(
    amount=200,  # grams
    variety="yellow",
    sweetness=0.7
)

carrot = Carrot(
    amount=100,  # grams
    freshness=0.95,
    sweetness=0.8
)

celery = Celery(
    amount=100,  # grams
    freshness=0.95,
    crunchiness=0.9
)

cream = Cream(
    amount=200,  # ml
    fat_content=0.35,
    freshness=0.95
)
```

### Instructions

```python
# Create recipe
soup = Recipe("Classic Tomato Soup")
soup.add_ingredient(tomatoes)
soup.add_ingredient(onion)
soup.add_ingredient(carrot)
soup.add_ingredient(celery)
soup.add_ingredient(cream)

# Set cooking parameters
soup.set_cooking_method("simmer")
soup.set_duration("1h")
soup.set_temperature(95)  # Celsius

# Execute recipe
final_soup = kitchen.cook_recipe(soup)
```

### Quality Control

```python
# Analyze soup
profile = tester.analyze(final_soup)

# Check quality metrics
print(f"Consistency: {profile.consistency}")
print(f"Vegetable balance: {profile.vegetable_balance}")
print(f"Cream integration: {profile.cream_integration}")
```

## Classic Bruschetta

### Ingredients

```python
# Create ingredients
tomatoes = Tomato(
    ripeness=0.95,
    variety="Cherry",
    weight=500  # grams
)

garlic = Garlic(
    cloves=3,
    freshness=0.95,
    size="medium"
)

basil = Basil(
    leaves=15,
    freshness=0.95,
    variety="Genovese"
)

olive_oil = OliveOil(
    amount=30,  # ml
    quality="extra_virgin",
    acidity=0.3  # %
)

bread = Bread(
    slices=8,
    type="ciabatta",
    freshness=0.9
)
```

### Instructions

```python
# Create recipe
bruschetta = Recipe("Classic Bruschetta")
bruschetta.add_ingredient(tomatoes)
bruschetta.add_ingredient(garlic)
bruschetta.add_ingredient(basil)
bruschetta.add_ingredient(olive_oil)
bruschetta.add_ingredient(bread)

# Set cooking parameters
bruschetta.set_cooking_method("assemble")
bruschetta.set_preparation_time("15m")

# Execute recipe
final_bruschetta = kitchen.prepare_recipe(bruschetta)
```

### Quality Control

```python
# Analyze bruschetta
profile = tester.analyze(final_bruschetta)

# Check quality metrics
print(f"Freshness: {profile.freshness}")
print(f"Texture balance: {profile.texture_balance}")
print(f"Overall quality: {profile.overall_score}")
```

## Best Practices

### Ingredient Selection

```python
# Check ingredient quality
def validate_ingredients(ingredients):
    for ingredient in ingredients:
        if not ingredient.is_fresh():
            print(f"Warning: {ingredient.name} may not be fresh")
        if not ingredient.meets_quality_standards():
            print(f"Warning: {ingredient.name} may not meet quality standards")
```

### Temperature Control

```python
# Monitor cooking temperature
def monitor_cooking(recipe, kitchen):
    with kitchen.temperature_monitor() as monitor:
        result = kitchen.cook_recipe(recipe)
        if monitor.get_max() > recipe.max_temperature:
            print("Warning: Temperature exceeded maximum")
        return result
```

### Quality Assessment

```python
# Assess final product
def assess_quality(result, tester):
    profile = tester.analyze(result)
    if profile.overall_score < 0.8:
        print("Warning: Product may need improvement")
    return profile
```

## Recipe Optimization

### Flavor Enhancement

```python
# Enhance flavor profile
def enhance_flavor(recipe, target_profile):
    current_profile = tester.analyze(recipe)
    recommendations = tester.get_optimization_recommendations(
        current_profile,
        target_profile
    )
    return recommendations
```

### Texture Improvement

```python
# Improve texture
def improve_texture(recipe, target_texture):
    current_texture = tester.analyze_texture(recipe)
    adjustments = tester.get_texture_recommendations(
        current_texture,
        target_texture
    )
    return adjustments
```

## Next Steps

* [Experimental Creations](broken://pages/IAQbWUOIZPdnoeTdw64C) - Try innovative recipes
* [API Reference](broken://pages/RFuxFKYGnKE80PKgU1qW) - Explore the full API
* [Tutorials](broken://pages/TwWJtG7EyW33R4RKEIK5) - Learn basic techniques


---

# Agent Instructions: Querying This Documentation

If you need additional information that is not directly available in this page, you can query the documentation dynamically by asking a question.

Perform an HTTP GET request on the current page URL with the `ask` query parameter:

```
GET https://tomatopy.pizza/docs/recipe-library/classic-dishes.md?ask=<question>
```

The question should be specific, self-contained, and written in natural language.
The response will contain a direct answer to the question and relevant excerpts and sources from the documentation.

Use this mechanism when the answer is not explicitly present in the current page, you need clarification or additional context, or you want to retrieve related documentation sections.