Update app.py

app.py

@@ -4,21 +4,27 @@ import os
 from dotenv import load_dotenv
 import http.client
 import json
+import time
+import tempfile
+from pathlib import Path
+import logging
 
-load_dotenv()
-
-# Configure the API key
-genai.configure(api_key=os.getenv("GOOGLE_API_KEY"))
+# Configuration du logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
 
-safety_settings = [
-    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
-    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
-    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
-    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
-]
+# Chargement des variables d'environnement
+load_dotenv()
 
-ss = """
+# Configuration des constantes
+GOOGLE_API_KEY = os.getenv("GOOGLE_API_KEY")
+SERPER_API_KEY = os.getenv("SERPER_API_KEY", "9b90a274d9e704ff5b21c0367f9ae1161779b573")
+MODEL_NAME = "gemini-2.0-flash-exp"
+MAX_SEARCH_RESULTS = 3
+MAX_QUESTIONS = 2
 
+# Définition du système prompt pour Mariam
+SYSTEM_PROMPT = """
 # Prompt System pour Mariam, IA conçu par youssouf 
 
 ## Personnalité Fondamentale
@@ -105,25 +111,69 @@ Mariam est une IA chaleureuse, bienveillante et authentique, conçue pour être
 - Maintenir une cohérence dans les réponses
 - Garder un historique contextuel pour des interactions plus naturelles
 - Mettre à jour régulièrement les connaissances et capacités
-
-## Amélioration Continue
-
-- Collecter les retours des utilisateurs
-- Analyser les interactions pour identifier les points d'amélioration
-- Ajuster les réponses en fonction des retours
-- Maintenir à jour les connaissances et références
-
 """
 
+# Paramètres de sécurité pour Gemini
+SAFETY_SETTINGS = [
+    {"category": "HARM_CATEGORY_HARASSMENT", "threshold": "BLOCK_NONE"},
+    {"category": "HARM_CATEGORY_HATE_SPEECH", "threshold": "BLOCK_NONE"},
+    {"category": "HARM_CATEGORY_SEXUALLY_EXPLICIT", "threshold": "BLOCK_NONE"},
+    {"category": "HARM_CATEGORY_DANGEROUS_CONTENT", "threshold": "BLOCK_NONE"},
+]
 
-model = genai.GenerativeModel('gemini-2.0-flash-exp', tools='code_execution',
-                            safety_settings=safety_settings,
-                            system_instruction=ss)
+# Types de fichiers acceptés
+ACCEPTED_FILE_TYPES = {
+    'image': ['jpg', 'jpeg', 'png', 'gif', 'bmp', 'webp'],
+    'document': ['pdf', 'txt', 'docx', 'md'],
+    'audio': ['mp3', 'wav', 'ogg', 'm4a'],
+    'video': ['mp4', 'mov', 'avi', 'webm']
+}
+ALL_ACCEPTED_FILES = [ext for exts in ACCEPTED_FILE_TYPES.values() for ext in exts]
+
+# Fonction pour initialiser l'état de session
+def initialize_session_state():
+    """Initialise les variables d'état de session de Streamlit."""
+    if "api_initialized" not in st.session_state:
+        try:
+            genai.configure(api_key=GOOGLE_API_KEY)
+            st.session_state.api_initialized = True
+        except Exception as e:
+            logger.error(f"Erreur lors de l'initialisation de l'API Gemini: {e}")
+            st.session_state.api_initialized = False
+    
+    if "chat" not in st.session_state:
+        try:
+            model = genai.GenerativeModel(
+                MODEL_NAME, 
+                tools='code_execution',
+                safety_settings=SAFETY_SETTINGS,
+                system_instruction=SYSTEM_PROMPT
+            )
+            st.session_state.chat = model.start_chat(history=[])
+            st.session_state.model = model
+        except Exception as e:
+            logger.error(f"Erreur lors de l'initialisation du modèle: {e}")
+            st.error("Impossible d'initialiser le modèle IA. Veuillez vérifier votre clé API.")
+    
+    # Autres variables d'état
+    if "web_search" not in st.session_state:
+        st.session_state.web_search = False
+    if "messages" not in st.session_state:
+        st.session_state.messages = []
+    if "thinking" not in st.session_state:
+        st.session_state.thinking = False
+    if "username" not in st.session_state:
+        st.session_state.username = None
+    if "temp_dir" not in st.session_state:
+        st.session_state.temp_dir = tempfile.mkdtemp()
+
+# Fonction pour effectuer une recherche web
 def perform_web_search(query):
