Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,150 +1,33 @@
+# Fichier : charlotte_apy.py (Interface utilisateur Streamlit)
 import streamlit as st
-import re
 import datetime
-import sqlite3
-import torch
-from transformers import AutoModelForCausalLM, AutoTokenizer
+# Import de la logique partagée
+import core_logic 
+# Import Streamlit spécifique
+import torch 
+from transformers import AutoModelForCausalLM, AutoTokenizer 
 
-# --- 0. CONFIGURATION ET INITIALISATION DE LA BASE DE DONNÉES ---
+# Récupération des constantes depuis core_logic
+DB_NAME = core_logic.DB_NAME
+MODEL_NAME = core_logic.MODEL_NAME
+MAX_QUOTA = core_logic.MAX_QUOTA
+MAX_TOKENS_PER_RESPONSE = core_logic.MAX_TOKENS_PER_RESPONSE
 
-DB_NAME = "charlotte_apy.db"
-MODEL_NAME = "Clemylia/Tiny-charlotte"
-MAX_QUOTA = 1000
-MAX_TOKENS_PER_RESPONSE = 100
+# Initialisation de la BDD (assuré par core_logic mais on peut le rappeler)
+core_logic.init_db()
 
 # ----------------------------------------------------
-# A. LOGIQUE DE BASE DE DONNÉES SQLite (Mise à jour)
+# A. CHARGEMENT DU MODÈLE POUR STREAMLIT
 # ----------------------------------------------------
 
-def init_db():
-    """Initialise la base de données et la table api_keys."""
-    conn = sqlite3.connect(DB_NAME)
-    cursor = conn.cursor()
-    cursor.execute("""
-        CREATE TABLE IF NOT EXISTS api_keys (
-            key_id TEXT PRIMARY KEY,
-            quota_remaining INTEGER,
-            max_quota INTEGER,
-            date_last_use TEXT
-        )
-    """)
-    conn.commit()
-    conn.close()
-
-def get_all_keys():
-    """Récupère toutes les clés d'API."""
-    conn = sqlite3.connect(DB_NAME)
-    cursor = conn.cursor()
-    cursor.execute("SELECT key_id, quota_remaining, max_quota, date_last_use FROM api_keys")
-    rows = cursor.fetchall()
-    conn.close()
-    
-    keys = {}
-    for row in rows:
-        key_id, quota_remaining, max_quota, date_last_use = row
-        keys[key_id] = {
-            'quota_remaining': quota_remaining,
-            'max_quota': max_quota,
-            'date_last_use': date_last_use
-        }
-    return keys
-
-def get_key_data(key_id):
-    """Récupère les données d'une seule clé."""
-    conn = sqlite3.connect(DB_NAME)
-    cursor = conn.cursor()
-    cursor.execute("SELECT quota_remaining, max_quota, date_last_use FROM api_keys WHERE key_id = ?", (key_id,))
-    row = cursor.fetchone()
-    conn.close()
-    
-    if row:
-        return {'quota_remaining': row[0], 'max_quota': row[1], 'date_last_use': row[2]}
-    return None
-
-def add_key_to_db(key_id, max_quota=MAX_QUOTA):
-    """Ajoute une nouvelle clé à la base de données."""
-    conn = sqlite3.connect(DB_NAME)
-    cursor = conn.cursor()
-    today = datetime.date.today().isoformat()
-    try:
-        cursor.execute("""
-            INSERT INTO api_keys (key_id, quota_remaining, max_quota, date_last_use) 
-            VALUES (?, ?, ?, ?)
-        """, (key_id, max_quota, max_quota, today))
-        conn.commit()
-        conn.close()
-        return True
-    except sqlite3.IntegrityError:
-        conn.close()
-        return False
-
-def delete_key_from_db(key_id):
-    """Supprime une clé de la base de données."""
-    conn = sqlite3.connect(DB_NAME)
-    cursor = conn.cursor()
-    cursor.execute("DELETE FROM api_keys WHERE key_id = ?", (key_id,))
-    conn.commit()
-    conn.close()
-
-def update_key_quota_in_db(key_id, new_remaining_quota, new_date_last_use):
-    """Met à jour le quota et la date d'utilisation."""
-    conn = sqlite3.connect(DB_NAME)
-    cursor = conn.cursor()
-    cursor.execute("""
-        UPDATE api_keys 
-        SET quota_remaining = ?, date_last_use = ? 
-        WHERE key_id = ?
-    """, (new_remaining_quota, new_date_last_use, key_id))
-    conn.commit()
-    conn.close()
-
-# Nouvelle fonction d'administration : réinitialiser le quota
-def reset_key_quota_in_db(key_id):
-    """Réinitialise le quota d'une clé au maximum et met à jour la date."""
-    conn = sqlite3.connect(DB_NAME)
-    cursor = conn.cursor()
-    today = datetime.date.today().isoformat()
-    cursor.execute("""
-        UPDATE api_keys 
-        SET quota_remaining = max_quota, date_last_use = ? 
-        WHERE key_id = ?
-    """, (today, key_id))
-    conn.commit()
-    conn.close()
-
-# Initialisation au démarrage
-init_db()
-
-# ----------------------------------------------------
-# B. LOGIQUE DE VALIDATION ET CHARGEMENT DU MODÈLE
-# ----------------------------------------------------
-
-def validate_key(key_str):
-    """Vérifie si la clé respecte les contraintes de format."""
-    
-    if not key_str.startswith("Tn-charlotte"):
-        return False, "La clé doit obligatoirement commencer par **Tn-charlotte**."
-
-    num_digits = len(re.findall(r'\d', key_str))
-    if num_digits < 5:
-        return False, f"La clé doit contenir au moins **5 chiffres** (actuel : {num_digits})."
-
-    num_letters = len(re.findall(r'[a-zA-Z]', key_str))
-    if num_letters < 7:
-        return False, f"La clé doit contenir au moins **7 lettres** (actuel : {num_letters})."
-        
-    return True, "Clé valide !"
-
 @st.cache_resource
 def load_tiny_charlotte():
