Update app.py

app.py

@@ -4,6 +4,9 @@ import torch
 import numpy as np
 import random
 import json
+from fastapi import FastAPI, Request
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
 
 # Lade RecipeBERT Modell (für semantische Zutat-Kombination)
 bert_model_name = "alexdseo/RecipeBERT"
@@ -89,15 +92,6 @@ def get_combined_scores(query_vector, embedding_list, all_good_embeddings, avg_w
 def find_best_ingredients(required_ingredients, available_ingredients, max_ingredients=6, avg_weight=0.6):
     """
     Findet die besten Zutaten basierend auf RecipeBERT Embeddings.
-
-    Args:
-        required_ingredients (list): Benötigte Zutaten, die verwendet werden müssen
-        available_ingredients (list): Verfügbare Zutaten zur Auswahl
-        max_ingredients (int): Maximale Anzahl von Zutaten für das Rezept
-        avg_weight (float): Gewicht für den Durchschnittsvektor
-
-    Returns:
-        list: Die optimale Kombination von Zutaten
     """
     # Stelle sicher, dass keine Duplikate in den Listen sind
     required_ingredients = list(set(required_ingredients))
@@ -282,32 +276,16 @@ def generate_recipe_with_t5(ingredients_list, max_retries=5):
         "directions": ["Fehler beim Generieren der Rezeptanweisungen"]
     }
 
-def flutter_api_generate_recipe(ingredients_data):
+# Diese Funktion wird von der Gradio-UI und der neuen FastAPI-Route aufgerufen.
+def process_recipe_request_logic(required_ingredients, available_ingredients, max_ingredients, max_retries):
     """
-    Flutter-freundliche API-Funktion, die JSON-Eingaben verarbeitet
-    und strukturierte JSON-Ausgaben zurückgibt, die deiner ursprünglichen Flask-API entsprechen.
+    Kernlogik zur Verarbeitung einer Rezeptgenerierungsanfrage.
+    Ausgelagert, um von verschiedenen Endpunkten aufgerufen zu werden.
     """
-    try:
-        # Eingabe parsen - behandle sowohl String- als auch Dict-Formate
-        if isinstance(ingredients_data, str):
-            data = json.loads(ingredients_data)
-        else:
-            data = ingredients_data # Ist bereits ein Dict (z.B. von Gradio UI)
-
-        # Parameter extrahieren (wie deine ursprüngliche Flask-API)
-        required_ingredients = data.get('required_ingredients', [])
-        available_ingredients = data.get('available_ingredients', [])
-
-        # Abwärtskompatibilität: Wenn nur 'ingredients' angegeben ist, behandle es als required_ingredients
-        if data.get('ingredients') and not required_ingredients:
-            required_ingredients = data.get('ingredients', [])
-
-        max_ingredients = data.get('max_ingredients', 7)
-        max_retries = data.get('max_retries', 5)
-
-        if not required_ingredients and not available_ingredients:
-            return json.dumps({"error": "Keine Zutaten angegeben"})
+    if not required_ingredients and not available_ingredients:
+        return {"error": "Keine Zutaten angegeben"}
 
