Update app.py

app.py

@@ -1,15 +1,22 @@
-from fastapi import FastAPI
+from fastapi import FastAPI, Request, HTTPException,Depends, Response
 from fastapi.middleware.cors import CORSMiddleware
 from fastapi.responses import JSONResponse
 from fastapi.staticfiles import StaticFiles
 from huggingface_hub import InferenceClient
-from sentence_transformers import SentenceTransformer
-
+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 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
+
+SECRET_KEY = secrets.token_hex(32)  # Génère une clé aléatoire
 
 HOST = os.environ.get("API_URL", "0.0.0.0")
 PORT = os.environ.get("PORT", 7860)
@@ -21,6 +28,14 @@ parser.add_argument("--ssl_certfile")
 parser.add_argument("--ssl_keyfile")
 args = parser.parse_args()
 
+# Configuration MongoDB
+mongo_uri = os.environ.get("MONGODB_URI", "mongodb+srv://giffardaxel95:[email protected]/")
+db_name = os.environ.get("DB_NAME", "chatmed_schizo")
+mongo_client = MongoClient(mongo_uri)
+db = mongo_client[db_name]
+
+
+
 app = FastAPI()
 app.add_middleware(
     CORSMiddleware,
@@ -31,15 +46,137 @@ app.add_middleware(
 )
 
 
-app = FastAPI()
-embedder = SentenceTransformer('sentence-transformers/distiluse-base-multilingual-cased-v1')
 
+# Fonction pour créer une session
+@app.post("/api/login")
+async def login(request: Request, response: Response):
+    try:
+        data = await request.json()
+        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']}"
+        
+        # Stocker la session en base de données
+        db.sessions.insert_one({
+            "session_id": session_id,
+            "user_id": user_id,
+            "created_at": datetime.utcnow(),
+            "expires_at": datetime.utcnow() + timedelta(days=7)
+        })
+        
+        # Définir le cookie de session
+        response.set_cookie(
+            key="session_id", 
+            value=session_id, 
+            httponly=True,
+            max_age=7*24*60*60,  # 7 jours
+            samesite="lax"
+        )
+        
+        return {"success": True, "username": username, "user_id": user_id}
+    
+    except HTTPException as he:
+        raise he
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=str(e))
+
+
+async def get_current_user(request: Request):
+    session_id = request.cookies.get("session_id")
+    if not session_id:
+        raise HTTPException(status_code=401, detail="Non authentifié")
+    
+    # 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()}
+    })
+    
+    if not session:
+        raise HTTPException(status_code=401, detail="Session expirée ou invalide")
+    
+    user = db.users.find_one({"_id": ObjectId(session["user_id"])})
+    if not user:
+        raise HTTPException(status_code=401, detail="Utilisateur non trouvé")
+    
+    return user
+
+# Endpoint pour déconnexion
+@app.post("/api/logout")
+async def logout(request: Request, response: Response):
+    session_id = request.cookies.get("session_id")
+    if session_id:
+        db.sessions.delete_one({"session_id": session_id})
+    
+    response.delete_cookie(key="session_id")
+    return {"success": True}
+@app.post("/api/register")
+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"],
+            "email": data["email"],
+            "password": hashed_password,
+            "createdAt": datetime.utcnow()
+        }
+        
+        result = db.users.insert_one(user)
+        
+        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", [])
-    embeddings = embedder.encode(texts)
-    return {"embeddings": embeddings.tolist()}
+    
+    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}
+    except Exception as e:
+        return {"error": str(e)}
 
 @app.get("/invert")
 async def invert(text: str):
@@ -48,41 +185,39 @@ async def invert(text: str):
         "inverted": text[::-1],
     }
 
-HF_TOKEN = os.getenv("REACT_APP_HF_TOKEN")
+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
-hf_client = InferenceClient(
-    provider="novita",
-    api_key=HF_TOKEN,
-)
+
+# Par cette version correcte
+hf_client = InferenceClient(token=HF_TOKEN)
 
 @app.post("/api/chat")
 async def chat(request: Request):
     data = await request.json()
     user_message = data.get("message", "").strip()
     if not user_message:
+        from fastapi import HTTPException
         raise HTTPException(status_code=400, detail="Le champ 'message' est requis.")
 
     try:
-        # Appel au modèle en mode chat
-        completion = hf_client.chat.completions.create(
+        # Utiliser l'API HF standard sans provider
+        response = hf_client.text_generation(
             model="mistralai/Mistral-7B-Instruct-v0.3",
-            messages=[
-                {"role": "system", "content": "Tu es un assistant médical spécialisé en schizophrénie."},
-                {"role": "user",   "content": user_message}
-            ],
-            max_tokens=512,
-            temperature=0.7,
+            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
         )
-
-        bot_msg = completion.choices[0].message.content
-        return {"response": bot_msg}
-
+        
+        return {"response": response}
+    
     except Exception as e:
-        # En cas d'erreur d'inférence
-        raise HTTPException(status_code=502, detail=f"Erreur d'inférence HF : {e}")
+        from fastapi import HTTPException
+        import traceback
+        print(f"Erreur détaillée: {traceback.format_exc()}")  # Log détaillé de l'erreur
+        raise HTTPException(status_code=502, detail=f"Erreur d'inférence HF : {str(e)}")
 
 
 @app.get("/data")
@@ -91,8 +226,11 @@ async def get_data():
     return JSONResponse(data)
 
 
-app.mount("/", StaticFiles(directory="static", html=True), name="static")
 
+# Ou ajoutez un index minimal
+@app.get("/")
+def read_root():
+    return {"message": "API Medically fonctionnelle", "endpoints": ["/api/chat", "/invert", "/data"]}
 if __name__ == "__main__":
     import uvicorn
 
@@ -104,4 +242,140 @@ if __name__ == "__main__":
         reload=args.reload,
         ssl_certfile=args.ssl_certfile,
         ssl_keyfile=args.ssl_keyfile,
-    )
+    )
+
+
+# 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"])
+        
+        return {"conversations": conversations}
+    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"),
+            "date": data.get("date"),
+            "time": data.get("time"),
+            "last_message": data.get("message", ""),
+            "created_at": datetime.utcnow()
+        }
+        
+        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
+        })
+        
+        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,
+            "sender": data.get("sender", "user"),
+            "text": data.get("text", ""),
+            "timestamp": datetime.utcnow()
+        }
+        
+        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()}}
+        )
+        
+        return {"success": True}
+    except Exception as e:
+        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
+        })
+        
+        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
+        
+        # Convertir les ObjectId en strings pour la sérialisation JSON
+        for msg in messages:
+            msg["_id"] = str(msg["_id"])
+            if "timestamp" in msg:
+                msg["timestamp"] = msg["timestamp"].isoformat()
+        
+        return {"messages": messages}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erreur serveur: {str(e)}")
+
+@app.delete("/api/conversations/{conversation_id}")
+async def delete_conversation(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
+        result = db.conversations.delete_one({
+            "_id": ObjectId(conversation_id),
+            "user_id": user_id
+        })
+        
+        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}
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Erreur serveur: {str(e)}")