Update app.py

app.py

@@ -1,39 +1,148 @@
+import os
+import textwrap
+import traceback
+import requests
+import gradio as gr
+
+# 1. Récupérer ton token Hugging Face (secret HF_TOKEN dans Settings)
+HF_TOKEN = os.environ.get("HF_TOKEN")
+
+if not HF_TOKEN:
+    raise RuntimeError(
+        "La variable d'environnement HF_TOKEN n'est pas définie. "
+        "Va dans Settings → Variables and secrets → Secrets et ajoute HF_TOKEN "
+        "avec ton token Hugging Face."
+    )
+
+# 2. Modèle de chat open-source hébergé par Hugging Face
+MODEL_ID = "HuggingFaceH4/zephyr-7b-beta"
+API_URL = f"https://api-inference.huggingface.co/models/{MODEL_ID}"
+
+HEADERS = {"Authorization": f"Bearer {HF_TOKEN}"}
+
+SYSTEM_PROMPT = """
+Tu es ArtGPT, un assistant spécialisé à 100% dans l'art :
+illustration, dessin, peinture, graphisme, composition, lumière,
+histoire de l'art, mouvements artistiques, direction artistique,
+portfolio, conseils logiciels et création visuelle.
+
+Règles :
+- Réponds uniquement en français.
+- Si la question n’est pas liée à l’art ou à la création visuelle,
+  tu rediriges gentiment vers ces thèmes.
+- Donne des réponses claires, structurées, pédagogiques.
+- Propose volontiers des exercices pratiques.
+"""
+
+def build_prompt(question: str) -> str:
+    """Construire un prompt texte pour le modèle."""
+    return textwrap.dedent(
+        f"""
+        {SYSTEM_PROMPT.strip()}
+
+        Utilisateur : {question.strip()}
+        Assistant :
+        """
+    ).strip()
+
+def query_hf(prompt: str) -> str:
+    """Appel brut à l'API de Hugging Face."""
+    payload = {
+        "inputs": prompt,
+        "parameters": {
+            "max_new_tokens": 400,
+            "temperature": 0.7,
+            "top_p": 0.95,
+            "repetition_penalty": 1.05,
+            "do_sample": True,
+        }
+    }
+
+    response = requests.post(API_URL, headers=HEADERS, json=payload, timeout=90)
+
+    # Si le HTTP code n'est pas 200, on lève pour afficher ensuite l'erreur proprement
+    try:
+        response.raise_for_status()
+    except Exception:
+        return (
+            "### Erreur HTTP Hugging Face\n\n"
+            "```text\n"
+            f"Status code: {response.status_code}\n"
+            f"Body: {response.text}\n"
+            "```"
+        )
+
+    data = response.json()
+
+    # Format typique de l'API Inference: liste d'objets avec generated_text
+    if isinstance(data, list) and data and isinstance(data[0], dict):
+        generated = data[0].get("generated_text", "")
+    # Certains modèles renvoient un dict avec 'error'
+    elif isinstance(data, dict) and "error" in data:
+        return (
+            "### Erreur du modèle Hugging Face\n\n"
+            "```text\n"
+            f"{data['error']}\n"
+            "```"
+        )
+    else:
+        # Format inattendu: on affiche tout pour debug
+        return (
+            "### Réponse inattendue de l'API Hugging Face\n\n"
+            "```text\n"
+            f"{data}\n"
+            "```"
+        )
+
+    return generated
+
 def answer(question: str) -> str:
     question = (question or "").strip()
     if not question:
         return "Pose-moi une question sur l'art 🙂"
 
+    prompt = build_prompt(question)
+
     try:
-        # Appel à l'API de chat Hugging Face (task "conversational")
-        response = client.chat_completion(
-            messages=[
-                {"role": "system", "content": SYSTEM_PROMPT.strip()},
-                {"role": "user", "content": question},
-            ],
-            max_tokens=400,
-            temperature=0.7,
-            top_p=0.95,
-        )
+        generated = query_hf(prompt)
 
-        # Format OpenAI-like : choices[0].message
-        message = response.choices[0].message
-        # Selon les versions, message peut être un dict ou un objet
-        content = getattr(message, "content", None)
-        if content is None and isinstance(message, dict):
-            content = message.get("content", "")
+        # Si l'API a déjà renvoyé un bloc d'erreur formaté markdown, on le retourne tel quel
+        if generated.startswith("### Erreur") or generated.startswith("### Réponse inattendue"):
+            return generated
 
-        content = (content or "").strip()
-        if not content:
+        # Nettoyage: certains modèles renvoient prompt + completion
+        if generated.startswith(prompt):
+            generated = generated[len(prompt):]
+
+        generated = generated.strip()
+        if not generated:
             return "Je n'ai pas réussi à générer une réponse cette fois-ci."
 
-        return content
+        return generated
 
     except Exception:
-        import traceback
         tb = traceback.format_exc()
         return (
-            "### Erreur lors de l'appel au modèle Hugging Face\n\n"
+            "### Erreur Python côté Space\n\n"
             "```text\n"
             f"{tb}\n"
             "```"
-        )
+        )
+
+demo = gr.Interface(
+    fn=answer,
+    inputs=gr.Textbox(
+        label="Pose ta question sur l'art",
+        placeholder="Ex : Donne-moi un exercice pour progresser en composition d’affiche.",
+    ),
+    outputs=gr.Markdown(label="Réponse d’ArtGPT"),
+    title="🎨 ArtGPT — Assistant IA pour artistes",
+    description=(
+        "Pose une question sur l'illustration, le dessin, la couleur, la composition, "
+        "l'histoire de l'art, le graphisme ou la direction artistique. "
+        "ArtGPT te répond de manière claire et pédagogique."
+    ),
+)
+
+if __name__ == "__main__":
+    demo.launch()