+    try:
         # Optimale Zutaten finden
         optimized_ingredients = find_best_ingredients(
             required_ingredients,
@@ -318,15 +296,36 @@ def flutter_api_generate_recipe(ingredients_data):
         # Rezept mit optimierten Zutaten generieren
         recipe = generate_recipe_with_t5(optimized_ingredients, max_retries)
 
-        # Für die Flutter-App formatieren - strukturiertes Format
+        # Ergebnis formatieren
         result = {
             'title': recipe['title'],
             'ingredients': recipe['ingredients'],
             'directions': recipe['directions'],
             'used_ingredients': optimized_ingredients
         }
+        return result
 
-        return json.dumps(result)
+    except Exception as e:
+        return {"error": f"Fehler bei der Rezeptgenerierung: {str(e)}"}
+
+def flutter_api_generate_recipe(ingredients_data):
+    """
+    Flutter-freundliche API-Funktion für den Gradio-API-Test-Tab.
+    Verarbeitet JSON-String-Eingabe und gibt JSON-String-Ausgabe zurück.
+    """
+    try:
+        data = json.loads(ingredients_data) # Muss ein JSON-String sein
+
+        required_ingredients = data.get('required_ingredients', [])
+        available_ingredients = data.get('available_ingredients', [])
+        max_ingredients = data.get('max_ingredients', 7)
+        max_retries = data.get('max_retries', 5)
+
+        # Rufe die Kernlogik auf
+        result_dict = process_recipe_request_logic(
+            required_ingredients, available_ingredients, max_ingredients, max_retries
+        )
+        return json.dumps(result_dict) # Gibt einen JSON-String zurück
 
     except Exception as e:
         return json.dumps({"error": f"Fehler bei der Rezeptgenerierung: {str(e)}"})
@@ -334,34 +333,17 @@ def flutter_api_generate_recipe(ingredients_data):
 def gradio_ui_generate_recipe(required_ingredients_text, available_ingredients_text, max_ingredients_val, max_retries_val):
     """Gradio UI Funktion für die Web-Oberfläche"""
     try:
-        # Text-Eingaben parsen
         required_ingredients = [ing.strip() for ing in required_ingredients_text.split(',') if ing.strip()]
         available_ingredients = [ing.strip() for ing in available_ingredients_text.split(',') if ing.strip()]
 
-        # Erstelle ein Dictionary im Format der Flutter API
-        data_for_flutter_api = {
-            'required_ingredients': required_ingredients,
-            'available_ingredients': available_ingredients,
-            'max_ingredients': max_ingredients_val, # Verwende den Parameter aus dem Slider
-            'max_retries': max_retries_val # Verwende den Parameter aus dem Slider
-        }
-
-        # --- WICHTIG: Wandle das Python-Dictionary in einen JSON-String um,
-        # da flutter_api_generate_recipe intern dieses Format erwartet,
-        # wenn es über einen Gradio-Input aufgerufen wird, der einen String liefert.
-        # Dies simuliert den JSON-String, den die Flutter-App senden würde.
-        data_json_string = json.dumps(data_for_flutter_api)
-        # ---------------------------------------------------------------------
-
-        # Verwende dieselbe Funktion wie die Flutter API
-        result_json = flutter_api_generate_recipe(data_json_string) # <-- Hier die Änderung
-
-        result = json.loads(result_json)
+        # Rufe die Kernlogik auf
+        result = process_recipe_request_logic(
+            required_ingredients, available_ingredients, max_ingredients_val, max_retries_val
+        )
 
         if 'error' in result:
             return result['error'], "", "", ""
 
-        # Für die Gradio-Anzeige formatieren
         ingredients_list = '\n'.join([f"• {ing}" for ing in result['ingredients']])
         directions_list = '\n'.join([f"{i+1}. {dir}" for i, dir in enumerate(result['directions'])])
         used_ingredients = ', '.join(result['used_ingredients'])
@@ -374,7 +356,6 @@ def gradio_ui_generate_recipe(required_ingredients_text, available_ingredients_t
         )
 
     except Exception as e:
-        # Fehlermeldung für die Gradio UI
         return f"Fehler: {str(e)}", "", "", ""
 
 # Erstelle die Gradio Oberfläche
@@ -395,7 +376,6 @@ with gr.Blocks(title="AI Rezept Generator") as demo:
                     placeholder="Knoblauch, Tomate, Pfeffer, Kräuter",
                     lines=2
                 )
-                # Die Parameter-Namen für Slider müssen mit den Argumenten der Gradio UI Funktion übereinstimmen
                 max_ing = gr.Slider(3, 10, value=7, step=1, label="Maximale Zutaten")
                 max_retries = gr.Slider(1, 10, value=5, step=1, label="Max. Wiederholungsversuche")
 