+    """Effectue une recherche web via l'API Serper et retourne les résultats."""
     conn = http.client.HTTPSConnection("google.serper.dev")
     payload = json.dumps({"q": query})
     headers = {
-        'X-API-KEY': '9b90a274d9e704ff5b21c0367f9ae1161779b573',
+        'X-API-KEY': SERPER_API_KEY,
         'Content-Type': 'application/json'
     }
     try:
@@ -132,12 +182,14 @@ def perform_web_search(query):
         data = json.loads(res.read().decode("utf-8"))
         return data
     except Exception as e:
-        st.error(f"Erreur lors de la recherche web : {e}")
+        logger.error(f"Erreur lors de la recherche web: {e}")
         return None
     finally:
         conn.close()
 
+# Fonction pour formater les résultats de recherche
 def format_search_results(data):
+    """Formate les résultats de recherche en texte markdown pour l'IA."""
     if not data:
         return "Aucun résultat trouvé"
     
@@ -149,97 +201,255 @@ def format_search_results(data):
         result += f"### {kg.get('title', '')}\n"
         result += f"*{kg.get('type', '')}*\n\n"
         result += f"{kg.get('description', '')}\n\n"
+        # Ajouter des attributs si disponibles
+        if 'attributes' in kg:
+            for key, value in kg['attributes'].items():
+                result += f"- **{key}**: {value}\n"
+            result += "\n"
     
     # Organic Results
     if 'organic' in data:
         result += "### Résultats principaux:\n"
-        for item in data['organic'][:3]:  # Limit to top 3 results
+        for item in data['organic'][:MAX_SEARCH_RESULTS]:
             result += f"- **{item['title']}**\n"
             result += f"  {item['snippet']}\n"
-            result += f"  [Lien]({item['link']})\n\n"
+            if 'date' in item:
+                result += f"  *Publié: {item['date']}*\n"
+            result += f"  [Source]({item['link']})\n\n"
     
     # People Also Ask
     if 'peopleAlsoAsk' in data:
         result += "### Questions fréquentes:\n"
-        for item in data['peopleAlsoAsk'][:2]:  # Limit to top 2 questions
+        for item in data['peopleAlsoAsk'][:MAX_QUESTIONS]:
             result += f"- **{item['question']}**\n"
             result += f"  {item['snippet']}\n\n"
     
-    return result
-
-def role_to_streamlit(role):
-    if role == "model":
-        return "assistant"
-    else:
-        return role
-
-# Add chat and settings to session state
-if "chat" not in st.session_state:
-    st.session_state.chat = model.start_chat(history=[])
-if "web_search" not in st.session_state:
-    st.session_state.web_search = False
-
-# Display Form Title
-st.title("Mariam AI!")
-
-# Settings section
-with st.sidebar:
-    st.title("Paramètres")
-    st.session_state.web_search = st.toggle("Activer la recherche web", value=st.session_state.web_search)
-
-# File upload section
-uploaded_file = st.file_uploader("Télécharger un fichier (image/document)", type=['jpg', 'mp4', 'mp3', 'jpeg', 'png', 'pdf', 'txt'])
+    # News
+    if 'news' in data and data['news']:
+        result += "### Actualités récentes:\n"
+        for item in data['news'][:2]:
+            result += f"- **{item['title']}**\n"
+            result += f"  {item['snippet']}\n"
+            result += f"  *Source: {item.get('source', 'Non spécifiée')} - {item.get('date', '')}*\n\n"
 
-# Display chat messages
-for message in st.session_state.chat.history:
-    with st.chat_message(role_to_streamlit(message.role)):
-        st.markdown(message.parts[0].text)
+    return result
 
-# Function to handle file upload with Gemini
+# Fonction pour traiter le fichier téléchargé
 def process_uploaded_file(file):
