Update app.py

app.py

@@ -6,6 +6,7 @@ import json
 from fastapi import FastAPI
 from fastapi.responses import JSONResponse
 from pydantic import BaseModel
+from datetime import datetime, timedelta # Importieren für Datumsberechnungen
 
 # Lade RecipeBERT Modell (für semantische Zutat-Kombination)
 bert_model_name = "alexdseo/RecipeBERT"
@@ -40,7 +41,6 @@ def get_embedding(text):
 
 def average_embedding(embedding_list):
     """Berechnet den Durchschnitt einer Liste von Embeddings"""
-    # Sicherstellen, dass embedding_list Tupel von (Name, Embedding) enthält
     tensors = torch.stack([emb for _, emb in embedding_list])
     return tensors.mean(dim=0)
 
@@ -59,60 +59,121 @@ def get_cosine_similarity(vec1, vec2):
         return 0
     return dot_product / (norm_a * norm_b)
 
-def get_combined_scores(query_vector, embedding_list, all_good_embeddings, avg_weight=0.6):
-    """Berechnet einen kombinierten Score unter Berücksichtigung der Ähnlichkeit zum Durchschnitt und zu einzelnen Zutaten"""
+# NEUE FUNKTION: Berechnet den Altersbonus für eine Zutat
+def calculate_age_bonus(date_added_str: str, category: str) -> float:
+    """
+    Berechnet einen prozentualen Bonus basierend auf dem Alter der Zutat.
+    - Standard: 0.5% pro Tag, max. 10%.
+    - Gemüse: 2.0% pro Tag, max. 10%.
+    """
+    try:
+        date_added = datetime.fromisoformat(date_added_str.replace('Z', '+00:00')) # Handle 'Z' for UTC
+    except ValueError:
+        print(f"Warning: Could not parse date_added_str: {date_added_str}. Returning 0 bonus.")
+        return 0.0
+
+    today = datetime.now()
+    days_since_added = (today - date_added).days
+
+    if days_since_added < 0: # Zutat aus der Zukunft? Ungültig.
+        return 0.0
+
+    if category and category.lower() == "vegetables":
+        daily_bonus = 0.02 # 2% pro Tag für Gemüse
+    else:
+        daily_bonus = 0.005 # 0.5% pro Tag für andere
+
+    bonus = days_since_added * daily_bonus
+    return min(bonus, 0.10) # Max 10% (0.10)
+
+def get_combined_scores(query_vector, embedding_list_with_details, all_good_embeddings, avg_weight=0.6):
+    """
+    Berechnet einen kombinierten Score unter Berücksichtigung der Ähnlichkeit zum Durchschnitt und zu einzelnen Zutaten.
+    Jetzt inklusive Altersbonus.
+    embedding_list_with_details: Liste von Tupeln (Name, Embedding, DateAddedStr, Category)
+    """
     results = []
-    for name, emb in embedding_list:
+    for name, emb, date_added_str, category in embedding_list_with_details:
         avg_similarity = get_cosine_similarity(query_vector, emb)
         individual_similarities = [get_cosine_similarity(good_emb, emb)
                                    for _, good_emb in all_good_embeddings]
         avg_individual_similarity = sum(individual_similarities) / len(individual_similarities) if individual_similarities else 0
-        combined_score = avg_weight * avg_similarity + (1 - avg_weight) * avg_individual_similarity
-        results.append((name, emb, combined_score))
+        
+        base_combined_score = avg_weight * avg_similarity + (1 - avg_weight) * avg_individual_similarity
+        
+        # NEU: Altersbonus hinzufügen
+        age_bonus = calculate_age_bonus(date_added_str, category)
+        final_combined_score = base_combined_score + age_bonus
+
+        results.append((name, emb, final_combined_score, date_added_str, category)) # Behalte Details für Debug oder zukünftige Nutzung
     results.sort(key=lambda x: x[2], reverse=True)
     return results
 
-# Die vollständige find_best_ingredients Funktion, die du bereitgestellt hast
-def find_best_ingredients(required_ingredients, available_ingredients, max_ingredients=6, avg_weight=0.6):
+def find_best_ingredients(required_ingredients_names, available_ingredients_details, max_ingredients=6, avg_weight=0.6):
     """
-    Findet die besten Zutaten basierend auf RecipeBERT Embeddings.
+    Findet die besten Zutaten basierend auf RecipeBERT Embeddings, jetzt mit Alters- und Kategorie-Bonus.
+    required_ingredients_names: Liste von Strings (nur Namen)
+    available_ingredients_details: Liste von Dicts (Name, DateAdded, Category)
     """
