This guide outlines best practices for writing efficient and performant code with TomatoPy.
# Good: Create ingredients with minimal memory usage
tomato = Tomato(
ripeness=0.8,
variety="San Marzano",
weight=150
)
# Bad: Creating unnecessary copies
tomato_copy = tomato.copy() # Unnecessary memory usage# Good: Process ingredients in batches
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)
# Bad: Processing one at a time
for ingredient in ingredients:
process_single(ingredient) # Less efficientfrom functools import lru_cache
# Good: Cache expensive computations
@lru_cache(maxsize=128)
def analyze_ingredient(ingredient):
return TasteTester().analyze(ingredient)
# Bad: Recomputing every time
def analyze_ingredient(ingredient):
return TasteTester().analyze(ingredient) # No caching# Good: Use appropriate data structures
from collections import defaultdict
class Recipe:
def __init__(self):
self.ingredients = defaultdict(float) # Efficient for ingredient tracking
# Bad: Using inefficient structures
class Recipe:
def __init__(self):
self.ingredients = [] # Less efficient for lookups# Good: Use context managers for resource cleanup
with kitchen.temperature_monitor() as monitor:
result = kitchen.cook(ingredient)
data = monitor.get_data()
# Bad: Manual resource management
monitor = kitchen.temperature_monitor()
try:
result = kitchen.cook(ingredient)
data = monitor.get_data()
finally:
monitor.cleanup() # More error-prone# Good: Use connection pooling
from tomatopy import ConnectionPool
pool = ConnectionPool(max_connections=10)
with pool.get_connection() as conn:
conn.execute_operation()
# Bad: Creating new connections each time
conn = create_connection() # Less efficient
conn.execute_operation()
conn.close()# Good: Use binary search for sorted data
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
# Bad: Linear search
def find_optimal_temperature(temps, target):
for i, temp in enumerate(temps):
if temp == target:
return i
return -1from concurrent.futures import ThreadPoolExecutor
# Good: Process multiple ingredients in parallel
def process_ingredients_parallel(ingredients):
with ThreadPoolExecutor(max_workers=4) as executor:
results = list(executor.map(process_ingredient, ingredients))
return results
# Bad: Sequential processing
def process_ingredients_sequential(ingredients):
results = []
for ingredient in ingredients:
results.append(process_ingredient(ingredient))
return results# Good: Modular code structure
class IngredientProcessor:
def process(self, ingredient):
self.validate(ingredient)
self.prepare(ingredient)
self.analyze(ingredient)
# Bad: Monolithic functions
def process_ingredient(ingredient):
# All processing in one function
validate_ingredient(ingredient)
prepare_ingredient(ingredient)
analyze_ingredient(ingredient)# Good: Clean interface design
class Kitchen:
def cook(self, ingredient, **kwargs):
self._validate_parameters(kwargs)
self._prepare_environment()
return self._execute_cooking(ingredient, kwargs)
# Bad: Complex interface
def cook(ingredient, temperature=None, duration=None, method=None,
stirring_frequency=None, humidity=None, pressure=None):
# Too many parameters
pass# Good: Graceful error recovery
def process_recipe(recipe):
try:
result = kitchen.cook_recipe(recipe)
return result
except TemperatureError:
# Handle temperature error
return adjust_temperature(recipe)
except IngredientError:
# Handle ingredient error
return substitute_ingredients(recipe)
finally:
cleanup_resources()
# Bad: No error recovery
def process_recipe(recipe):
result = kitchen.cook_recipe(recipe)
return result # No error handling# Good: Proper resource cleanup
class Kitchen:
def __init__(self):
self.resources = []
def __enter__(self):
return self
def __exit__(self, exc_type, exc_val, exc_tb):
self.cleanup()
# Bad: Manual cleanup
def use_kitchen():
kitchen = Kitchen()
try:
# Use kitchen
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
passMemory Management
Use efficient data structures
Implement batch processing
Avoid unnecessary copies
Performance Optimization
Cache expensive computations
Use appropriate algorithms
Implement parallel processing
Resource Management
Use context managers
Implement connection pooling
Clean up resources properly
Code Organization
Follow modular design
Create clean interfaces
Maintain separation of concerns
Error Handling
Implement graceful recovery
Clean up resources properly
Log errors appropriately
Virtual Kitchen Management - Learn kitchen optimization
API Reference - Explore the full API
Tutorials - Learn advanced techniques
This guide outlines best practices for managing virtual kitchens efficiently in TomatoPy.
Resource Management
Efficient equipment allocation
Space optimization
Resource tracking
Workflow Management
Task scheduling
Workflow optimization
Dependency management
Temperature Control
Zone management
Temperature monitoring
Alert systems
Safety Management
Safety protocols
Emergency procedures
Violation handling
Maintenance
Equipment maintenance
Cleaning protocols
Schedule management
- Explore the full API
- Learn advanced techniques
- Learn optimization techniques
from tomatopy import Kitchen, KitchenHardware
# Initialize kitchen with basic settings
kitchen = Kitchen(
temperature=22, # Celsius
humidity=0.65,
ventilation="standard",
lighting="bright"
)
# Configure hardware
hardware = KitchenHardware()
hardware.configure(
oven={"type": "convection", "capacity": "large"},
stove={"burners": 4, "type": "gas"},
refrigerator={"capacity": "medium", "temperature": 4}
)# Configure advanced settings
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"]
}
)# Good: Efficient equipment allocation
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
# Bad: No equipment management
def cook_recipe(recipe):
# No equipment allocation
pass# Good: Optimize kitchen space
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)
# Bad: No space optimization
def prepare_recipe(recipe):
# No space management
pass# Good: Efficient task scheduling
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)
# Bad: No task scheduling
def process_recipes(recipes):
for recipe in recipes:
# No scheduling
process_recipe(recipe)# Good: Optimize workflow
class WorkflowOptimizer:
def optimize_workflow(self, tasks):
# Sort tasks by priority and dependencies
sorted_tasks = self.topological_sort(tasks)
# Group compatible tasks
task_groups = self.group_tasks(sorted_tasks)
# Schedule groups efficiently
return self.schedule_groups(task_groups)
# Bad: No workflow optimization
def process_tasks(tasks):
for task in tasks:
# No optimization
process_task(task)# Good: Manage temperature zones
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)
# Bad: No zone management
def set_temperature(temp):
# No zone control
pass# Good: Monitor temperatures
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)
# Bad: No temperature monitoring
def check_temperature():
# No monitoring
pass# Good: Implement safety protocols
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
# Bad: No safety protocols
def perform_operation(operation):
# No safety checks
pass# Good: Handle emergencies
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)
# Bad: No emergency handling
def handle_problem(problem):
# No emergency procedures
pass# Good: Manage equipment maintenance
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)
# Bad: No maintenance scheduling
def fix_equipment(equipment):
# No maintenance management
pass# Good: Implement cleaning protocols
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)
# Bad: No cleaning management
def clean_area(area):
# No cleaning protocols
pass