Upload app.py

app.py

@@ -0,0 +1,409 @@
+import os
+import re
+import json
+import gradio as gr
+from typing import Dict, Any, List, Optional
+from huggingface_hub import InferenceClient
+
+# ────────────────────────────────────────────────────────────────────────────────
+# CONFIG
+MODEL_ID = os.environ.get("MODEL_ID", "meta-llama/Meta-Llama-3.1-8B-Instruct")
+HF_TOKEN = os.environ.get("HF_TOKEN")  # set in Space settings → Repository secrets
+
+# ────────────────────────────────────────────────────────────────────────────────
+CATEGORIES = [
+    {"key": "alimentation", "icon": "🍎", "fr": "Alimentation", "en": "Nutrition"},
+    {"key": "mouvement",    "icon": "🦘", "fr": "Mouvement",    "en": "Movement"},
+    {"key": "cerveau",      "icon": "🧠", "fr": "Cerveau",      "en": "Brain"},
+    {"key": "liens",        "icon": "🤝", "fr": "Liens",        "en": "Connections"},
+    {"key": "bien-etre",    "icon": "💬", "fr": "Bien-être",    "en": "Well-being"},
+]
+
+# Category-specific guidance (stronger prompt conditioning)
+GUIDES = {
+    "fr": {
+        "alimentation": "Focalise sur des habitudes simples: hydratation, fruits/légumes, rythme des repas, portions, collations intelligentes. Pas de régime strict, pas de moralisation.",
+        "mouvement": "Mise sur le NEAT (mouvements du quotidien): marche, escaliers, étirements courts, pauses actives, mini-rituels autour du café ou des appels.",
+        "cerveau": "Stimulation douce: curiosité, mémoire, respiration, mini-jeux, apprentissage de 2-3 minutes. Zéro jargon médical.",
+        "liens": "Interactions humaines simples: gratitude, messages courts, appel bref, se joindre à quelqu’un, sourire, entraide. Inclusif, bienveillant.",
+        "bien-etre": "Auto-soin micro: pauses, respiration, sommeil régulier, journal rapide, limiter les écrans un moment. Ton chaleureux, zéro culpabilisation."
+    },
+    "en": {
+        "alimentation": "Focus on simple habits: hydration, fruit/veg, meal rhythm, portions, smart snacks. No strict diets, no moralizing.",
+        "mouvement": "Lean into NEAT: daily walking, stairs, quick stretches, active breaks, tiny rituals around coffee or calls.",
+        "cerveau": "Gentle stimulation: curiosity, memory, breathing, tiny games, 2–3 min learning. No medical jargon.",
+        "liens": "Simple human interactions: gratitude, short messages, brief call, joining someone, smiling, helping. Inclusive, kind tone.",
+        "bien-etre": "Micro self-care: breaks, breathing, steady sleep, quick journaling, small screen limits. Warm tone, no guilt."
+    }
+}
+
+# Few-shot examples to anchor style (one per category per language)
+FEWSHOTS = {
+    "fr": {
+        "alimentation": {
+            "questions": [
+                "Quelle boisson te donne envie de boire plus d’eau dans la journée ?",
+                "Quel ajout simple rend ton petit-déj plus rassasiant ?",
+                "Quand as-tu naturellement faim d’un fruit ou d’un yaourt ?"
+            ],
+            "micro_actions": [
+                "Remplir une gourde ce matin.",
+                "Ajouter un fruit à la collation de l’après-midi."
+            ]
+        },
+        "mouvement": {
+            "questions": [
+                "Quel trajet pourrais-tu faire à pied au moins une fois cette semaine ?",
+                "Quelle pause-active de 2 minutes peux-tu glisser entre deux tâches ?",
+                "Qu’est-ce qui te fait bouger sans y penser (ex: marcher au téléphone) ?"
+            ],
+            "micro_actions": [
+                "Monter un étage par les escaliers aujourd’hui.",
+                "Faire 5 étirements doux après le café."
+            ]
+        },
+        "cerveau": {
+            "questions": [
+                "Qu’est-ce qui a suscité ta curiosité aujourd’hui ?",
+                "Quel moment t’irait pour 3 minutes de respiration ?",
+                "Quel mini-jeu aimes-tu pour réveiller l’esprit (ex: 3 mots fléchés) ?"
+            ],
+            "micro_actions": [
+                "Programmer un minuteur de 3 minutes pour respirer.",
+                "Lire un paragraphe d’un sujet nouveau ce soir."
+            ]
+        },
+        "liens": {
+            "questions": [
+                "Qui pourrais-tu remercier aujourd’hui et comment ?",
+                "À qui enverrais-tu un message court pour reprendre contact ?",
+                "Avec qui partagerais-tu une courte marche cette semaine ?"
+            ],
+            "micro_actions": [
+                "Envoyer un message de gratitude à une personne.",
+                "Proposer une pause-café de 10 minutes."
+            ]
+        },
+        "bien-etre": {
+            "questions": [
+                "Quel signal t’indique qu’il est temps de faire une pause ?",
+                "Quelle routine de 2 minutes t’aide à te recentrer ?",
+                "Quel moment favorise un coucher plus régulier ?"
+            ],
+            "micro_actions": [
+                "Éteindre les écrans 10 minutes plus tôt ce soir.",
+                "Écrire 3 lignes sur ton humeur du jour."
+            ]
+        }
+    },
+    "en": {
+        "alimentation": {
+            "questions": [
+                "What drink makes you want to sip more water through the day?",
+                "What small add-on makes your breakfast more filling?",
+                "When do you naturally crave a fruit or yogurt?"
+            ],
+            "micro_actions": [
+                "Fill a water bottle this morning.",
+                "Add one fruit to your afternoon snack."
+            ]
+        },
+        "mouvement": {
+            "questions": [
+                "Which short trip could you walk at least once this week?",
+                "Which 2-minute active break fits between two tasks?",
+                "What makes you move without noticing (e.g., walking on calls)?"
+            ],
+            "micro_actions": [
+                "Take one flight of stairs today.",
+                "Do 5 light stretches after coffee."
+            ]
+        },
+        "cerveau": {
+            "questions": [
+                "What sparked your curiosity today?",
+                "When could you do 3 minutes of breathing?",
+                "Which mini-game wakes you up (e.g., 3 crossword clues)?"
+            ],
+            "micro_actions": [
+                "Set a 3-minute timer to breathe.",
+                "Read one paragraph on a new topic tonight."
+            ]
+        },
+        "liens": {
+            "questions": [
+                "Who could you thank today—and how?",
+                "Who might you text briefly to reconnect?",
+                "Who could you invite for a short walk this week?"
+            ],
+            "micro_actions": [
+                "Send a gratitude message to one person.",
+                "Offer a 10-minute coffee break."
+            ]
+        },
+        "bien-etre": {
+            "questions": [
+                "What cue tells you it’s time for a pause?",
+                "What 2-minute routine helps you reset?",
+                "What time supports a steadier bedtime?"
+            ],
+            "micro_actions": [
+                "Turn screens off 10 minutes earlier tonight.",
+                "Write three lines about your mood today."
+            ]
+        }
+    }
+}
+
+def build_prompt(lang: str, category_key: str, variant: str) -> str:
+    cat = next((c for c in CATEGORIES if c["key"] == category_key), None)
+    if not cat:
+        category_key = "alimentation"
+        cat = next((c for c in CATEGORIES if c["key"] == category_key), None)
+
+    # Variant tone
+    variant_fr = (
+        "Contrainte de ton: *ludique et original* (‘meilleur’)."
+        if variant == "best" else
+        "Contrainte de ton: *introspectif et authentique* (‘plus sincère’)."
+    )
+    variant_en = (
+        "Tone constraint: *playful and original* (‘best’)."
+        if variant == "best" else
+        "Tone constraint: *introspective and authentic* (‘most sincere’)."
+    )
+
+    # Shared schema
+    schema = (
+        "{\n"
+        '  "category": "<category_key>",\n'
+        '  "language": "<fr|en>",\n'
+        '  "questions": ["q1", "q2", "q3"],\n'
+        '  "micro_actions": ["m1", "m2"],\n'
+        '  "tone": "playful|sincere|ludique|sincère",\n'
+        '  "safety_notes": "short coaching tips"\n'
+        "}"
+    )
+
+    # Safety & style guardrails
+    safety_fr = (
+        "Règles de sécurité et de style:\n"
+        "- Zéro conseil médical, pas de diagnostic, pas d’injonction.\n"
+        "- Langage bienveillant, inclusif, non culpabilisant.\n"
+        "- Items concrets, réalisables en 1–3 minutes quand c’est pertinent.\n"
+        "- Phrases courtes. Pas de listes imbriquées. Pas d’emojis dans la sortie.\n"
+        "- Réponds STRICTEMENT en JSON valide, sans texte autour."
+    )
+    safety_en = (
+        "Safety & style rules:\n"
+        "- No medical advice, no diagnosis, no injunctions.\n"
+        "- Kind, inclusive, non-judgmental language.\n"
+        "- Concrete items, doable in 1–3 minutes when relevant.\n"
+        "- Short sentences. No nested lists. No emojis in output.\n"
+        "- Respond in STRICT, valid JSON only, with nothing else."
+    )
+
+    guide = GUIDES[lang][category_key]
+    few = FEWSHOTS[lang][category_key]
+
+    if lang == "fr":
+        system = (
+            "Tu es l’IA du jeu de cartes Neurovie, inspiré du modèle FINGER. "
+            "Une carte = une question sur les routines (alimentation, mouvement, cerveau, liens, bien-être)."
+        )
+        rules = (
+            "Mode d’emploi (style 7 familles):\n"
+            "- Demande une carte (catégorie FINGER) avec une question précise.\n"
+            "- Si l’autre joueur l’a, il la donne et continue. Sinon, tu pioches.\n"
+            "Variante: chacun pioche à son tour; le meilleur ou le plus sincère garde la carte."
+        )
+        user = (
+            f"Catégorie: {cat['fr']} {cat['icon']}. {variant_fr}\n"
+            f"Guide de ciblage: {guide}\n"
+            "Produit attendu: 3 QUESTIONS et 2 MICRO-ACTIONS, chacune en 1 phrase, concrète.\n"
+            "Adapte le ton selon la contrainte. Respecte scrupuleusement le schéma JSON.\n"
+            "Exemple de style (à imiter, ne pas répéter tel quel):\n"
+            f"- Questions: {few['questions']}\n"
+            f"- Micro-actions: {few['micro_actions']}\n"
+            "Schéma JSON strict:\n"
+            f"{schema}\n"
+            "RENVOIE UNIQUEMENT DU JSON VALIDE."
+        )
+        content = f"{system}\n\n{rules}\n\n{safety_fr}\n\n{user}"
+    else:
+        system = (
+            "You are the AI for the Neurovie card game, inspired by the FINGER model. "
+            "One card = one question about daily routines (nutrition, movement, brain, connections, well-being)."
+        )
+        rules = (
+            "How to play (7-families style):\n"
+            "- Ask for a specific card (FINGER category) using a clear question.\n"
+            "- If they have it, they give it and keep asking; otherwise, draw.\n"
+            "Variant: players draw in turn; the best or most sincere keeps the card."
+        )
+        user = (
+            f"Category: {cat['en']} {cat['icon']}. {variant_en}\n"
+            f"Targeting guide: {guide}\n"
+            "Expected output: 3 QUESTIONS and 2 MICRO-ACTIONS, each one sentence, concrete.\n"
+            "Match the requested tone. Follow the JSON schema exactly.\n"
+            "Style example (imitate tone; do not copy verbatim):\n"
+            f"- Questions: {few['questions']}\n"
+            f"- Micro-actions: {few['micro_actions']}\n"
+            "Strict JSON schema:\n"
+            f"{schema}\n"
+            "RETURN JSON ONLY."
+        )
+        content = f"{system}\n\n{rules}\n\n{safety_en}\n\n{user}"
+
+    return content
+
+# ────────────────────────────────────────────────────────────────────────────────
+# Inference helpers
+
+def try_parse_json(text: str) -> Optional[Dict[str, Any]]:
+    if not text:
+        return None
+    # Grab last JSON object
+    match = re.search(r"\{[\s\S]*\}\s*$", text.strip())
+    if not match:
+        return None
+    try:
+        return json.loads(match.group(0))
+    except Exception:
+        return None
+
+def normalize_output(data: Dict[str, Any], lang: str, category_key: str, variant: str) -> Dict[str, Any]:
+    """Ensure exactly 3 questions, 2 micro_actions, set tone, fill missing fields."""
+    q = data.get("questions", [])
+    m = data.get("micro_actions", [])
+    # basic sanitization
+    q = [str(s).strip().rstrip() for s in q if str(s).strip()]
+    m = [str(s).strip().rstrip() for s in m if str(s).strip()]
+    # clip/extend
+    q = (q + [""] * 3)[:3]
+    m = (m + [""] * 2)[:2]
+
+    tone = data.get("tone", "")
+    if not tone:
+        tone = ("ludique" if (lang == "fr" and variant == "best")
+                else "sincère" if lang == "fr"
+                else "playful" if variant == "best"
+                else "sincere")
+
+    safety = data.get("safety_notes", "")
+    if not safety:
+        safety = "Reste bienveillant·e, évite les conseils médicaux." if lang == "fr" else "Be kind, avoid medical advice."
+
+    out = {
+        "category": category_key,
+        "language": lang,
+        "questions": q,
+        "micro_actions": m,
+        "tone": tone,
+        "safety_notes": safety,
+    }
+    return out
+
+def model_call(prompt: str) -> str:
+    client = InferenceClient(model=MODEL_ID, token=HF_TOKEN)
+
+    # Prefer chat endpoint when available
+    try:
+        resp = client.chat.completions.create(
+            model=MODEL_ID,
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.85,
+            top_p=0.92,
+            max_tokens=220,
+        )
+        content = resp.choices[0].message["content"] if hasattr(resp.choices[0], "message") else resp.choices[0].message.content
+        if isinstance(content, list):
+            content = "".join(part.get("text", "") if isinstance(part, dict) else str(part) for part in content)
+        return content.strip()
+    except Exception:
+        pass
+
+    # Fallback to text_generation
+    resp = client.text_generation(
+        prompt,
+        max_new_tokens=220,
+        temperature=0.85,
+        top_p=0.92,
+        return_full_text=False,
+    )
+    return resp.strip()
+
+def generate(lang: str, category_key: str, variant: str) -> Dict[str, str]:
+    prompt = build_prompt(lang, category_key, variant)
+
+    raw_text = None
+    try:
+        raw_text = model_call(prompt)
+    except Exception:
+        raw_text = None
+
+    parsed = try_parse_json(raw_text) if raw_text else None
+
+    # Local fallback if needed (pull from fewshots to keep style tight)
+    if not parsed:
+        few = FEWSHOTS[lang][category_key]
+        parsed = {
+            "category": category_key,
+            "language": lang,
+            "questions": few["questions"][:3],
+            "micro_actions": few["micro_actions"][:2],
+            "tone": ("ludique" if (lang == "fr" and variant == "best")
+                     else "sincère" if lang == "fr"
+                     else "playful" if variant == "best"
+                     else "sincere"),
+            "safety_notes": "Reste bienveillant·e, évite les conseils médicaux." if lang == "fr" else "Be kind, avoid medical advice.",
+        }
+        raw_text = "(local few-shot fallback used)"
+
+    normalized = normalize_output(parsed, lang, category_key, variant)
+
+    pretty = [
+        f"Category: {normalized['category']} | Lang: {normalized['language']} | Tone: {normalized['tone']}",
+        "",
+        "Questions:",
+        *[f"• {q}" for q in normalized["questions"]],
+        "",
+        "Micro-actions:",
+        *[f"• {m}" for m in normalized["micro_actions"]],
+    ]
+    if normalized.get("safety_notes"):
+        pretty += ["", f"Notes: {normalized['safety_notes']}"]
+
+    return {
+        "pretty_text": "\n".join(pretty),
+        "raw_json": json.dumps(normalized, ensure_ascii=False, indent=2)
+    }
+
+# ────────────────────────────────────────────────────────────────────────────────
+# GRADIO UI
+with gr.Blocks(title="Neurovie – FINGER Question Generator") as demo:
+    gr.Markdown("# Neurovie – FINGER Question Generator")
+    gr.Markdown("Aggressively guided prompts with category-aware examples. Strict JSON, then friendly display.")
+
+    with gr.Row():
+        lang = gr.Radio(choices=["fr", "en"], value="fr", label="Lang / Language")
+        category = gr.Radio(
+            choices=[c["key"] for c in CATEGORIES],
+            value="alimentation",
+            label="Catégorie / Category"
+        )
+        variant = gr.Radio(choices=["best", "sincere"], value="best", label="Variante")
+
+    btn = gr.Button("Generate")
+
+    pretty = gr.Textbox(label="Output", lines=14)
+    raw_json = gr.Code(label="Parsed JSON", language="json")
+
+    def on_click(l, c, v):
+        out = generate(l, c, v)
+        return out["pretty_text"], out["raw_json"]
+
+    btn.click(on_click, inputs=[lang, category, variant], outputs=[pretty, raw_json])
+
+if __name__ == "__main__":
+    demo.launch()