banyaro/backend/scraper/breed_enricher.py

"""
BAN YARO — Rassen-Anreicherung via KI

Nutzt ki.complete() um fehlende Rassen-Daten (Beschreibung, Vorkommen, etc.)
per Claude API anzureichern und in wiki_rassen zurückzuschreiben.
"""

import asyncio
import json
import logging
import re
import sys
import os

# Pfad zum Backend-Verzeichnis sicherstellen (beim direkten Aufruf)
sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.abspath(__file__))))

from database import db
from ki import complete, KIUnavailableError

logger = logging.getLogger(__name__)

_SYSTEM = "Du bist ein Hunde-Experte."

_PROMPT_TEMPLATE = '''\
Gib mir strukturierte Informationen über die Hunderasse "{name}" (Herkunft: {herkunft}) auf Deutsch.
Antworte NUR mit einem JSON-Objekt, keine Erklärung darum.

Format:
{{
  "beschreibung": "3-5 Sätze über Charakter und Wesen der Rasse",
  "vorkommen_de": "1-2 Sätze wie verbreitet die Rasse in Deutschland/DACH ist",
  "groesse": "klein|mittel|gross|sehr_gross",
  "gewicht_min_kg": Zahl_oder_null,
  "gewicht_max_kg": Zahl_oder_null,
  "lebensdauer": "X-Y Jahre oder null",
  "aktivitaet": "niedrig|mittel|hoch|sehr_hoch",
  "erfahrung": "anfaenger|fortgeschritten|experte",
  "kinder_geeignet": true_oder_false,
  "wohnung_geeignet": true_oder_false,
  "temperament": "kommagetrennte Eigenschaftsliste auf Deutsch, z.B. freundlich, verspielt, loyal"
}}
'''

# Felder die direkt in wiki_rassen geschrieben werden (wenn nicht null)
_DIRECT_FIELDS = {
    "beschreibung", "vorkommen_de",
    "groesse", "gewicht_min_kg", "gewicht_max_kg",
    "lebensdauer", "aktivitaet", "erfahrung",
    "kinder_geeignet", "wohnung_geeignet", "temperament",
}


def _parse_json(raw: str) -> dict:
    """JSON aus KI-Antwort extrahieren — toleriert ```json ... ``` Wrapper."""
    # Versuche direkt
    try:
        return json.loads(raw)
    except json.JSONDecodeError:
        pass

    # Suche nach ```json ... ``` Block
    match = re.search(r"```(?:json)?\s*([\s\S]+?)\s*```", raw)
    if match:
        try:
            return json.loads(match.group(1))
        except json.JSONDecodeError:
            pass

    # Suche nach erstem { ... } Block
    match = re.search(r"\{[\s\S]+\}", raw)
    if match:
        try:
            return json.loads(match.group(0))
        except json.JSONDecodeError:
            pass

    raise ValueError(f"Kein gültiges JSON in Antwort gefunden: {raw[:200]}")


async def enrich_breeds(limit: int = 10) -> int:
    """
    Reichert bis zu `limit` Rassen an, bei denen ki_enriched = 0.

    Returns:
        Anzahl erfolgreich angereicherter Rassen.
    """
    with db() as conn:
        rassen = conn.execute(
            """SELECT id, name, slug, herkunft FROM wiki_rassen
               WHERE ki_enriched = 0
               ORDER BY name ASC
               LIMIT ?""",
            (limit,),
        ).fetchall()

    if not rassen:
        logger.info("Keine Rassen zur Anreicherung gefunden (alle ki_enriched=1).")
        return 0

    enriched_count = 0

    for rasse in rassen:
        name     = rasse["name"]
        herkunft = rasse["herkunft"] or "unbekannt"
        rasse_id = rasse["id"]

        prompt = _PROMPT_TEMPLATE.format(name=name, herkunft=herkunft)

        try:
            raw = await complete(
                prompt,
                system=_SYSTEM,
                max_tokens=600,
                requires_premium=False,
            )
        except KIUnavailableError as e:
            logger.warning("KI nicht verfügbar, Anreicherung abgebrochen: %s", e)
            break
        except Exception as e:
            logger.error("Fehler bei KI-Anfrage für %s: %s", name, e)
            await asyncio.sleep(2)
            continue

        try:
            data = _parse_json(raw)
        except ValueError as e:
            logger.warning("JSON-Parsing fehlgeschlagen für %s: %s", name, e)
            await asyncio.sleep(2)
            continue

        # Nur bekannte Felder mit nicht-None-Wert übernehmen
        updates = {
            k: v for k, v in data.items()
            if k in _DIRECT_FIELDS and v is not None
        }
        updates["ki_enriched"] = 1

        cols   = ", ".join(f"{k}=?" for k in updates)
        values = list(updates.values()) + [rasse_id]

        try:
            with db() as conn:
                conn.execute(
                    f"UPDATE wiki_rassen SET {cols} WHERE id=?",
                    values,
                )
            logger.info("Rasse angereichert: %s (%d Felder)", name, len(updates) - 1)
            enriched_count += 1
        except Exception as e:
            logger.error("DB-Update fehlgeschlagen für %s: %s", name, e)

        await asyncio.sleep(2)

    return enriched_count


if __name__ == "__main__":
    import argparse

    logging.basicConfig(level=logging.INFO, format="%(levelname)s %(message)s")

    parser = argparse.ArgumentParser(description="Rassen-Anreicherung via KI")
    parser.add_argument("--limit", type=int, default=10, help="Anzahl Rassen (default: 10)")
    args = parser.parse_args()

    count = asyncio.run(enrich_breeds(args.limit))
    print(f"Angereichert: {count} Rassen")