-    if file is not None:
-        with open(os.path.join("temp", file.name), "wb") as f:
-            f.write(file.getbuffer())
-        try:
-            gemini_file = genai.upload_file(os.path.join("temp", file.name))
-            return gemini_file
-        except Exception as e:
-            st.error(f"Erreur lors du téléchargement du fichier : {e}")
-            return None
-
-# Chat input and processing
-if prompt := st.chat_input("Hey?"):
-    uploaded_gemini_file = None
-    if uploaded_file:
-        uploaded_gemini_file = process_uploaded_file(uploaded_file)
-    
-    # Display user message
-    st.chat_message("user").markdown(prompt)
-    print(prompt)
-    print("------------")
+    """Traite le fichier téléchargé et le prépare pour l'API Gemini."""
+    if file is None:
+        return None
+        
+    # Créer un chemin de fichier temporaire
+    file_path = Path(st.session_state.temp_dir) / file.name
+    
+    # Écrire le fichier sur le disque
+    with open(file_path, "wb") as f:
+        f.write(file.getbuffer())
+    
+    try:
+        # Télécharger le fichier vers l'API Gemini
+        gemini_file = genai.upload_file(str(file_path))
+        logger.info(f"Fichier téléchargé avec succès: {file.name}")
+        return gemini_file
+    except Exception as e:
+        logger.error(f"Erreur lors du téléchargement du fichier: {e}")
+        st.error(f"Erreur lors du téléchargement du fichier: {e}")
+        return None
+
+# Fonction pour gérer l'envoi de message
+def handle_message(prompt, uploaded_file=None):
+    """Gère l'envoi d'un message à l'IA et la réception de la réponse."""
+    if not prompt.strip():
+        return
+    
+    # Ajouter le message de l'utilisateur à l'historique
+    st.session_state.messages.append({"role": "user", "content": prompt})
+    
+    # Indiquer que l'IA est en train de réfléchir
+    st.session_state.thinking = True
+    
     try:
-        # Perform web search if enabled
+        # Traiter le fichier téléchargé s'il existe
+        uploaded_gemini_file = None
+        if uploaded_file:
+            uploaded_gemini_file = process_uploaded_file(uploaded_file)
+        
+        # Effectuer une recherche web si activée
         web_results = None
+        enhanced_prompt = prompt
+        
         if st.session_state.web_search:
-            with st.spinner("Recherche web en cours..."):
+            with st.spinner("Recherche d'informations en cours..."):
                 web_results = perform_web_search(prompt)
                 if web_results:
                     formatted_results = format_search_results(web_results)
-                    prompt = f"""Question: {prompt}\n\nRésultats de recherche web:\n{formatted_results}\n\nPourrais-tu analyser ces informations et me donner une réponse complète?"""
+                    enhanced_prompt = f"""Question: {prompt}
+
+Résultats de recherche web:
+{formatted_results}
+
+Analyse ces informations et donne une réponse complète et à jour. Cite tes sources quand c'est pertinent."""
         
-        # Send message to Gemini
+        # Envoyer le message à l'API Gemini
         if uploaded_gemini_file:
-            response = st.session_state.chat.send_message([uploaded_gemini_file, "\n\n", prompt])
+            response = st.session_state.chat.send_message([uploaded_gemini_file, "\n\n", enhanced_prompt])
         else:
-            response = st.session_state.chat.send_message(prompt)
+            response = st.session_state.chat.send_message(enhanced_prompt)
+        
+        # Ajouter la réponse à l'historique
+        st.session_state.messages.append({"role": "assistant", "content": response.text})
+        logger.info("Réponse générée avec succès")
+        
+    except Exception as e:
+        error_msg = f"Erreur lors de la génération de la réponse: {str(e)}"
+        st.session_state.messages.append({"role": "assistant", "content": error_msg})
+        logger.error(error_msg)
+    
+    finally:
+        st.session_state.thinking = False
 
-        print(response.text)
-        # Display assistant response
-        with st.chat_message("assistant"):
-            st.markdown(response.text)
+# Fonction pour afficher l'interface
+def render_ui():
+    """Affiche l'interface utilisateur de l'application."""
     