-    required_ingredients = list(set(required_ingredients))
-    available_ingredients = list(set([i for i in available_ingredients if i not in required_ingredients]))
-    
-    if not required_ingredients and available_ingredients:
-        random_ingredient = random.choice(available_ingredients)
-        required_ingredients = [random_ingredient]
-        available_ingredients = [i for i in available_ingredients if i != random_ingredient]
-        print(f"No required ingredients provided. Randomly selected: {random_ingredient}")
-    
-    if not required_ingredients or len(required_ingredients) >= max_ingredients:
-        return required_ingredients[:max_ingredients]
-    
-    if not available_ingredients:
-        return required_ingredients
-    
-    embed_required = [(e, get_embedding(e)) for e in required_ingredients]
-    embed_available = [(e, get_embedding(e)) for e in available_ingredients]
-    
-    num_to_add = min(max_ingredients - len(required_ingredients), len(available_ingredients))
-    
-    final_ingredients = embed_required.copy()
-    
+    required_ingredients_names = list(set(required_ingredients_names))
+
+    # Filtern der verfügbaren Zutaten, um sicherzustellen, dass keine Pflichtzutaten dabei sind
+    # und gleichzeitig die Details beibehalten
+    available_ingredients_filtered_details = [
+        item for item in available_ingredients_details
+        if item['name'] not in required_ingredients_names
+    ]
+
+    # Wenn keine Pflichtzutaten vorhanden sind, aber verfügbare, wähle eine zufällig als Pflichtzutat
+    if not required_ingredients_names and available_ingredients_filtered_details:
+        random_item = random.choice(available_ingredients_filtered_details)
+        required_ingredients_names = [random_item['name']]
+        # Entferne die zufällig gewählte Zutat aus den verfügbaren Details
+        available_ingredients_filtered_details = [
+            item for item in available_ingredients_filtered_details
+            if item['name'] != random_item['name']
+        ]
+        print(f"No required ingredients provided. Randomly selected: {required_ingredients_names[0]}")
+
+    if not required_ingredients_names or len(required_ingredients_names) >= max_ingredients:
+        return required_ingredients_names[:max_ingredients]
+
+    if not available_ingredients_filtered_details:
+        return required_ingredients_names
+
+    # Erstelle Embeddings für Pflichtzutaten (nur Name und Embedding)
+    embed_required = [(name, get_embedding(name)) for name in required_ingredients_names]
+
+    # Erstelle Embeddings für verfügbare Zutaten, inklusive ihrer Details
+    embed_available_with_details = [
+        (item['name'], get_embedding(item['name']), item['dateAdded'], item['category'])
+        for item in available_ingredients_filtered_details
+    ]
+
+    num_to_add = min(max_ingredients - len(required_ingredients_names), len(embed_available_with_details))
+
+    final_ingredients_with_embeddings = embed_required.copy() # (Name, Embedding)
+    final_ingredients_names = required_ingredients_names.copy() # Nur Namen zum Tracken der ausgewählten
+
     for _ in range(num_to_add):
-        avg = average_embedding(final_ingredients)
-        candidates = get_combined_scores(avg, embed_available, final_ingredients, avg_weight)
+        avg = average_embedding(final_ingredients_with_embeddings)
+        # Sende die Liste mit den detaillierten Zutaten an get_combined_scores
+        candidates = get_combined_scores(avg, embed_available_with_details, final_ingredients_with_embeddings, avg_weight)
         
         if not candidates:
             break
             
-        best_name, best_embedding, _ = candidates[0]
-        
-        final_ingredients.append((best_name, best_embedding))
+        best_name, best_embedding, best_score, _, _ = candidates[0] # Holen Sie den besten Kandidaten
+
+        # Füge nur den Namen und das Embedding zum final_ingredients_with_embeddings hinzu
+        final_ingredients_with_embeddings.append((best_name, best_embedding))
+        final_ingredients_names.append(best_name)
         
-        embed_available = [item for item in embed_available if item[0] != best_name]
-    
-    return [name for name, _ in final_ingredients]
+        # Entferne den besten Kandidaten aus den verfügbaren
+        embed_available_with_details = [item for item in embed_available_with_details if item[0] != best_name]
+            
+    return final_ingredients_names
+
 
 def skip_special_tokens(text, special_tokens):
     """Entfernt spezielle Tokens aus dem Text"""