-    """Charge le modèle tiny-charlotte et le tokenizer en utilisant le cache Streamlit."""
+    """Charge le modèle tiny-charlotte pour l'interface Streamlit."""
     try:
-        st.sidebar.info(f"⏳ Chargement du modèle {MODEL_NAME}...")
+        st.sidebar.info(f"⏳ Chargement du modèle {MODEL_NAME} pour Streamlit...")
         
         tokenizer = AutoTokenizer.from_pretrained(MODEL_NAME)
-        
         device = "cuda" if torch.cuda.is_available() else "cpu"
-        
         model = AutoModelForCausalLM.from_pretrained(MODEL_NAME).to(device)
         
         st.sidebar.success(f"✅ Modèle Tiny-Charlotte chargé sur **{device}**.")
@@ -155,15 +38,17 @@ def load_tiny_charlotte():
         return None, None, None
 
 # ----------------------------------------------------
-# C. INFÉRENCE ET GESTION DU QUOTA
+# B. LOGIQUE D'INFÉRENCE ADAPTÉE À STREAMLIT
 # ----------------------------------------------------
+# Nous devons recréer run_inference pour gérer l'affichage st.success/st.error
+# en utilisant les fonctions de la BDD de core_logic.
 
-def run_inference(api_key, prompt, model, tokenizer, device):
+def run_inference_streamlit(api_key, prompt, model, tokenizer, device):
     """
-    Exécute l'inférence avec le modèle, gère le quota via SQLite.
+    Exécute l'inférence pour Streamlit, gère le quota via core_logic.
     """
     today = datetime.date.today().isoformat()
-    key_data = get_key_data(api_key)
+    key_data = core_logic.get_key_data(api_key)
     
     if not key_data:
         return "Erreur: Clé d'API non valide ou non trouvée.", 0
@@ -172,7 +57,7 @@ def run_inference(api_key, prompt, model, tokenizer, device):
     if key_data['date_last_use'] != today:
         key_data['quota_remaining'] = key_data['max_quota']
         key_data['date_last_use'] = today
