Update app.py

app.py

@@ -1,83 +1,162 @@
 import os
 import gradio as gr
 from huggingface_hub import InferenceClient
+from fastapi import FastAPI, Request
+from fastapi.responses import StreamingResponse
+import json
+from typing import Generator
+import asyncio
 
 # Récupérer le token depuis les variables d'environnement (Secrets)
 HF_TOKEN = os.environ.get("HF_TOKEN")
 
-def respond(
-    message,
-    history: list[dict[str, str]],
-    system_message,
-    max_tokens,
-    temperature,
-    top_p,
-):
-    """
-    For more information on `huggingface_hub` Inference API support, please check the docs: https://huggingface.co/docs/huggingface_hub/v0.22.2/en/guides/inference
-    """
+# Définir un message système
+SYSTEM_MESSAGE = """
+Tu es TeachEase, un enseignant virtuel conçu pour aider les élèves à comprendre leurs cours, faire leurs exercices et devoirs.
+Ton rôle est d'expliquer les concepts de manière claire et pédagogique, de fournir des exemples concrets et de poser des questions pour vérifier la compréhension.
+**Instructions spéciales :**
+1. **Salutations :** Réponds de manière courte et amicale.
+2. **Expressions mathématiques et scientifiques :** Utilise le format LaTeX.
+3. **Traduction et réponses multilingues :** Adapte ta réponse en fonction de la langue demandée.
+"""
+
+# Créer l'application FastAPI
+app = FastAPI(title="TeachEase API")
+
+def detect_language_request(message: str) -> str:
+    """Détecte la langue demandée"""
+    language_requests = {
+        "anglais": "en", "english": "en", "espagnol": "es", "spanish": "es",
+        "allemand": "de", "german": "de", "portugais": "pt", "portuguese": "pt",
+        "français": "fr", "french": "fr", "italien": "it", "italian": "it",
+        "chinois": "zh", "chinese": "zh", "japonais": "ja", "japanese": "ja",
+        "russe": "ru",
+    }
+    for keyword, lang_code in language_requests.items():
+        if keyword in message.lower():
+            return lang_code
+    return None
+
+async def generate_stream_response(message: str, history: list = None, max_tokens: int = 256, temperature: float = 0.7, top_p: float = 0.95) -> Generator[str, None, None]:
+    """Génère une réponse en streaming"""
     if not HF_TOKEN:
-        yield "❌ Erreur : HF_TOKEN non configuré. Ajoutez-le dans les Secrets de votre Space."
+        yield json.dumps({"error": "HF_TOKEN non configuré"})
         return
     
     try:
         client = InferenceClient(token=HF_TOKEN, model="openai/gpt-oss-20b")
-
-        messages = [{"role": "system", "content": system_message}]
-        messages.extend(history)
+        
+        messages = [{"role": "system", "content": SYSTEM_MESSAGE}]
+        
+        # Ajouter l'historique si disponible
+        if history:
+            for exchange in history[-3:]:  # Limiter aux 3 derniers échanges
+                if exchange.get("user"):
+                    messages.append({"role": "user", "content": exchange["user"]})
+                if exchange.get("assistant"):
+                    messages.append({"role": "assistant", "content": exchange["assistant"]})
+        
         messages.append({"role": "user", "content": message})
 