@@ -409,13 +389,13 @@ with gr.Blocks(title="AI Rezept Generator") as demo:
 
                 generate_btn.click(
                     fn=gradio_ui_generate_recipe,
-                    inputs=[required_ing, available_ing, max_ing, max_retries], # Hier die Slider-Komponenten übergeben
+                    inputs=[required_ing, available_ing, max_ing, max_retries],
                     outputs=[title_output, ingredients_output, directions_output, used_ingredients_output]
                 )
 
     with gr.Tab("API-Test"):
-        gr.Markdown("### Teste die Flutter API")
-        gr.Markdown("Dieser Tab verwendet dieselbe Funktion, die Flutter-Apps über die API aufrufen werden.")
+        gr.Markdown("### Teste die Gradio API (für interne Tests)")
+        gr.Markdown("Dieser Tab verwendet die interne Gradio API für Testzwecke.")
 
         api_input = gr.Textbox(
             label="JSON-Eingabe (Flutter API-Format)",
@@ -425,11 +405,12 @@ with gr.Blocks(title="AI Rezept Generator") as demo:
         api_output = gr.Textbox(label="JSON-Ausgabe", lines=15, interactive=False)
         api_test_btn = gr.Button("API testen", variant="secondary")
 
+        # Hier wird die Funktion weiterhin für den Gradio-eigenen API-Test-Tab verwendet.
         api_test_btn.click(
             fn=flutter_api_generate_recipe,
             inputs=[api_input],
             outputs=[api_output],
-            api_name="generate_recipe_for_flutter" # <-- Dies ist der von Flutter verwendete API-Name
+            api_name="generate_recipe_for_flutter" # Gradio-interner API-Name
         )
 
         gr.Examples(
@@ -440,5 +421,46 @@ with gr.Blocks(title="AI Rezept Generator") as demo:
             inputs=[api_input]
         )
 
-if __name__ == "__main__":
-    demo.launch()
+# --- FastAPI-Integration ---
+app = FastAPI()
+
+class RecipeRequest(BaseModel):
+    required_ingredients: list[str] = []
+    available_ingredients: list[str] = []
+    max_ingredients: int = 7
+    max_retries: int = 5
+
+@app.post("/api/generate_recipe_rest")
+async def generate_recipe_rest_api(request_data: RecipeRequest):
+    """
+    Standard-REST-API-Endpunkt für die Flutter-App.
+    Nimmt direkt JSON-Daten an und gibt direkt JSON zurück.
+    """
+    required_ingredients = request_data.required_ingredients
+    available_ingredients = request_data.available_ingredients
+    max_ingredients = request_data.max_ingredients
+    max_retries = request_data.max_retries
+
+    # Abwärtskompatibilität, falls 'ingredients' statt 'required_ingredients' gesendet wird
+    # Dies ist in der FastAPI-Pydantic-Modelldefinition nicht direkt abbildbar,
+    # aber du könntest es manuell hinzufügen, falls nötig, wenn das Pydantic-Modell flexibler wäre.
+    # Für den Einfachheit halber gehen wir davon aus, dass Flutter die korrekten Felder sendet.
+
+    result_dict = process_recipe_request_logic(
+        required_ingredients, available_ingredients, max_ingredients, max_retries
+    )
+
+    return JSONResponse(content=result_dict)
+
+# Gradio-App als Sub-App in die FastAPI-App mounten
+# Dies ist der Standardweg, um Gradio in eine FastAPI-Anwendung einzubetten.
+# Der Gradio-Teil wird dann unter dem Wurzelpfad '/'.
+app = gr.mount_gradio_app(app, demo, path="/") # Gradio unter dem Wurzelpfad mounten
+
+# Wenn du deine App lokal ausführst, kannst du FastAPI mit Uvicorn starten:
+# if __name__ == "__main__":
+#    import uvicorn
+#    uvicorn.run(app, host="0.0.0.0", port=8000)
+
+# Für Hugging Face Spaces ist der if __name__ == "__main__": Block nicht nötig,
+# da Spaces Uvicorn automatisch startet und die "app"-Variable sucht.