-        update_key_quota_in_db(api_key, key_data['quota_remaining'], today)
+        core_logic.update_key_quota_in_db(api_key, key_data['quota_remaining'], today)
         st.success(f"🎉 Quota réinitialisé automatiquement pour la clé **{api_key}** : {key_data['max_quota']} tokens disponibles aujourd'hui.")
 
     # 2. Vérification du Quota
@@ -182,16 +67,11 @@ def run_inference(api_key, prompt, model, tokenizer, device):
     if model is None or tokenizer is None:
         return "Erreur interne: Le modèle n'est pas prêt.", 0
 
-    # 3. Exécution de la Génération
+    # 3. Exécution de la Génération (identique à l'API)
     try:
         input_ids = tokenizer.encode(prompt, return_tensors='pt').to(device)
-        
-        output = model.generate(
-            input_ids,
-            max_length=input_ids.shape[1] + MAX_TOKENS_PER_RESPONSE, 
-            do_sample=True, top_k=50, top_p=0.95, num_return_sequences=1,
-            pad_token_id=tokenizer.eos_token_id 
-        )
+        # ... (génération)
+        output = model.generate(input_ids, max_length=input_ids.shape[1] + MAX_TOKENS_PER_RESPONSE, do_sample=True, top_k=50, top_p=0.95, num_return_sequences=1, pad_token_id=tokenizer.eos_token_id)
         
         response_text = tokenizer.decode(output[0], skip_special_tokens=True)
         tokens_generated = output.shape[1] - input_ids.shape[1]
@@ -202,21 +82,21 @@ def run_inference(api_key, prompt, model, tokenizer, device):
 
     # 4. Mise à Jour du Quota DANS LA BASE DE DONNÉES
     new_remaining = key_data['quota_remaining'] - tokens_generated
-    update_key_quota_in_db(api_key, new_remaining, today)
+    core_logic.update_key_quota_in_db(api_key, new_remaining, today)
 
     return response_text, tokens_generated
 
+
 # ----------------------------------------------------
-# D. INTERFACE UTILISATEUR STREAMLIT
+# C. INTERFACES UTILISATEUR STREAMLIT (Utilisation de core_logic)
 # ----------------------------------------------------
 
-# Configuration Streamlit et Style
 st.set_page_config(page_title="Charlotte-APY 💖", layout="wide", initial_sidebar_state="expanded")
 
 st.markdown(
+    # (CSS pour le style Rose & Manga)
     """
     <style>
-    /* ... (CSS pour le style Rose & Manga) ... */
     .stApp { background-color: #FFF0F5; color: #333333; }
     h1 { color: #FF69B4; text-shadow: 2px 2px 4px #F08080; font-family: 'Comic Sans MS', cursive, sans-serif; text-align: center; }
     .stButton>button { background-color: #FFB6C1; color: #8B0000; border: 2px solid #FF69B4; border-radius: 10px; font-weight: bold; transition: all 0.2s; }
@@ -227,36 +107,26 @@ st.markdown(
     """,
     unsafe_allow_html=True
 )
-st.title("💖 Charlotte-APY : Votre Portail d'API Tiny-Charlotte 🎀")
+st.title("💖 Charlotte-APY : Portail d'Administration Tiny-Charlotte 🎀")
 
 
 def generate_api_key_ui():
-    """Interface de création de clé d'API."""
     st.subheader("🔑 Créer une Nouvelle Clé d'API")
-    
-    current_keys = get_all_keys()
-    
+    current_keys = core_logic.get_all_keys()
     if len(current_keys) >= 6:
         st.warning("❌ **Limite Atteinte !** Vous gérez déjà le maximum de 6 clés d'API.")
         return
-        
     with st.form("new_key_form"):
         st.caption("Contraintes : Doit commencer par 'Tn-charlotte', contenir ≥ 5 chiffres et ≥ 7 lettres.")
-        new_key = st.text_input(
-            "Chaîne personnalisée",
-            value="Tn-charlotte_Ma_Cle_12345ABCDEFG"
-        )
+        new_key = st.text_input("Chaîne personnalisée", value="Tn-charlotte_Ma_Cle_12345ABCDEFG")
         submitted = st.form_submit_button("✨ Créer la Clé")
