update

app.py

@@ -1,125 +1,81 @@
-from fastapi import FastAPI, Depends, HTTPException, status
-from sqlalchemy.orm import Session
-from sqlalchemy import create_engine, Column, Integer, String, Boolean, Enum
-from sqlalchemy.ext.declarative import declarative_base
-from sqlalchemy.orm import sessionmaker
-from passlib.context import CryptContext
-from jose import JWTError, jwt
-import openai
-from fastapi.middleware.cors import CORSMiddleware
-
-# Configuration de la base de données MySQL
-DATABASE_URL = "mysql+mysqlconnector://basa6167_kity_cara:4P&l-5yH1Ql8@https://kumquat.o2switch.net:2083/basa6167_kitty"
-engine = create_engine(DATABASE_URL)
-SessionLocal = sessionmaker(autocommit=False, autoflush=False, bind=engine)
-Base = declarative_base()
+from fastapi import FastAPI, HTTPException
+from pydantic import BaseModel
+from openai import OpenAI
 
-app =FastAPI(
-    title='API kitty',
-    description ='Informations'
-)  
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
+# Initialiser le client OpenAI
+client = OpenAI(
+    base_url="https://integrate.api.nvidia.com/v1",
+    api_key="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"
 )
 
-# Configuration JWT et hachage de mot de passe
-SECRET_KEY = "your_secret_key"
-ALGORITHM = "HS256"
-ACCESS_TOKEN_EXPIRE_MINUTES = 30
-
-pwd_context = CryptContext(schemes=["bcrypt"], deprecated="auto")
-
-# Modèle pour les utilisateurs
-class User(Base):
-    __tablename__ = "users"
-    id = Column(Integer, primary_key=True, index=True)
-    name = Column(String(255), unique=True, index=True)
-    passcode = Column(String(255))
-    accept_terms = Column(Boolean)
-    sex = Column(Enum('male', 'female'))
-    age = Column(Integer)
-
-Base.metadata.create_all(bind=engine)
-
-app = FastAPI()
-
-# Créer une session pour la base de données
-def get_db():
-    db = SessionLocal()
-    try:
-        yield db
-    finally:
-        db.close()
-
-# Fonction pour vérifier le mot de passe haché
-def verify_password(plain_password, hashed_password):
-    return pwd_context.verify(plain_password, hashed_password)
-
-# Fonction pour hacher le mot de passe
-def get_password_hash(password):
-    return pwd_context.hash(password)
-
-# Fonction pour créer un JWT token
-def create_access_token(data: dict):
-    to_encode = data.copy()
-    token = jwt.encode(to_encode, SECRET_KEY, algorithm=ALGORITHM)
-    return token
-
-# Schéma de données pour la création d'utilisateurs
-from pydantic import BaseModel
-class UserCreate(BaseModel):
+# Définir les prompts
+DEFAULT_PROMPT2 = """You are Kittycara, a friendly AI assistant designed to help adolescent girls and their caretakers understand menstrual health. 
+Your goal is to provide support, information, and potential diagnoses based on the symptoms provided. Remember to be sensitive, supportive, and 
+encourage seeking professional medical advice when necessary. Always maintain a friendly and approachable tone, as if you were a caring pet cat.
+Always explain medical terms in a way that is easy to understand. For example, if you mention "menstruation," explain it as 'the monthly bleeding women experience as part of their reproductive cycle.'
+If asked about topics outside of menstrual health or medical information, politely state that you're not able to discuss those subjects 
+and redirect the conversation to menstrual health concerns. Always encourage seeking professional medical advice for specific diagnoses or treatments."""
+
+SYMPTOMS = [
+    "Heavy bleeding", "Irregular periods", "Painful periods", "Missed periods",
+    "Spotting between periods", "Mood swings", "Fatigue", "Abdominal pain",
+    "Nausea", "Headaches", "Breast tenderness", "Acne"
+]
+
+# Définir les classes de données d'entrée avec Pydantic
+class RequestData(BaseModel):
     name: str