-        response = ""
-
-        for message in client.chat_completion(
+        full_response = ""
+        
+        for chunk in client.chat_completion(
             messages,
             max_tokens=max_tokens,
             stream=True,
             temperature=temperature,
             top_p=top_p,
         ):
-            choices = message.choices
-            token = ""
-            if len(choices) and choices[0].delta.content:
-                token = choices[0].delta.content
+            if chunk.choices and chunk.choices[0].delta.content:
+                token = chunk.choices[0].delta.content
+                full_response += token
+                # Envoyer chaque token au fur et à mesure
+                yield f"data: {json.dumps({'token': token, 'full_response': full_response})}\n\n"
+                await asyncio.sleep(0.01)  # Petit délai pour le streaming
+                
+        # Signal de fin
+        yield f"data: {json.dumps({'done': True, 'full_response': full_response})}\n\n"
+        
+    except Exception as e:
+        yield f"data: {json.dumps({'error': str(e)})}\n\n"
 
-            response += token
-            yield response
-            
+@app.post("/api/chat/stream")
+async def chat_stream(request: Request):
+    """Endpoint API pour le streaming"""
+    try:
+        data = await request.json()
+        message = data.get("message", "")
+        history = data.get("history", [])
+        max_tokens = data.get("max_tokens", 256)
+        temperature = data.get("temperature", 0.7)
+        top_p = data.get("top_p", 0.95)
+        
+        return StreamingResponse(
+            generate_stream_response(message, history, max_tokens, temperature, top_p),
+            media_type="text/event-stream",
+            headers={
+                "Access-Control-Allow-Origin": "*",
+                "Access-Control-Allow-Methods": "POST, OPTIONS",
+                "Access-Control-Allow-Headers": "Content-Type",
+            }
+        )
     except Exception as e:
-        yield f"❌ Erreur : {str(e)}"
+        return {"error": str(e)}
 
+@app.options("/api/chat/stream")
+async def options_chat_stream():
+    """Gérer les requêtes OPTIONS pour CORS"""
+    return {
+        "Access-Control-Allow-Origin": "*",
+        "Access-Control-Allow-Methods": "POST, OPTIONS",
+        "Access-Control-Allow-Headers": "Content-Type",
+    }
 
-"""
-For information on how to customize the ChatInterface, peruse the gradio docs: https://www.gradio.app/docs/chatinterface
-"""
-chatbot = gr.ChatInterface(
+# Interface Gradio (optionnelle)
+def respond(message, history, system_message=SYSTEM_MESSAGE, max_tokens=256, temperature=0.7, top_p=0.95):
+    """Fonction pour l'interface Gradio"""
+    if not HF_TOKEN:
+        yield "❌ Erreur : HF_TOKEN non configuré"
+        return
+    
+    try:
+        client = InferenceClient(token=HF_TOKEN, model="openai/gpt-oss-20b")
+        messages = [{"role": "system", "content": system_message}]
+        
+        for val in history[-3:]:
+            if val[0]: messages.append({"role": "user", "content": val[0]})
+            if val[1]: messages.append({"role": "assistant", "content": val[1]})
+        
+        messages.append({"role": "user", "content": message})
+        response = ""
+
+        for message in client.chat_completion(
+            messages, max_tokens=max_tokens, stream=True, temperature=temperature, top_p=top_p
+        ):
+            if message.choices and message.choices[0].delta.content:
+                token = message.choices[0].delta.content
+                response += token
+                yield response
+                
+    except Exception as e:
+        yield f"❌ Erreur : {str(e)}"
+
+# Configuration de l'interface Gradio
+demo = gr.ChatInterface(
     respond,
-    type="messages",
     additional_inputs=[
-        gr.Textbox(value="You are a friendly Chatbot.", label="System message"),
-        gr.Slider(minimum=1, maximum=2048, value=512, step=1, label="Max new tokens"),
+        gr.Textbox(value=SYSTEM_MESSAGE, label="System message"),
+        gr.Slider(minimum=1, maximum=512, value=256, step=1, label="Max new tokens"),
         gr.Slider(minimum=0.1, maximum=4.0, value=0.7, step=0.1, label="Temperature"),
-        gr.Slider(
-            minimum=0.1,
-            maximum=1.0,
-            value=0.95,
-            step=0.05,
-            label="Top-p (nucleus sampling)",
-        ),
+        gr.Slider(minimum=0.1, maximum=1.0, value=0.95, step=0.05, label="Top-p"),
     ],
+    title="TeachEase - Enseignant Virtuel",
+    description="Bienvenue sur TeachEase ! API streaming disponible sur /api/chat/stream"
 )
 
-with gr.Blocks() as demo:
-    # Affichage d'information sur le token (debug)
-    gr.Markdown(f"Token configuré: {'✅ Oui' if HF_TOKEN else '❌ Non'}")
-    
-    # Vous pouvez retirer le LoginButton puisque nous utilisons le token direct
-    # with gr.Sidebar():
-    #     gr.LoginButton()
-    
-    chatbot.render()
-
+# Lancer avec Gradio App
+app = gr.mount_gradio_app(app, demo, path="/")
 
 if __name__ == "__main__":
-    demo.launch()
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)