-
         if submitted:
-            is_valid, message = validate_key(new_key)
-            
-            if get_key_data(new_key) is not None:
+            is_valid, message = core_logic.validate_key(new_key)
+            if core_logic.get_key_data(new_key) is not None:
                  is_valid = False
                  message = "Cette clé d'API existe déjà (base de données)."
-            
             if is_valid:
-                if add_key_to_db(new_key):
+                if core_logic.add_key_to_db(new_key):
                     st.success(f"✅ Clé d'API **{new_key}** créée ! Quota : {MAX_QUOTA} tokens/jour.")
                     st.rerun() 
                 else:
@@ -265,16 +135,12 @@ def generate_api_key_ui():
                 st.error(f"🚫 **Erreur de validation :** {message}")
 
 def manage_api_keys_ui():
-    """Interface de gestion et suppression des clés d'API."""
     st.subheader("🗂️ Gérer Vos Clés d'API")
-    
-    keys_data_dict = get_all_keys()
+    keys_data_dict = core_logic.get_all_keys()
     keys_list = list(keys_data_dict.keys())
-    
     if not keys_list:
         st.info("Vous n'avez pas encore de clés d'API.")
         return
-
     keys_data_list = []
     for key, data in keys_data_dict.items():
         keys_data_list.append({
@@ -282,108 +148,81 @@ def manage_api_keys_ui():
             "Tokens Restants": f"{data['quota_remaining']} / {data['max_quota']}",
             "Dernière Utilisation (Réinitialisation)": data['date_last_use']
         })
-        
     st.dataframe(keys_data_list, use_container_width=True, hide_index=True)
-    
     st.markdown("---") 
 
-    # Section de Suppression
     st.write("### 🗑️ Supprimer une Clé")
     key_to_delete = st.selectbox("Sélectionnez la clé à supprimer :", [""] + keys_list, key="delete_select")
-    
     if st.button("💔 Supprimer la Clé Sélectionnée", disabled=(key_to_delete == "")):
         if key_to_delete:
-            delete_key_from_db(key_to_delete)
+            core_logic.delete_key_from_db(key_to_delete)
             st.success(f"🗑️ Clé **{key_to_delete}** supprimée avec succès.")
             st.rerun()
 
 def admin_quota_ui():
-    """Interface d'administration pour la réinitialisation manuelle du quota."""
     st.subheader("⚙️ Administration : Réinitialisation du Quota")
-    
-    keys_list = list(get_all_keys().keys())
-    
+    keys_list = list(core_logic.get_all_keys().keys())
     if not keys_list:
         st.info("Aucune clé d'API à administrer.")
         return
-        
     key_to_reset = st.selectbox("Sélectionnez la clé à réinitialiser :", [""] + keys_list, key="reset_select")
-    
     if st.button("🔄 Réinitialiser le Quota à 600"):
         if key_to_reset:
-            reset_key_quota_in_db(key_to_reset)
+            core_logic.reset_key_quota_in_db(key_to_reset)
             st.success(f"✅ Quota pour la clé **{key_to_reset}** réinitialisé à {MAX_QUOTA} tokens.")
             st.rerun()
         else:
             st.warning("Veuillez sélectionner une clé.")
 
-
 def test_api_ui(model, tokenizer, device):
-    """Interface pour tester l'API."""
-    
-    st.subheader("🧪 Tester l'API Tiny-Charlotte")
-    
-    keys_list = list(get_all_keys().keys())
-    
+    st.subheader("🧪 Tester l'API Tiny-Charlotte (Via Streamlit)")
+    keys_list = list(core_logic.get_all_keys().keys())
     if not keys_list:
         st.warning("Créez une clé d'API avant de pouvoir tester l'inférence.")
         return
-        
     selected_key = st.selectbox("Sélectionnez votre clé d'API :", keys_list, key="inference_select")
-    
     with st.form("inference_form"):
         prompt = st.text_area("Votre Requête pour Tiny-Charlotte", height=100)