-    passcode: str
-    accept_terms: bool
-    sex: str
     age: int
+    sex: str
+    message: str
+    history: list
+    symptoms: list
 
-# Schéma de données pour l'authentification
-class Token(BaseModel):
-    access_token: str
-    token_type: str
-
-class UserLogin(BaseModel):
-    name: str
-    passcode: str
-
-# Inscription d'un utilisateur
-@app.post("/register/")
-def register(user: UserCreate, db: Session = Depends(get_db)):
-    hashed_password = get_password_hash(user.passcode)
-    db_user = User(name=user.name, passcode=hashed_password, accept_terms=user.accept_terms, sex=user.sex, age=user.age)
-    db.add(db_user)
-    db.commit()
-    db.refresh(db_user)
-    return {"message": "User registered successfully"}
+# Initialiser l'application FastAPI
+app = FastAPI()
 
-# Connexion d'un utilisateur
-@app.post("/login/", response_model=Token)
-def login(user: UserLogin, db: Session = Depends(get_db)):
-    db_user = db.query(User).filter(User.name == user.name).first()
-    if not db_user:
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials")
-    if not verify_password(user.passcode, db_user.passcode):
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid credentials")
-    
-    access_token = create_access_token(data={"sub": db_user.name})
-    return {"access_token": access_token, "token_type": "bearer"}
+# Fonction pour obtenir un message personnalisé basé sur les symptômes
+def get_reassurance_message(symptoms):
+    if "Painful periods" in symptoms or "Abdominal pain" in symptoms:
+        return "I know that pain can be tough, but you're doing great, and it's important to listen to your body. 🫂 Take care, and don't hesitate to reach out to a healthcare professional!"
+    elif "Mood swings" in symptoms or "Fatigue" in symptoms:
+        return "It's completely normal to feel this way sometimes. Don't worry, you're not alone, and things will get better. 🌼 Stay strong!"
+    elif "Heavy bleeding" in symptoms:
+        return "Heavy bleeding can be concerning, but there are options to help manage it. 🧡 It’s always good to talk to a doctor to make sure everything's okay."
+    else:
+        return "You're doing great by paying attention to your health. 💪 Keep going, and don't hesitate to ask for help if you need it!"
+
+# Fonction pour prédire la réponse
+def predict(name, age, sex, message, history, symptoms):
+    messages = [{"role": "system", "content": DEFAULT_PROMPT2}]
+    for human, assistant in history:
+        messages.append({"role": "user", "content": human})
+        messages.append({"role": "assistant", "content": assistant})
+
+    selected_symptoms = ", ".join([sym for sym in symptoms if sym])
+    full_message = f"Name: {name}, Age: {age}, Sex: {sex}\nSymptoms: {selected_symptoms}\nAdditional information: {message}"
+    messages.append({"role": "user", "content": full_message})
 
-# API protégée utilisant OpenAI après connexion
-@app.post("/use_openai/")
-def use_openai(db: Session = Depends(get_db), token: str = Depends(create_access_token)):
-    # Appel à l'API OpenAI en utilisant la clé d'accès
-    openai.api_key = "YOUR_OPENAI_API_KEY"
-    
-    # Exemple de requête OpenAI
-    response = openai.Completion.create(
-        engine="text-davinci-003",
-        prompt="Hello, how are you?",
-        max_tokens=50
-    )
-    
-    return {"openai_response": response["choices"][0]["text"].strip()}
+    try:
+        completion = client.chat.completions.create(
+            model="meta/llama-3.1-8b-instruct",
+            messages=messages,
+            temperature=0.2,
+            top_p=0.9,
+            max_tokens=1024,
+            stream=True
+        )
+
+        full_response = ""
+        for chunk in completion:
+            if chunk.choices[0].delta.content is not None:
+                full_response += chunk.choices[0].delta.content
+
+        return full_response
+    except Exception as e:
+        return f"Erreur : {str(e)}"
+
+# Point de départ pour lancer l'application FastAPI avec Uvicorn
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)