Prototyp

app/services/openai_service.py

@@ -0,0 +1,183 @@
+"""OpenAI integration: Whisper transcription + GPT-4o-mini recipe extraction."""
+from __future__ import annotations
+import json
+import logging
+from pathlib import Path
+
+from openai import AsyncOpenAI, AuthenticationError, RateLimitError, APIConnectionError
+
+from app.config import get_settings
+from app.models import Ingredient, NutritionInfo, Recipe
+
+log = logging.getLogger(__name__)
+
+_RECIPE_SYSTEM_PROMPT = """Du bist ein Rezept-Extraktor. Extrahiere das Rezept aus dem Text und antworte NUR mit einem JSON-Objekt (kein Markdown).
+
+JSON-Schema:
+{
+  "title": "string",
+  "description": "string oder null",
+  "servings": integer oder null,
+  "prep_time_minutes": integer oder null,
+  "cook_time_minutes": integer oder null,
+  "ingredients": [
+    {"name": "string", "amount": "string oder null", "unit": "string oder null", "note": "string oder null"}
+  ],
+  "steps": ["string"],
+  "kcal_per_serving": number oder null,
+  "tags": ["string"]
+}
+
+Regeln:
+- amount ist immer ein String (z.B. "200", "1/2", "2-3")
+- unit ist die Maßeinheit (g, ml, EL, TL, Stück, etc.)
+- Wenn keine Kalorien erkennbar sind, setze kcal_per_serving auf null
+- steps sind vollständige Zubereitungsschritte
+- tags: maximal 5 relevante Schlagwörter
+"""
+
+_CAPTION_CHECK_PROMPT = """Enthält der folgende Text ein vollständiges Rezept mit Zutaten UND Zubereitungsschritten?
+Antworte NUR mit einem JSON-Objekt: {"has_recipe": true} oder {"has_recipe": false}
+
+Text:
+"""
+
+
+def _get_client() -> AsyncOpenAI:
+    return AsyncOpenAI(api_key=get_settings().openai_api_key)
+
+
+def _openai_error(e: Exception) -> RuntimeError:
+    if isinstance(e, AuthenticationError):
+        return RuntimeError("OpenAI API-Schlüssel ungültig oder abgelaufen.")
+    if isinstance(e, RateLimitError):
+        return RuntimeError("OpenAI Rate-Limit erreicht. Bitte kurz warten und erneut versuchen.")
+    if isinstance(e, APIConnectionError):
+        return RuntimeError("OpenAI nicht erreichbar. Internetverbindung prüfen.")
+    return RuntimeError(f"OpenAI-Fehler: {e}")
+
+
+async def check_caption_has_recipe(text: str) -> bool:
+    """Check if a video description/caption contains a complete recipe."""
+    client = _get_client()
+    try:
+        resp = await client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "user", "content": _CAPTION_CHECK_PROMPT + text[:3000]}
+            ],
+            max_tokens=20,
+            response_format={"type": "json_object"},
+        )
+        data = json.loads(resp.choices[0].message.content or "{}")
+        return bool(data.get("has_recipe", False))
+    except (AuthenticationError, RateLimitError, APIConnectionError) as e:
+        raise _openai_error(e) from e
+    except Exception as e:
+        log.warning("Caption check failed: %s", e)
+        return False
+
+
+async def transcribe_audio(audio_path: Path) -> str:
+    """Transcribe audio file with Whisper API."""
+    client = _get_client()
+    try:
+        with open(audio_path, "rb") as f:
+            transcript = await client.audio.transcriptions.create(
+                model="whisper-1",
+                file=f,
+                language="de",
+                response_format="text",
+            )
+        return str(transcript)
+    except (AuthenticationError, RateLimitError, APIConnectionError) as e:
+        raise _openai_error(e) from e
+
+
+async def extract_recipe_from_text(text: str, source_url: str) -> Recipe:
+    """Use GPT-4o-mini to extract a structured recipe from text."""
+    client = _get_client()
+    try:
+        resp = await client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "system", "content": _RECIPE_SYSTEM_PROMPT},
+                {"role": "user", "content": text[:12000]},
+            ],
+            response_format={"type": "json_object"},
+            temperature=0.1,
+        )
+    except (AuthenticationError, RateLimitError, APIConnectionError) as e:
+        raise _openai_error(e) from e
+    raw = resp.choices[0].message.content or "{}"
+    data = json.loads(raw)
+    return _gpt_json_to_recipe(data, source_url)
+
+
+async def estimate_nutrition_gpt(ingredients: list[Ingredient], servings: int) -> NutritionInfo:
+    """Estimate kcal using GPT-4o-mini as last resort."""
+    client = _get_client()
+    ing_text = "\n".join(
+        f"- {i.amount or ''} {i.unit or ''} {i.name} {('(' + i.note + ')') if i.note else ''}".strip()
+        for i in ingredients
+    )
+    prompt = (
+        f"Schätze die Gesamtkalorienzahl und Kalorien pro Portion für folgende Zutaten "
+        f"({servings} Portionen):\n{ing_text}\n\n"
+        'Antworte NUR mit JSON: {"kcal_total": number, "kcal_per_serving": number}'
+    )
+    try:
+        resp = await client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[{"role": "user", "content": prompt}],
+            response_format={"type": "json_object"},
+            temperature=0,
+        )
+        data = json.loads(resp.choices[0].message.content or "{}")
+        return NutritionInfo(
+            kcal_per_serving=data.get("kcal_per_serving"),
+            kcal_total=data.get("kcal_total"),
+            servings=servings,
+            source="gpt4_estimate",
+        )
+    except (AuthenticationError, RateLimitError, APIConnectionError) as e:
+        log.warning("GPT nutrition estimate failed (API): %s", _openai_error(e))
+        return NutritionInfo(source="gpt4_estimate")
+    except Exception as e:
+        log.warning("GPT nutrition estimate failed: %s", e)
+        return NutritionInfo(source="gpt4_estimate")
+
+
+def _gpt_json_to_recipe(data: dict, source_url: str) -> Recipe:
+    ingredients = [
+        Ingredient(
+            name=i.get("name", ""),
+            amount=i.get("amount"),
+            unit=i.get("unit"),
+            note=i.get("note"),
+        )
+        for i in data.get("ingredients", [])
+        if i.get("name")
+    ]
+
+    nutrition = None
+    kcal = data.get("kcal_per_serving")
+    if kcal:
+        try:
+            nutrition = NutritionInfo(kcal_per_serving=float(kcal), source="extracted")
+        except (ValueError, TypeError):
+            pass
+
+    return Recipe(
+        title=data.get("title", "Unbekanntes Rezept"),
+        description=data.get("description"),
+        image_url=None,
+        source_url=source_url,
+        servings=data.get("servings"),
+        prep_time_minutes=data.get("prep_time_minutes"),
+        cook_time_minutes=data.get("cook_time_minutes"),
+        ingredients=ingredients,
+        steps=data.get("steps", []),
+        nutrition=nutrition,
+        tags=data.get("tags", [])[:10],
+    )