Update app.py

app.py

@@ -5,18 +5,18 @@ from fastapi.staticfiles import StaticFiles
 from huggingface_hub import InferenceClient
 import secrets
 from typing import Optional
-from bson.objectid import ObjectId  # Pour les _id MongoDB
-from datetime import datetime, timedelta  # Ajout de timedelta pour expires_at
+from bson.objectid import ObjectId  
+from datetime import datetime, timedelta  
 from fastapi import Request
 import requests
 import numpy as np
 import argparse
 import os
 from pymongo import MongoClient
-from datetime import datetime  # Ajout pour createdAt
-from passlib.hash import bcrypt  # Ajout pour le hash du mot de passe
+from datetime import datetime  
+from passlib.hash import bcrypt  
 
-SECRET_KEY = secrets.token_hex(32)  # Génère une clé aléatoire
+SECRET_KEY = secrets.token_hex(32)  
 
 HOST = os.environ.get("API_URL", "0.0.0.0")
 PORT = os.environ.get("PORT", 7860)
@@ -39,9 +39,9 @@ db = mongo_client[db_name]
 app = FastAPI()
 app.add_middleware(
     CORSMiddleware,
-    # Spécifiez les origines exactes au lieu de "*"
+
     allow_origins=[
-        "https://axl95-medically.hf.space",  # URL de votre espace HF
+        "https://axl95-medically.hf.space",  
         "https://huggingface.co", 
         "http://localhost:3000",
         "http://localhost:7860",
@@ -54,7 +54,6 @@ app.add_middleware(
 
 
 
-# Fonction pour créer une session
 @app.post("/api/login")
 async def login(request: Request, response: Response):
     try:
@@ -62,12 +61,10 @@ async def login(request: Request, response: Response):
         email = data.get("email")
         password = data.get("password")
         
-        # Vérifier les identifiants
         user = db.users.find_one({"email": email})
         if not user or not bcrypt.verify(password, user["password"]):
             raise HTTPException(status_code=401, detail="Email ou mot de passe incorrect")
         
-        # Créer une session
         session_id = secrets.token_hex(16)
         user_id = str(user["_id"])
         username = f"{user['prenom']} {user['nom']}"
@@ -84,22 +81,21 @@ async def login(request: Request, response: Response):
         response.set_cookie(
             key="session_id", 
             value=session_id, 
-            httponly=False,  # Permettre à JavaScript d'accéder au cookie
-            max_age=7*24*60*60,  # 7 jours
-            samesite="none",  # Obligatoire pour le cross-site
-            secure=True,      # Obligatoire avec samesite=none
-            path="/"          # Accessible sur tout le domaine
+            httponly=False,  
+            max_age=7*24*60*60,  
+            samesite="none", 
+            secure=True,      
+            path="/"         
         )
         
         # Log pour débogage
         print(f"Session créée: {session_id} pour l'utilisateur {user_id}")
         
-        # Renvoyer le session_id dans la réponse pour permettre le stockage manuel si nécessaire
         return {
             "success": True, 
             "username": username, 
             "user_id": user_id,
-            "session_id": session_id  # Permet de stocker la session côté client
+            "session_id": session_id  
         }
     
     except Exception as e:
@@ -108,18 +104,15 @@ async def login(request: Request, response: Response):
 
 
 async def get_current_user(request: Request):
-    # 1. Essayer d'obtenir la session du cookie
     session_id = request.cookies.get("session_id")
     print(f"Cookie de session reçu: {session_id[:5] if session_id else 'None'}")
     
-    # 2. Si pas de cookie, vérifier l'en-tête d'autorisation
     if not session_id:
         auth_header = request.headers.get("Authorization")
         if auth_header and auth_header.startswith("Bearer "):
             session_id = auth_header.replace("Bearer ", "")
             print(f"Session d'autorisation reçue: {session_id[:5]}...")
     
-    # 3. Si toujours pas de session, vérifier les paramètres de requête
     if not session_id:
         session_id = request.query_params.get("session_id")
         if session_id:
@@ -128,7 +121,6 @@ async def get_current_user(request: Request):
     if not session_id:
         raise HTTPException(status_code=401, detail="Non authentifié - Aucune session trouvée")
     
-    # Vérifier si la session existe et n'est pas expirée
     session = db.sessions.find_one({
         "session_id": session_id,
         "expires_at": {"$gt": datetime.utcnow()}
@@ -157,21 +149,17 @@ async def register(request: Request):
     try:
         data = await request.json()
         
-        # Validation
         required_fields = ["prenom", "nom", "email", "password"]
         for field in required_fields:
             if not data.get(field):
                 raise HTTPException(status_code=400, detail=f"Le champ {field} est requis")
         
-        # Vérifier si l'email existe déjà
         existing_user = db.users.find_one({"email": data["email"]})
         if existing_user:
             raise HTTPException(status_code=409, detail="Cet email est déjà utilisé")
         
-        # Hash du mot de passe (installer passlib avec pip install passlib[bcrypt])
         hashed_password = bcrypt.hash(data["password"])
         
-        # Insérer l'utilisateur
         user = {
             "prenom": data["prenom"],
             "nom": data["nom"],
@@ -185,26 +173,20 @@ async def register(request: Request):
         return {"message": "Utilisateur créé avec succès", "userId": str(result.inserted_id)}
     
     except HTTPException as he:
-        # Re-lever les HTTPException pour FastAPI les traite
         raise he
     
     except Exception as e:
-        # Logging détaillé pour débogage
         import traceback
         print(f"Erreur lors de l'inscription: {str(e)}")
         print(traceback.format_exc())
         raise HTTPException(status_code=500, detail=f"Erreur serveur: {str(e)}")
-# Par cette solution utilisant l'API d'inférence directement:
 @app.post("/api/embed")
 async def embed(request: Request):
     data = await request.json()
     texts = data.get("texts", [])
     
     try:
-        # Si vous utilisez un embedder personnalisé
-        # embeddings = embedder.encode(texts).tolist()
         
-        # Pour déboguer, renvoyez simplement un embedding fictif
         dummy_embedding = [[0.1, 0.2, 0.3] for _ in range(len(texts))]
         
         return {"embeddings": dummy_embedding}
@@ -222,9 +204,6 @@ HF_TOKEN = os.getenv('REACT_APP_HF_TOKEN')
 if not HF_TOKEN:
     raise RuntimeError("Le token Hugging Face (HF_TOKEN) n'est pas défini dans les variables d'environnement.")
 
-# Initialisation du client HF
-
-# Par cette version correcte
 hf_client = InferenceClient(token=HF_TOKEN)
 
 @app.post("/api/chat")
@@ -235,13 +214,12 @@ async def chat(request: Request):
         raise HTTPException(status_code=400, detail="Le champ 'message' est requis.")
 
     try:
-        # Utiliser le provider novita comme demandé
         response = hf_client.text_generation(
             model="mistralai/Mistral-7B-Instruct-v0.3",
             prompt=f"<s>[INST] Tu es un assistant médical spécialisé en schizophrénie. Réponds à cette question: {user_message} [/INST]",
             max_new_tokens=512,
             temperature=0.7,
-            provider="novita"  # Spécifier le provider novita ici
+            provider="novita" 
         )
         
         return {"response": response}
@@ -258,18 +236,15 @@ async def get_data():
     data = {"data": np.random.rand(100).tolist()}
     return JSONResponse(data)
 
-# Endpoint pour récupérer toutes les conversations d'un utilisateur
 @app.get("/api/conversations")
 async def get_conversations(current_user: dict = Depends(get_current_user)):
     try:
         user_id = str(current_user["_id"])
-        # Récupération des conversations triées par date (les plus récentes d'abord)
         conversations = list(db.conversations.find(
             {"user_id": user_id},
             {"_id": 1, "title": 1, "date": 1, "time": 1, "last_message": 1, "created_at": 1}
         ).sort("created_at", -1))
         
-        # Convertir les ObjectId en strings pour la sérialisation JSON
         for conv in conversations:
             conv["_id"] = str(conv["_id"])
         
@@ -277,14 +252,12 @@ async def get_conversations(current_user: dict = Depends(get_current_user)):
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Erreur serveur: {str(e)}")
 
-# Endpoint pour sauvegarder une nouvelle conversation
 @app.post("/api/conversations")
 async def create_conversation(request: Request, current_user: dict = Depends(get_current_user)):
     try:
         data = await request.json()
         user_id = str(current_user["_id"])
         
-        # Créer la nouvelle conversation
         conversation = {
             "user_id": user_id,
             "title": data.get("title", "Nouvelle conversation"),
@@ -296,22 +269,18 @@ async def create_conversation(request: Request, current_user: dict = Depends(get
         
         result = db.conversations.insert_one(conversation)
         
-        # Retourner l'ID de la conversation créée
         return {"conversation_id": str(result.inserted_id)}
     except Exception as e:
         raise HTTPException(status_code=500, detail=f"Erreur serveur: {str(e)}")
 
-# Endpoint pour sauvegarder un message dans une conversation
 @app.post("/api/conversations/{conversation_id}/messages")
 async def add_message(conversation_id: str, request: Request, current_user: dict = Depends(get_current_user)):
     try:
         data = await request.json()
         user_id = str(current_user["_id"])
         
-        # Debug pour vérifier les données
         print(f"Ajout message: conversation_id={conversation_id}, sender={data.get('sender')}, text={data.get('text')[:20]}...")
         
-        # Vérifier que la conversation appartient à l'utilisateur
         conversation = db.conversations.find_one({
             "_id": ObjectId(conversation_id),
             "user_id": user_id
@@ -320,7 +289,6 @@ async def add_message(conversation_id: str, request: Request, current_user: dict
         if not conversation:
             raise HTTPException(status_code=404, detail="Conversation non trouvée")
         
-        # Ajouter le message
         message = {
             "conversation_id": conversation_id,
             "user_id": user_id,
@@ -331,7 +299,6 @@ async def add_message(conversation_id: str, request: Request, current_user: dict
         
         db.messages.insert_one(message)
         
-        # Mettre à jour la dernière activité de la conversation
         db.conversations.update_one(
             {"_id": ObjectId(conversation_id)},
             {"$set": {"last_message": data.get("text", ""), "updated_at": datetime.utcnow()}}
@@ -342,13 +309,11 @@ async def add_message(conversation_id: str, request: Request, current_user: dict
         print(f"Erreur lors de l'ajout d'un message: {str(e)}")
         raise HTTPException(status_code=500, detail=f"Erreur serveur: {str(e)}")
 
-# Endpoint pour récupérer les messages d'une conversation
 @app.get("/api/conversations/{conversation_id}/messages")
 async def get_messages(conversation_id: str, current_user: dict = Depends(get_current_user)):
     try:
         user_id = str(current_user["_id"])
         
-        # Vérifier que la conversation appartient à l'utilisateur
         conversation = db.conversations.find_one({
             "_id": ObjectId(conversation_id),
             "user_id": user_id
@@ -357,12 +322,10 @@ async def get_messages(conversation_id: str, current_user: dict = Depends(get_cu
         if not conversation:
             raise HTTPException(status_code=404, detail="Conversation non trouvée")
         
-        # Récupérer les messages
         messages = list(db.messages.find(
             {"conversation_id": conversation_id}
-        ).sort("timestamp", 1))  # Du plus ancien au plus récent
+        ).sort("timestamp", 1)) 
         
-        # Convertir les ObjectId en strings pour la sérialisation JSON
         for msg in messages:
             msg["_id"] = str(msg["_id"])
             if "timestamp" in msg:
@@ -377,7 +340,6 @@ async def delete_conversation(conversation_id: str, current_user: dict = Depends
     try:
         user_id = str(current_user["_id"])
         
-        # Vérifier que la conversation appartient à l'utilisateur
         result = db.conversations.delete_one({
             "_id": ObjectId(conversation_id),
             "user_id": user_id
@@ -386,7 +348,6 @@ async def delete_conversation(conversation_id: str, current_user: dict = Depends
         if result.deleted_count == 0:
             raise HTTPException(status_code=404, detail="Conversation non trouvée")
         
-        # Supprimer également tous les messages associés
         db.messages.delete_many({"conversation_id": conversation_id})
         
         return {"success": True}