Update README.md

README.md

@@ -11,16 +11,182 @@ run: sh run.sh
 
 # 💖 Charlotte-APY : Portail d'Administration Tiny-Charlotte 🎀
 
-Ce Space héberge deux services :
-1.  **Interface d'administration (Streamlit)** sur le port 7860 (visible ci-dessus).
-2.  **API d'Inférence (FastAPI)** sur le port 7861 (accessible publiquement).
+Pour utiliser l'API Tiny-charlotte,
+dans votre propre application/script vous devez cloné le space en local et exécuter les codes suivant !
 
----
+# Cellule 1 : Lancement du Serveur FastAPI (Méthode Robuste)
+
+```
+import sys
+import os
+import subprocess
+import threading
+import time
+import nest_asyncio
+
+# --- Installation et Chemin d'Accès ---
+!pip install fastapi uvicorn requests nest-asyncio python-multipart starlette transformers torch --quiet
+print("Dépendances vérifiées.")
+
+# Chemin du dossier 'src' qui contient api_server.py et core_logic.py
+src_path = os.path.abspath('Charlotte-APY/src')
+
+# --- Définition des Paramètres du Serveur ---
+# Le module est simplement 'api_server:app' car nous allons nous déplacer dans son répertoire.
+FASTAPI_MODULE = "api_server:app"
+FASTAPI_PORT = 8000
+FASTAPI_CMD = f"uvicorn {FASTAPI_MODULE} --host 127.0.0.1 --port {FASTAPI_PORT}"
+
+nest_asyncio.apply()
+
+# --- Fonction de Lancement Robuste ---
+def run_fastapi():
+    """
+    Lance le serveur FastAPI en changeant de répertoire de travail (CWD).
+    Ceci est essentiel pour que Python trouve 'api_server' et 'core_logic'
+    sans manipulation complexe du PYTHONPATH.
+    """
+    
+    # CLÉ DE LA CORRECTION : Changer le répertoire de travail pour le dossier 'src'
+    if not os.path.exists(src_path):
+        print(f"❌ ERREUR: Le chemin {src_path} n'existe pas. Veuillez vérifier que le dépôt est cloné correctement.")
+        return
+        
+    os.chdir(src_path)
+    
+    print("\n-----------------------------------------------------")
+    print(f"Démarrage de FastAPI sur http://127.0.0.1:{FASTAPI_PORT}...")
+    print(f"Répertoire de travail actuel: {os.getcwd()}") # Doit pointer vers .../Charlotte-APY/src
+    
+    try:
+        # Lancement non-bloquant du serveur
+        get_ipython().system(FASTAPI_CMD)
+    except NameError:
+        # Fallback pour un environnement Python standard
+        subprocess.run(FASTAPI_CMD, shell=True)
+    finally:
+        # Revenir au répertoire initial (racine de Colab) après l'exécution
+        os.chdir(os.path.abspath('..'))
+
+
+# Lancement du serveur dans un thread séparé.
+fastapi_thread = threading.Thread(target=run_fastapi, daemon=True)
+fastapi_thread.start()
+
+# Attendre le chargement du modèle
+print("Attente de 30 secondes pour le démarrage du serveur et le chargement du modèle...")
+time.sleep(30) 
+print("-----------------------------------------------------")
+print("✅ Le serveur est censé être prêt ! Tentez l'appel API dans la cellule suivante.")
+
+```
+Clone du space :
+```
+git clone https://huggingface.co/spaces/Clemylia/Charlotte-APY
+```
+Requête :
+
+# Cellule 2 : Test du Client API
+
+```
+import requests
+import json
+import time
+
+# --- Configurations ---
+API_BASE_URL = "http://127.0.0.1:8000/"
+API_PATH = "v1/inference"
+API_URL = API_BASE_URL + API_PATH
+
+YOUR_API_KEY = "Tn-charlotte_Ma_Cle_12345ABCDEFG"
+PROMPT = "Salut ? Explique-moi la différence entre l'espoir et l'optimisme en une phrase."
+
+# --- Construction de la Requête ---
+headers = {
+    "Content-Type": "application/json",
+    "Authorization": f"Bearer {YOUR_API_KEY}"
+}
+payload = {
+    "prompt": PROMPT,
+}
+
+# --- Appel API ---
+print(f"🚀 Envoi de la requête locale à : {API_URL}")
+
+try:
+    start_time = time.time()
+    response = requests.post(
+        API_URL,
+        headers=headers,
+        data=json.dumps(payload),
+        timeout=120
+    )
+
+    response.raise_for_status()
+    response_json = response.json()
+    end_time = time.time()
+
+    print("\n✅ Réponse reçue :")
+    print(json.dumps(response_json, indent=4, ensure_ascii=False))
+    print(f"\nDurée de l'appel : {end_time - start_time:.2f} secondes.")
+
+except requests.exceptions.HTTPError as errh:
+    print(f"\n❌ Erreur HTTP ({response.status_code}) : {errh}")
+    try:
+        print(f"Détail du serveur : {response.json().get('detail', response.text)}")
+    except:
+        print("Réponse brute du serveur : Impossible de décoder JSON.")
+except requests.exceptions.RequestException as e:
+    print(f"\n❌ Une erreur s'est produite lors de l'appel API : {e}")
+
+Rechargement :
+# Cellule 4 : Forcer le Rechargement du Module core_logic
+
+import importlib
+import core_logic # Importe le module initialement
+
+print("Tentative de rechargement du module core_logic...")
+try:
+    # Cette fonction force Python à relire le fichier core_logic.py depuis le disque
+    importlib.reload(core_logic)
+    print("✅ core_logic rechargé avec succès. La nouvelle fonction 'create_api_key' devrait être disponible.")
+except NameError:
+    # Si le module n'était pas chargé
+    print("core_logic n'était pas chargé, le prochain appel Cellule 3 le chargera.")
+except Exception as e:
+    print(f"❌ Erreur lors du rechargement : {e}")
+```
+créer une clé ;
+
+
+# Cellule 3 : Création d'une Nouvelle Clé d'API Valide (Correction)
+
+```
+import sys
+import os
+import core_logic 
+
+# --- S'assurer que le chemin est correct (héritage de Cellule 1) ---
 
-## 🔑 Accès à l'API de Production
+print("🔑 Tentative de création d'une nouvelle clé d'API...")
+core_logic.init_db() 
 
-Si l'API n'est pas accessible via l'URL principale, veuillez essayer l'URL spécifique au port :
+# 1. Utilisation de la fonction correcte, 'create_api_key'
+# Ligne corrigée ci-dessous :
+new_key = core_logic.create_api_key() # <-- CORRECTION
 
-`https://Clemylia-Charlotte-APY-7861.hf.space/v1/inference`
+# 2. Récupère les données pour confirmation
+if new_key:
+    key_data = core_logic.get_key_data(new_key)
+else:
+    key_data = None
 
-Vous devez inclure un en-tête `Authorization: Bearer <votre_clé>` pour utiliser le service.
+print("\n--- Résultat ---")
+if key_data:
+    print(f"✅ Nouvelle clé d'API créée et enregistrée avec succès !")
+    print(f"Clé d'API à utiliser : **{new_key}**")
+    print(f"Quota initial : {key_data['max_quota']} tokens")
+    print("\n💡 Utilisez cette clé pour remplacer 'YOUR_API_KEY' dans la Cellule 2.")
+else:
+    print("❌ Échec de la création de la clé.")
+```