-    except Exception as e:
-        st.error(f"Erreur lors de l'envoi du message : {e}")
+    # Configuration du thème et du titre
+    st.set_page_config(
+        page_title="Mariam AI",
+        page_icon="🤖",
+        layout="wide",
+        initial_sidebar_state="expanded"
+    )
+    
+    # Barre latérale avec paramètres
+    with st.sidebar:
+        st.image("https://via.placeholder.com/150x150.png?text=Mariam+AI", width=150)
+        st.title("Mariam AI")
+        st.caption("Votre assistante IA personnelle")
+        
+        # Paramètres utilisateur
+        with st.expander("⚙️ Paramètres", expanded=False):
+            # Nom d'utilisateur
+            username = st.text_input("Votre nom (optionnel)", value=st.session_state.username or "")
+            if username != st.session_state.username:
+                st.session_state.username = username
+            
+            # Activation de la recherche web
+            web_search = st.toggle(
+                "Activer la recherche web", 
+                value=st.session_state.web_search,
+                help="Permet à Mariam d'effectuer des recherches web pour répondre à vos questions"
+            )
+            if web_search != st.session_state.web_search:
+                st.session_state.web_search = web_search
+        
+        # Actions
+        with st.expander("🔄 Actions", expanded=False):
+            if st.button("Nouvelle conversation", use_container_width=True):
+                st.session_state.chat = st.session_state.model.start_chat(history=[])
+                st.session_state.messages = []
+                st.rerun()
+        
+        # À propos
+        with st.expander("ℹ️ À propos", expanded=False):
+            st.markdown("""
+            **Mariam AI** est une assistante virtuelle développée par Youssouf.
+            
+            Elle est conçue pour être:
+            - 🤗 Chaleureuse et empathique
+            - 🧠 Intelligente et informative
+            - 🛠️ Pratique et utile
+            
+            Basée sur la technologie Google Gemini.
+            """)
+        
+        st.divider()
+        st.caption("© 2025 Mariam AI • Tous droits réservés")
+    
+    # Contenu principal
+    col1, col2 = st.columns([3, 1])
+    
+    with col1:
+        # Titre principal
+        st.title("💬 Discutez avec Mariam")
+        
+        # Zone de messages
+        message_container = st.container(height=500, border=False)
+        
+        with message_container:
+            # Afficher tous les messages
+            for message in st.session_state.messages:
+                with st.chat_message(message["role"]):
+                    st.markdown(message["content"])
+            
+            # Afficher l'indicateur "en train d'écrire"
+            if st.session_state.thinking:
+                with st.chat_message("assistant"):
+                    st.write("Mariam est en train de réfléchir...")
+        
+        # Zone de saisie et téléchargement
+        file_col, input_col = st.columns([1, 4])
+        
+        with file_col:
+            # Zone de téléchargement de fichier
+            uploaded_file = st.file_uploader(
+                "Fichier",
+                type=ALL_ACCEPTED_FILES,
+                label_visibility="collapsed",
+                help="Téléchargez une image, un document ou un fichier audio pour en discuter avec Mariam"
+            )
+        
+        with input_col:
+            # Zone de saisie de texte
+            user_input = st.chat_input(
+                "Posez une question à Mariam...", 
+                disabled=st.session_state.thinking
+            )
+            
+            if user_input:
+                handle_message(user_input, uploaded_file)
+                st.rerun()
+    
+    with col2:
+        # Zone d'informations sur les fichiers
+        st.subheader("📎 Fichiers acceptés")
+        st.markdown("""
+        - **Images**: jpg, jpeg, png, gif
+        - **Documents**: pdf, txt, docx
+        - **Audio**: mp3, wav, ogg
+        - **Vidéo**: mp4, mov, avi
+        """)
+        
+        # Aperçu du fichier téléchargé
+        if uploaded_file:
+            st.subheader("🔍 Fichier téléchargé")
+            
+            file_ext = uploaded_file.name.split('.')[-1].lower()
+            
+            if file_ext in ACCEPTED_FILE_TYPES['image']:
+                st.image(uploaded_file, caption=uploaded_file.name, use_column_width=True)
+            elif file_ext in ACCEPTED_FILE_TYPES['audio']:
+                st.audio(uploaded_file, format=f'audio/{file_ext}')
+            elif file_ext in ACCEPTED_FILE_TYPES['video']:
+                st.video(uploaded_file)
+            else:
+                st.info(f"Fichier: {uploaded_file.name}")
+                file_details = {"Nom": uploaded_file.name, "Type": uploaded_file.type, "Taille": f"{uploaded_file.size / 1024:.1f} KB"}
+                st.json(file_details)
+
+# Fonction principale
+def main():
+    # Initialiser l'état de session
+    initialize_session_state()
+    
+    # Vérifier si l'API est initialisée
+    if not st.session_state.get("api_initialized", False):
+        st.error("Erreur d'initialisation de l'API. Veuillez vérifier votre clé API dans le fichier .env")
+        st.stop()
+    
+    # Afficher l'interface
+    render_ui()
 
-# Create temp directory
-os.makedirs("temp", exist_ok=True)
+# Point d'entrée principal
+if __name__ == "__main__":
+    main()