@@ -219,17 +280,18 @@ def generate_recipe_with_t5(ingredients_list, max_retries=5):
         "directions": ["Fehler beim Generieren der Rezeptanweisungen"]
     }
 
-def process_recipe_request_logic(required_ingredients, available_ingredients, max_ingredients, max_retries):
+def process_recipe_request_logic(required_ingredients, available_ingredients_details, max_ingredients, max_retries):
     """
     Kernlogik zur Verarbeitung einer Rezeptgenerierungsanfrage.
+    available_ingredients_details: Liste von Dicts (Name, DateAdded, Category)
     """
-    if not required_ingredients and not available_ingredients:
+    if not required_ingredients and not available_ingredients_details:
         return {"error": "Keine Zutaten angegeben"}
     try:
+        # Die find_best_ingredients Funktion erwartet jetzt die detaillierte Liste
         optimized_ingredients = find_best_ingredients(
-            required_ingredients, available_ingredients, max_ingredients
+            required_ingredients, available_ingredients_details, max_ingredients
         )
-        # KORRIGIERT: Aufruf der echten T5-Generierungsfunktion
         recipe = generate_recipe_with_t5(optimized_ingredients, max_retries)
         result = {
             'title': recipe['title'],
@@ -239,34 +301,42 @@ def process_recipe_request_logic(required_ingredients, available_ingredients, ma
         }
         return result
     except Exception as e:
+        import traceback
+        traceback.print_exc() # Dies hilft bei der Fehlersuche im Log
         return {"error": f"Fehler bei der Rezeptgenerierung: {str(e)}"}
 
 # --- FastAPI-Implementierung ---
-app = FastAPI(title="AI Recipe Generator API") # Ohne Gradio-spezifische Titelzusätze
+app = FastAPI(title="AI Recipe Generator API")
+
+# NEU: Model für die empfangene Zutat mit Details
+class IngredientDetail(BaseModel):
+    name: str
+    dateAdded: str # Muss ein String sein, da wir ihn als ISO 8601 empfangen
+    category: str
 
 class RecipeRequest(BaseModel):
     required_ingredients: list[str] = []
-    available_ingredients: list[str] = []
+    # NEU: available_ingredients ist jetzt eine Liste von IngredientDetail-Objekten
+    available_ingredients: list[IngredientDetail] = []
     max_ingredients: int = 7
     max_retries: int = 5
-    # Optional: Für Abwärtskompatibilität, falls 'ingredients' als Top-Level-Feld gesendet wird
+    # Optional: Für Abwärtskompatibilität (kann entfernt werden, wenn nicht mehr benötigt)
     ingredients: list[str] = []
 
-@app.post("/generate_recipe") # Der API-Endpunkt für Flutter
+@app.post("/generate_recipe")
 async def generate_recipe_api(request_data: RecipeRequest):
     """
     Standard-REST-API-Endpunkt für die Flutter-App.
     Nimmt direkt JSON-Daten an und gibt direkt JSON zurück.
     """
-    # Wenn required_ingredients leer ist, aber ingredients vorhanden sind,
-    # verwende ingredients für Abwärtskompatibilität.
     final_required_ingredients = request_data.required_ingredients
     if not final_required_ingredients and request_data.ingredients:
         final_required_ingredients = request_data.ingredients
 
+    # Jetzt die detaillierten available_ingredients an die Logik übergeben
     result_dict = process_recipe_request_logic(
         final_required_ingredients,
-        request_data.available_ingredients,
+        request_data.available_ingredients, # Hier ist die Liste der IngredientDetail-Objekte
         request_data.max_ingredients,
         request_data.max_retries
     )
@@ -274,9 +344,6 @@ async def generate_recipe_api(request_data: RecipeRequest):
 
 @app.get("/")
 async def read_root():
-    return {"message": "AI Recipe Generator API is running (FastAPI only)!"} # Angepasste Nachricht
-
-# Hier gibt es KEINEN Gradio-Mount oder Gradio-Launch-Befehl
-# Das `app` Objekt ist eine reine FastAPI-Instanz
-print("INFO: Pure FastAPI application script finished execution and defined 'app' variable.")
+    return {"message": "AI Recipe Generator API is running (FastAPI only)!"}
 
+print("INFO: Pure FastAPI application script finished execution and defined 'app' variable.")