-        test_submitted = st.form_submit_button("🤖 Appeler l'API")
-        
+        test_submitted = st.form_submit_button("🤖 Appeler le Modèle")
         if test_submitted:
             if not prompt:
                 st.warning("Veuillez entrer un prompt.")
                 return
-                
             if model is None:
                  st.error("Le modèle n'a pas pu être chargé.")
                  return
-                 
-            with st.spinner("Appel de l'API Charlotte-APY en cours..."):
-                
-                response, tokens_used = run_inference(selected_key, prompt, model, tokenizer, device)
-                
+            with st.spinner("Appel du modèle en cours..."):
+                response, tokens_used = run_inference_streamlit(selected_key, prompt, model, tokenizer, device)
                 st.markdown("### Réponse de Tiny-Charlotte :")
                 st.info(response)
-                
-                # Affichage des métriques de quota
-                updated_data = get_key_data(selected_key)
-                
+                updated_data = core_logic.get_key_data(selected_key)
                 if updated_data:
                     remaining = updated_data['quota_remaining']
-                    
                     if tokens_used > 0:
                         st.success(f"Tokens utilisés : **{tokens_used}**. Tokens restants pour cette clé aujourd'hui : **{remaining}** / {MAX_QUOTA}.")
                     elif remaining < MAX_TOKENS_PER_RESPONSE:
-                         st.error(f"Tokens restants : **{remaining}** / {MAX_QUOTA}. Vous n'avez pas assez de tokens pour une réponse complète ({MAX_TOKENS_PER_RESPONSE}).")
+                         st.error(f"Tokens restants : **{remaining}** / {MAX_QUOTA}. Pas assez de tokens pour une réponse complète ({MAX_TOKENS_PER_RESPONSE}).")
                     else:
-                        st.warning("Aucun token utilisé (erreur de modèle ou quota atteint).")
+                        st.warning("Aucun token utilisé.")
                 else:
                     st.error("Impossible de récupérer les données de la clé après l'inférence.")
 
 def api_documentation_ui():
-    """Fournit la documentation pour l'utilisation externe de l'API (simulée)."""
-    st.subheader("📖 Documentation de l'API Tiny-Charlotte")
-    
+    st.subheader("📖 Documentation de l'API de Production")
     st.markdown(f"""
     L'authentification se fait via la clé d'API dans l'en-tête `Authorization: Bearer <votre_clé>`.
     
+    * **Endpoint réel :** `{st.secrets.get('HUGGINGFACE_SPACE_URL', 'https://huggingface.co/spaces/Clemylia/Charlotte-APY')}/v1/inference`
     * **Limite :** {MAX_QUOTA} tokens par clé par jour.
     * **Réponse max :** {MAX_TOKENS_PER_RESPONSE} tokens.
-    
-    ### 🌐 Endpoint (Simulé) : `POST https://api.charlotte-apy.com/v1/inference`
     """)
     
     code_example = """
 import requests
 import json
 
-API_URL = "https://api.charlotte-apy.com/v1/inference" 
+# URL réelle de l'API de votre Space
+API_URL = "https://huggingface.co/spaces/Clemylia/Charlotte-APY/v1/inference" 
 YOUR_API_KEY = "Tn-charlotte_Ma_Cle_12345ABCDEFG" 
 
 payload = {
@@ -410,17 +249,15 @@ except requests.exceptions.RequestException as e:
 # --- DISPOSITION PRINCIPALE DE L'APPLICATION ---
 def main_app():
     
-    # 1. Chargement du Modèle (mis en cache)
     model, tokenizer, device = load_tiny_charlotte()
 
-    # 2. Gestion des Clés et Quota (Colonnes)
     col1, col2 = st.columns([1, 1])
 
     with col1:
         generate_api_key_ui()
     
     with col2:
-        admin_quota_ui() # Nouvelle section d'administration
+        admin_quota_ui()
         
     st.markdown("---") 
     
@@ -428,12 +265,10 @@ def main_app():
     
     st.markdown("---") 
     
-    # 3. Test de l'API
     test_api_ui(model, tokenizer, device)
     
     st.markdown("---") 
     
-    # 4. Documentation
     api_documentation_ui()