Update src/streamlit_app_stable.py

src/streamlit_app_stable.py

@@ -5,8 +5,9 @@ import time
 import psutil
 from transformers import AutoProcessor, Gemma3nForConditionalGeneration
 from PIL import Image
+import os # Importé pour l'exemple d'utilisation de `max_upload_size`
 
-# Configuration de la page
+# --- Configuration de la Page ---
 st.set_page_config(
     page_title="AgriLens AI - Analyse de Plantes",
     page_icon="🌱",
@@ -14,7 +15,7 @@ st.set_page_config(
     initial_sidebar_state="expanded"
 )
 
-# Initialisation des variables de session
+# --- Initialisation des Variables de Session ---
 if 'model_loaded' not in st.session_state:
     st.session_state.model_loaded = False
 if 'model' not in st.session_state:
@@ -26,13 +27,14 @@ if 'model_status' not in st.session_state:
 if 'model_load_time' not in st.session_state:
     st.session_state.model_load_time = None
 if 'language' not in st.session_state:
-    st.session_state.language = "fr"
+    st.session_state.language = "fr" # Langue par défaut
 if 'load_attempt_count' not in st.session_state:
     st.session_state.load_attempt_count = 0
 if 'device' not in st.session_state:
     st.session_state.device = "cpu"
 
-# Fonctions d'aide système
+# --- Fonctions d'Aide Système ---
+
 def check_model_health():
     """Vérifie si le modèle et le processeur sont chargés et semblent opérationnels."""
     try:
@@ -49,7 +51,7 @@ def diagnose_loading_issues():
     try:
         ram = psutil.virtual_memory()
         ram_gb = ram.total / (1024**3)
-        if ram_gb < 8:
+        if ram_gb < 8: # Recommandation générale, le modèle peut nécessiter plus
             issues.append(f"⚠️ RAM faible: {ram_gb:.1f}GB (recommandé: 8GB+ pour ce modèle)")
     except Exception as e:
         issues.append(f"⚠️ Impossible de vérifier la RAM : {e}")
@@ -65,7 +67,7 @@ def diagnose_loading_issues():
     if torch.cuda.is_available():
         try:
             gpu_memory = torch.cuda.get_device_properties(0).total_memory / (1024**3)
-            if gpu_memory < 6:
+            if gpu_memory < 6: # Recommandation générale, le modèle peut nécessiter plus
                 issues.append(f"⚠️ GPU mémoire faible: {gpu_memory:.1f}GB (recommandé: 6GB+)")
         except Exception as e:
             issues.append(f"⚠️ Erreur lors de la vérification de la mémoire GPU : {e}")
@@ -89,11 +91,11 @@ def afficher_ram_disponible(context=""):
         ram_used_gb = ram.used / (1024**3)
         ram_total_gb = ram.total / (1024**3)
         ram_percent = ram.percent
-        st.write(f"💾 RAM {context}: {ram_used_gb:.1f}GB / {ram_total_gb:.1f}GB ({ram_percent:.1f}%)")
+        st.write(f"💾 RAM : {ram_used_gb:.1f}GB / {ram_total_gb:.1f}GB ({ram_percent:.1f}%)")
     except Exception as e:
-        st.write(f"💾 Impossible d'afficher l'utilisation de la RAM {context}: {e}")
+        st.write(f"💾 Impossible d'afficher l'utilisation de la RAM : {e}")
 
-# Gestion des traductions
+# --- Gestion des Traductions ---
 def t(key):
     """Fonction pour gérer les traductions."""
     translations = {
@@ -110,7 +112,48 @@ def t(key):
             "config_title": "⚙️ Configuration & Informations",
             "about_title": "ℹ️ À Propos de l'Application",
             "load_model": "Charger le Modèle IA",
-            "model_status": "Statut du Modèle IA"
+            "model_status": "Statut du Modèle IA",
+            "upload_image_label": "📁 Upload d'image",
+            "webcam_capture_label": "📷 Capture par webcam",
+            "image_analysis_options_title": "Options d'analyse",
+            "analysis_type_full_diagnosis": "Diagnostic complet (maladie, soins, prévention)",
+            "analysis_type_disease_id": "Identification et diagnostic de maladies",
+            "analysis_type_care_advice": "Conseils de soins et d'entretien",
+            "custom_prompt_label": "Prompt personnalisé (optionnel) :",
+            "analyze_image_button": "🔍 Analyser l'image",
+            "analyze_text_button": "🔍 Analyser la description",
+            "model_not_loaded_warning": "⚠️ Modèle IA non chargé. Veuillez d'abord charger le modèle depuis la barre latérale.",
+            "system_info_title": "🔧 Informations Système",
+            "model_stats_title": "📊 Statistiques du Modèle IA",
+            "model_status_loaded": "✅ Modèle chargé et fonctionnel",
+            "model_status_not_loaded": "❌ Modèle IA non chargé",
+            "model_type_label": "Type de modèle :",
+            "device_used_label": "Device utilisé :",
+            "load_time_label": "Heure de chargement :",
+            "reload_model_button": "🔄 Recharger le modèle",
+            "model_unloaded_info": "Modèle déchargé. Cliquez sur 'Charger le modèle IA' pour le recharger.",
+            "loading_model_spinner": "🔄 Chargement du modèle IA en cours...",
+            "analysis_in_progress_image": "🔍 Analyse d'image en cours...",
+            "analysis_in_progress_text": "🔍 Analyse textuelle en cours...",
+            "analysis_complete_success": "✅ Analyse terminée !",
+            "analysis_failed_error": "❌ Échec de l'analyse de l'image.",
+            "text_analysis_failed_error": "❌ Échec de l'analyse textuelle.",
+            "results_title": "📋 Résultats de l'analyse",
+            "sys_ram_total": "RAM Totale :",
+            "sys_ram_used": "RAM Utilisée :",
+            "sys_disk_free": "Espace Disque Libre (/) :",
+            "sys_gpu_detected": "GPU Détecté :",
+            "sys_gpu_total_mem": "Mémoire GPU Totale :",
+            "sys_gpu_not_available": "GPU : Non disponible (fonctionnement sur CPU)",
+            "sys_info_error": "Erreur lors de la récupération des informations système :",
+            "model_loading_error": "❌ Trop de tentatives de chargement ont échoué. Veuillez vérifier votre configuration et redémarrer l'application.",
+            "model_loading_hub_error": "❌ Échec du chargement du modèle depuis Hugging Face Hub : ",
+            "image_processing_error": "❌ Erreur lors du traitement du fichier uploadé : ",
+            "image_capture_processing_error": "❌ Erreur lors du traitement de l'image capturée : ",
+            "image_resized_info": "ℹ️ Image redimensionnée de {} à {} pour l'analyse.",
+            "choose_capture_method_label": "Choisissez votre méthode de capture :",
+            "webcam_instructions": "Positionnez votre plante malade devant la webcam et cliquez sur 'Prendre une photo'.",
+            "file_size_warning": "Le fichier est très volumineux. Il est recommandé d'utiliser des images de taille raisonnable pour une analyse plus rapide."
         },
         "en": {
             "title": "🌱 AgriLens AI - Plant Analysis Assistant",
@@ -125,76 +168,116 @@ def t(key):
             "config_title": "⚙️ Configuration & Information",
             "about_title": "ℹ️ About the Application",
             "load_model": "Load AI Model",
-            "model_status": "AI Model Status"
+            "model_status": "AI Model Status",
+            "upload_image_label": "📁 Upload Image",
+            "webcam_capture_label": "📷 Webcam Capture",
+            "image_analysis_options_title": "Analysis Options",
+            "analysis_type_full_diagnosis": "Full Diagnosis (disease, care, prevention)",
+            "analysis_type_disease_id": "Disease Identification and Diagnosis",
+            "analysis_type_care_advice": "Care and Maintenance Advice",
+            "custom_prompt_label": "Custom prompt (optional) :",
+            "analyze_image_button": "🔍 Analyze Image",
+            "analyze_text_button": "🔍 Analyze Description",
+            "model_not_loaded_warning": "⚠️ AI Model not loaded. Please load the model from the sidebar first.",
+            "system_info_title": "🔧 System Information",
+            "model_stats_title": "📊 AI Model Statistics",
+            "model_status_loaded": "✅ Model Loaded and Functional",
+            "model_status_not_loaded": "❌ AI Model Not Loaded",
+            "model_type_label": "Model Type:",
+            "device_used_label": "Device Used:",
+            "load_time_label": "Load Time:",
+            "reload_model_button": "🔄 Reload Model",
+            "model_unloaded_info": "Model unloaded. Click 'Load AI Model' to reload it.",
+            "loading_model_spinner": "🔄 Loading AI Model...",
+            "analysis_in_progress_image": "🔍 Analyzing image...",
+            "analysis_in_progress_text": "🔍 Analyzing text...",
+            "analysis_complete_success": "✅ Analysis complete!",
+            "analysis_failed_error": "❌ Image analysis failed.",
+            "text_analysis_failed_error": "❌ Text analysis failed.",
+            "results_title": "📋 Analysis Results",
+            "sys_ram_total": "Total RAM:",
+            "sys_ram_used": "RAM Used:",
+            "sys_disk_free": "Free Disk Space (/):",
+            "sys_gpu_detected": "GPU Detected:",
+            "sys_gpu_total_mem": "Total GPU Memory:",
+            "sys_gpu_not_available": "GPU: Not Available (CPU operation)",
+            "sys_info_error": "Error retrieving system information:",
+            "model_loading_error": "❌ Too many failed loading attempts. Please check your configuration and restart the application.",
+            "model_loading_hub_error": "❌ Failed to load model from Hugging Face Hub: ",
+            "image_processing_error": "❌ Error processing uploaded file: ",
+            "image_capture_processing_error": "❌ Error processing captured image: ",
+            "image_resized_info": "ℹ️ Image resized from {} to {} for analysis.",
+            "choose_capture_method_label": "Choose your capture method:",
+            "webcam_instructions": "Position your sick plant in front of the webcam and click 'Take Photo'.",
+            "file_size_warning": "The file is very large. It's recommended to use reasonably sized images for faster analysis."
         }
     }
     return translations[st.session_state.language].get(key, key)
 
-# Fonctions de chargement et d'analyse du modèle
+# --- Fonctions de chargement et d'analyse du modèle ---
 MODEL_ID_HF = "google/gemma-3n-E4B-it" # ID du modèle sur Hugging Face Hub
 
 def get_device_map():
     """Détermine si le modèle doit être chargé sur GPU ou CPU."""
     if torch.cuda.is_available():
         st.session_state.device = "cuda"
-        return "auto"
+        return "auto" # Laisse transformers décider de la meilleure répartition
     else:
         st.session_state.device = "cpu"
         return "cpu"
 
-def load_model():
+@st.cache_resource # Utilisation du cache Streamlit pour le modèle
+def load_model_and_processor():
     """
     Charge le modèle Gemma 3n et son processeur associé depuis Hugging Face Hub.
     Gère les erreurs et les tentatives de chargement.
     """
-    try:
-        if st.session_state.load_attempt_count >= 3:
-            st.error("❌ Trop de tentatives de chargement ont échoué. Veuillez vérifier votre configuration et redémarrer l'application.")
-            return None, None
-
-        st.session_state.load_attempt_count += 1
-        st.info("🔍 Diagnostic de l'environnement avant chargement...")
-        issues = diagnose_loading_issues()
-        if issues:
-            with st.expander("📊 Diagnostic système", expanded=False):
-                for issue in issues:
-                    st.write(issue)
-
-        gc.collect()
-        if torch.cuda.is_available():
-            torch.cuda.empty_cache()
-        device_map = get_device_map()
+    if st.session_state.load_attempt_count >= 3:
+        st.error(t("model_loading_error"))
+        return None, None
 
-        try:
-            st.info(f"Chargement du modèle depuis Hugging Face Hub : {MODEL_ID_HF}...")
-            processor = AutoProcessor.from_pretrained(MODEL_ID_HF, trust_remote_code=True)
-            model = Gemma3nForConditionalGeneration.from_pretrained(
-                MODEL_ID_HF,
-                torch_dtype=torch.bfloat16 if device_map == "auto" else torch.float32,
-                trust_remote_code=True,
-                low_cpu_mem_usage=True,
-                device_map=device_map
-            )
-            st.success(f"✅ Modèle chargé avec succès depuis Hugging Face Hub ({MODEL_ID_HF}).")
-            st.session_state.model_status = "Chargé (Hub)"
+    st.session_state.load_attempt_count += 1
+    st.info("🔍 Diagnostic de l'environnement avant chargement...")
+    issues = diagnose_loading_issues()
+    if issues:
+        with st.expander("📊 Diagnostic système", expanded=False):
+            for issue in issues:
+                st.write(issue)
 
-            st.session_state.model = model
-            st.session_state.processor = processor
-            st.session_state.model_loaded = True
-            st.session_state.model_load_time = time.time()
-            st.session_state.load_attempt_count = 0
+    gc.collect() # Nettoyage de la mémoire
+    if torch.cuda.is_available():
+        torch.cuda.empty_cache() # Vide le cache GPU
 
-            return model, processor
+    device_map = get_device_map()
 
-        except Exception as e:
-            st.error(f"❌ Échec du chargement du modèle depuis Hugging Face Hub : {e}")
-            return None, None
+    try:
+        st.info(f"Chargement du modèle depuis Hugging Face Hub : `{MODEL_ID_HF}`...")
+
+        # Configuration du torch_dtype pour une meilleure efficacité sur GPU
+        torch_dtype = torch.bfloat16 if st.session_state.device == "cuda" else torch.float32
+
+        processor = AutoProcessor.from_pretrained(MODEL_ID_HF, trust_remote_code=True)
+        model = Gemma3nForConditionalGeneration.from_pretrained(
+            MODEL_ID_HF,
+            torch_dtype=torch_dtype,
+            trust_remote_code=True,
+            low_cpu_mem_usage=True, # Tente de réduire l'utilisation CPU pendant le chargement
+            device_map=device_map
+        )
+
+        st.success(f"✅ Modèle `{MODEL_ID_HF}` chargé avec succès depuis Hugging Face Hub.")
+        st.session_state.model_status = "Chargé (Hub)"
+        st.session_state.model_loaded = True
+        st.session_state.model_load_time = time.time()
+        st.session_state.load_attempt_count = 0 # Réinitialise le compteur si succès
+
+        return model, processor
 
-    except ImportError:
-        st.error("❌ Erreur : Les bibliothèques `transformers` ou `torch` ne sont pas installées.")
+    except ImportError as e:
+        st.error(f"❌ Erreur : Les bibliothèques `transformers` ou `torch` ne sont pas installées. Détails: {e}")
         return None, None
     except Exception as e:
-        st.error(f"❌ Erreur générale lors du chargement du modèle : {e}")
+        st.error(f"{t('model_loading_hub_error')} {e}")
         return None, None
 
 def analyze_image_multilingual(image, prompt_text=""):
@@ -203,15 +286,16 @@ def analyze_image_multilingual(image, prompt_text=""):
     Retourne le résultat de l'analyse.
     """
     if not st.session_state.model_loaded or not check_model_health():
-        st.error("❌ Modèle IA non chargé ou non fonctionnel. Veuillez le charger via la barre latérale.")
+        st.error(t("model_not_loaded_warning"))
         return None
 
     try:
         if image.mode != 'RGB':
             image = image.convert('RGB')
 
-        if not prompt_text:
-            prompt_text = """<image>
+        if not prompt_text: # Utilisation des prompts par défaut basés sur la langue
+            if st.session_state.language == "fr":
+                prompt_text = """<image>
 Analyse cette image de plante et fournis un diagnostic complet :
 1. **État général de la plante :** Décris son apparence globale et sa vitalité.
 2. **Identification des problèmes :** Liste les maladies, parasites ou carences visibles.
@@ -220,7 +304,18 @@ Analyse cette image de plante et fournis un diagnostic complet :
 5. **Recommandations de traitement :** Propose des solutions concrètes et adaptées.
 6. **Conseils préventifs :** Donne des astuces pour éviter que le problème ne revienne.
 Réponds de manière structurée et claire en français."""
-
+            else: # English
+                prompt_text = """<image>
+Analyze this plant image and provide a comprehensive diagnosis:
+1. **Overall Plant Health:** Describe its general appearance and vitality.
+2. **Problem Identification:** List visible diseases, pests, or deficiencies.
+3. **Probable Diagnosis:** Indicate the most likely disease or problem.
+4. **Possible Causes:** Explain what might have caused this issue.
+5. **Treatment Recommendations:** Propose concrete and appropriate solutions.
+6. **Preventive Advice:** Give tips to avoid the problem from recurring.
+Respond in a structured and clear manner in English."""
+
+        # Assure que le prompt commence par <image> si ce n'est pas déjà le cas
         if "<image>" not in prompt_text:
             prompt_text = "<image>\n" + prompt_text
 
@@ -230,10 +325,12 @@ Réponds de manière structurée et claire en français."""
             return_tensors="pt"
         )
 
+        # Déplace les tenseurs sur le bon device
         inputs = {key: val.to(st.session_state.model.device) for key, val in inputs.items()}
 
-        with st.spinner("🔍 Analyse d'image en cours..."):
+        with st.spinner(t("analysis_in_progress_image")):
             input_len = inputs["input_ids"].shape[-1]
+            # Paramètres de génération ajustables si nécessaire
             outputs = st.session_state.model.generate(
                 **inputs,
                 max_new_tokens=512,
@@ -241,13 +338,13 @@ Réponds de manière structurée et claire en français."""
                 temperature=0.7,
                 top_p=0.9
             )
-            generation = outputs[0][input_len:]
+            generation = outputs[0][input_len:] # Garde uniquement les tokens générés
             response = st.session_state.processor.decode(generation, skip_special_tokens=True)
 
         return response.strip()
 
     except Exception as e:
-        st.error(f"❌ Erreur lors de l'analyse de l'image : {e}")
+        st.error(f"{t('analysis_failed_error')} {e}")
         return None
 
 def analyze_text_multilingual(text_description):
@@ -256,28 +353,44 @@ def analyze_text_multilingual(text_description):
     Retourne le diagnostic et les recommandations.
     """
     if not st.session_state.model_loaded or not check_model_health():
-        st.error("❌ Modèle IA non chargé ou non fonctionnel. Veuillez le charger via la barre latérale.")
+        st.error(t("model_not_loaded_warning"))
         return None
 
     try:
-        prompt = f"""Analyse la description des symptômes de cette plante et fournis un diagnostic détaillé :
+        # Définition du prompt en fonction de la langue sélectionnée
+        if st.session_state.language == "fr":
+            prompt = f"""Analyse la description des symptômes de cette plante et fournis un diagnostic détaillé :
 **Description des symptômes :**
-{text_description}
+
 **Instructions :**
 1. **Diagnostic probable :** Quel est le problème principal ?
 2. **Causes possibles :** Pourquoi ce problème survient-il ?
 3. **Traitement recommandé :** Comment le résoudre ?
 4. **Conseils préventifs :** Comment l'éviter à l'avenir ?
 Réponds en français de manière claire et structurée."""
+        else: # English
+            prompt = f"""Analyze the description of this plant's symptoms and provide a detailed diagnosis:
+**Symptoms Description:**
+
+**Instructions:**
+1. **Probable Diagnosis:** What is the main issue?
+2. **Possible Causes:** Why is this problem occurring?
+3. **Recommended Treatment:** How to resolve it?
+4. **Preventive Advice:** How to avoid it in the future?
+Respond in English in a clear and structured manner."""
+
+        # Ajoute la description de l'utilisateur au prompt
+        full_prompt = prompt + "\n\n" + text_description
 
         inputs = st.session_state.processor(
-            text=prompt,
+            text=full_prompt,
             return_tensors="pt"
         )
 
+        # Déplace les tenseurs sur le bon device
         inputs = {key: val.to(st.session_state.model.device) for key, val in inputs.items()}
 
-        with st.spinner("🔍 Analyse textuelle en cours..."):
+        with st.spinner(t("analysis_in_progress_text")):
             outputs = st.session_state.model.generate(
                 **inputs,
                 max_new_tokens=512,
@@ -285,28 +398,29 @@ Réponds en français de manière claire et structurée."""
                 temperature=0.7,
                 top_p=0.9
             )
+            response = st.session_state.processor.decode(outputs[0], skip_special_tokens=True)
 
-        response = st.session_state.processor.decode(outputs[0], skip_special_tokens=True)
-
-        if prompt.strip() in response:
-            response_only = response.split(prompt.strip())[-1].strip()
+        # Nettoie le prompt du début de la réponse si le modèle l'inclut
+        if full_prompt.strip() in response:
+            response_only = response.split(full_prompt.strip())[-1].strip()
         else:
             response_only = response.strip()
 
         return response_only
 
     except Exception as e:
-        st.error(f"❌ Erreur lors de l'analyse textuelle : {e}")
+        st.error(f"{t('text_analysis_failed_error')} {e}")
         return None
 
-# Interface Utilisateur Streamlit
+# --- Interface Utilisateur Streamlit ---
 st.title(t("title"))
 st.markdown(t("subtitle"))
 
-# Barre Latérale (Sidebar) pour la Configuration
+# --- Barre Latérale (Sidebar) pour la Configuration ---
 with st.sidebar:
     st.header(t("config_title"))
 
+    # Sélection de la langue
     lang_selector_options = ["Français", "English"]
     current_lang_index = 0 if st.session_state.language == "fr" else 1
     language_selected = st.selectbox(
@@ -319,47 +433,54 @@ with st.sidebar:
 
     st.divider()
 
+    # Statut du Modèle IA et Bouton de chargement
     st.header(t("model_status"))
-
     if st.session_state.model_loaded and check_model_health():
-        st.success("✅ Modèle chargé et fonctionnel")
-        st.write(f"**Statut :** `{st.session_state.model_status}`")
+        st.success(t("model_status_loaded"))
+        st.write(f"**{t('model_type_label')}** `{st.session_state.model_status}`")
         if st.session_state.model_load_time:
             load_time_str = time.strftime('%H:%M:%S', time.localtime(st.session_state.model_load_time))
-            st.write(f"**Heure de chargement :** {load_time_str}")
+            st.write(f"**{t('load_time_label')}** `{load_time_str}`")
 
-        if st.button("🔄 Recharger le modèle", type="secondary"):
+        if st.button(t("reload_model_button"), type="secondary"):
             st.session_state.model_loaded = False
             st.session_state.model = None
             st.session_state.processor = None
             st.session_state.model_status = "Non chargé"
             st.session_state.load_attempt_count = 0
-            st.info("Modèle déchargé. Cliquez sur 'Charger le modèle IA' pour le recharger.")
+            st.info(t("model_unloaded_info"))
+            st.rerun() # Recharge l'application pour appliquer le changement
     else:
-        st.warning("⚠️ Modèle IA non chargé")
+        st.warning(t("model_status_not_loaded"))
 
         if st.button(t("load_model"), type="primary"):
-            with st.spinner("🔄 Chargement du modèle IA en cours..."):
-                model_loaded_success = load_model()
-                if model_loaded_success[0] is not None and model_loaded_success[1] is not None:
-                    st.success("✅ Modèle IA chargé avec succès !")
+            with st.spinner(t("loading_model_spinner")):
+                # Utilise la fonction cachée pour charger le modèle
+                model, processor = load_model_and_processor()
+                if model is not None and processor is not None:
+                    st.session_state.model = model
+                    st.session_state.processor = processor
+                    st.success(t("✅ Modèle IA chargé avec succès !")) # Message plus clair
                 else:
-                    st.error("❌ Échec du chargement du modèle IA.")
+                    st.error(t("❌ Échec du chargement du modèle IA."))
+                st.rerun() # Recharge pour mettre à jour l'UI
 
     st.divider()
-    st.subheader("📊 Ressources Système")
+    # Affichage des ressources système
+    st.subheader(t("system_info_title"))
     afficher_ram_disponible()
     if torch.cuda.is_available():
         try:
             gpu_memory = torch.cuda.memory_allocated(0) / (1024**3)
             gpu_total = torch.cuda.get_device_properties(0).total_memory / (1024**3)
-            st.write(f"🚀 GPU actuel : {gpu_memory:.1f}GB / {gpu_total:.1f}GB")
+            st.write(f"🚀 {t('sys_gpu_detected')}: {torch.cuda.get_device_name(0)}")
+            st.write(f"📊 {t('sys_gpu_total_mem')}: {gpu_total:.1f} GB")
         except Exception as e:
-            st.write(f"🚀 Erreur lors de la récupération des informations GPU : {e}")
+            st.write(f"🚀 {t('sys_gpu_detected')}: Erreur lors de la récupération des informations GPU : {e}")
     else:
-        st.write("🚀 GPU : Non disponible (utilisation CPU)")
+        st.write(f"🚀 {t('sys_gpu_not_available')}")
 
-# Onglets Principaux
+# --- Onglets Principaux ---
 tab1, tab2, tab3, tab4 = st.tabs(t("tabs"))
 
 with tab1:
@@ -367,9 +488,8 @@ with tab1:
     st.markdown(t("image_analysis_desc"))
 
     capture_option = st.radio(
-        "Choisissez votre méthode de capture :",
-        ["📁 Upload d'image" if st.session_state.language == "fr" else "📁 Upload Image",
-         "📷 Capture par webcam" if st.session_state.language == "fr" else "📷 Webcam Capture"],
+        t("choose_capture_method_label"),
+        [t("upload_image_label"), t("webcam_capture_label")],
         horizontal=True,
         key="image_capture_method"
     )
@@ -377,98 +497,102 @@ with tab1:
     uploaded_file = None
     captured_image = None
 
-    if capture_option == ("📁 Upload d'image" if st.session_state.language == "fr" else "📁 Upload Image"):
+    if capture_option == t("upload_image_label"):
         uploaded_file = st.file_uploader(
             t("choose_image"),
             type=['png', 'jpg', 'jpeg'],
-            help="Formats acceptés : PNG, JPG, JPEG (taille max recommandée : 10MB)."
+            help="Formats acceptés : PNG, JPG, JPEG (taille max : 10MB).",
+            max_upload_size=10 # Limite à 10MB
         )
         if uploaded_file is not None and uploaded_file.size > 10 * 1024 * 1024:
-            st.warning("Le fichier est très volumineux. Il est recommandé d'utiliser des images de taille raisonnable pour une analyse plus rapide.")
-    else:
-        st.markdown("**📷 Capture d'image par webcam**")
-        st.info("Positionnez votre plante malade devant la webcam et cliquez sur 'Prendre une photo'.")
-        captured_image = st.camera_input("Prendre une photo de la plante")
+            st.warning(t("file_size_warning"))
+    else: # Webcam Capture
+        st.markdown(t("webcam_instructions"))
+        captured_image = st.camera_input(t("take_photo_label")) # Ajout d'une étiquette pour la caméra
 
     image_to_analyze = None
     if uploaded_file is not None:
         try:
             image_to_analyze = Image.open(uploaded_file)
         except Exception as e:
-            st.error(f"❌ Erreur lors du traitement du fichier uploadé : {e}")
+            st.error(f"{t('image_processing_error')} {e}")
     elif captured_image is not None:
         try:
             image_to_analyze = Image.open(captured_image)
         except Exception as e:
-            st.error(f"❌ Erreur lors du traitement de l'image capturée : {e}")
+            st.error(f"{t('image_capture_processing_error')} {e}")
 
     if image_to_analyze is not None:
-        original_size = image_to_analyze.size
         resized_image, was_resized = resize_image_if_needed(image_to_analyze)
 
         col1, col2 = st.columns([1, 1])
         with col1:
-            st.image(resized_image, caption="Image à analyser", use_container_width=True)
+            st.image(resized_image, caption=t("image_to_analyze_caption"), use_container_width=True) # Caption pour l'image
             if was_resized:
-                st.info(f"ℹ️ Image redimensionnée de {original_size} à {resized_image.size} pour l'analyse.")
+                st.info(t("image_resized_info").format(resized_image.size)) # Utilise la clé pour le message
 
         with col2:
             if st.session_state.model_loaded and check_model_health():
-                st.subheader("Options d'analyse")
+                st.subheader(t("image_analysis_options_title"))
+
+                # Définition des options d'analyse basée sur la langue
+                analysis_options = [
+                    t("analysis_type_full_diagnosis"),
+                    t("analysis_type_disease_id"),
+                    t("analysis_type_care_advice")
+                ]
                 analysis_type = st.selectbox(
-                    "Type d'analyse souhaitée :",
-                    [
-                        "Diagnostic complet (maladie, soins, prévention)" if st.session_state.language == "fr" else "Full Diagnosis (disease, care, prevention)",
-                        "Identification et diagnostic de maladies" if st.session_state.language == "fr" else "Disease Identification and Diagnosis",
-                        "Conseils de soins et d'entretien" if st.session_state.language == "fr" else "Care and Maintenance Advice"
-                    ],
+                    t("analysis_type_label"), # Ajout d'une clé pour le label du selectbox
+                    analysis_options,
                     key="image_analysis_type_selector"
                 )
 
                 custom_prompt_input = st.text_area(
-                    "Prompt personnalisé (optionnel) :",
+                    t("custom_prompt_label"),
                     value="",
                     height=100,
-                    placeholder="Entrez une requête spécifique ici si besoin..."
+                    placeholder=t("custom_prompt_placeholder") # Placeholder pour le prompt
                 )
 
-                if st.button("🔍 Analyser l'image", type="primary", key="analyze_image_button"):
+                if st.button(t("analyze_image_button"), type="primary", key="analyze_image_button"):
                     final_prompt = custom_prompt_input.strip()
+                    # Utilise la fonction `t` pour obtenir le prompt par défaut basé sur la langue
                     if not final_prompt:
-                        if analysis_type.startswith("Diagnostic complet"):
-                            final_prompt = """Analyse cette image de plante et fournis un diagnostic complet :
-1. **État général de la plante :** Décris son apparence globale et sa vitalité.
-2. **Identification des problèmes :** Liste les maladies, parasites ou carences visibles.
-3. **Diagnostic probable :** Indique la maladie ou le problème le plus probable.
-4. **Causes possibles :** Explique ce qui a pu causer ce problème.
-5. **Recommandations de traitement :** Propose des solutions concrètes et adaptées.
-6. **Conseils préventifs :** Donne des astuces pour éviter que le problème ne revienne.
-Réponds de manière structurée et claire en français."""
-                        elif analysis_type.startswith("Identification et diagnostic de maladies"):
-                            final_prompt = """Diagnostique cette plante en te concentrant sur les maladies et parasites :
-1. Identifie les symptômes visuels spécifiques aux maladies ou parasites.
-2. Détermine la maladie ou le parasite le plus probable.
-3. Explique les conditions favorisant leur développement.
-4. Propose des traitements ciblés et des méthodes de lutte.
-Réponds en français de manière structurée."""
-                        else:
-                            final_prompt = """Analyse cette plante et donne des conseils de soins détaillés :
-1. État général de la plante : Évalue sa santé actuelle.
-2. Besoins spécifiques : Précise ses besoins en eau, lumière, nutriments et substrat.
-3. Conseils d'entretien : Donne des instructions pour l'arrosage, la fertilisation et la taille.
-4. Améliorations recommandées : Suggère des actions pour optimiser sa croissance et sa santé.
-Réponds en français de manière structurée."""
+                        if analysis_type == t("analysis_type_full_diagnosis"):
+                            default_prompt_key = "default_prompt_full_diagnosis"
+                        elif analysis_type == t("analysis_type_disease_id"):
+                            default_prompt_key = "default_prompt_disease_id"
+                        else: # Care Advice
+                            default_prompt_key = "default_prompt_care_advice"
+
+                        # Fonction pour obtenir les prompts par défaut en fonction de la langue
+                        def get_default_prompt(lang, key):
+                            prompts = {
+                                "fr": {
+                                    "default_prompt_full_diagnosis": "<image>\nAnalyse cette image de plante et fournis un diagnostic complet :\n1. **État général de la plante :** Décris son apparence globale et sa vitalité.\n2. **Identification des problèmes :** Liste les maladies, parasites ou carences visibles.\n3. **Diagnostic probable :** Indique la maladie ou le problème le plus probable.\n4. **Causes possibles :** Explique ce qui a pu causer ce problème.\n5. **Recommandations de traitement :** Propose des solutions concrètes et adaptées.\n6. **Conseils préventifs :** Donne des astuces pour éviter que le problème ne revienne.\nRéponds de manière structurée et claire en français.",
+                                    "default_prompt_disease_id": "<image>\nDiagnostique cette plante en te concentrant sur les maladies et parasites :\n1. Identifie les symptômes visuels spécifiques aux maladies ou parasites.\n2. Détermine la maladie ou le parasite le plus probable.\n3. Explique les conditions favorisant leur développement.\n4. Propose des traitements ciblés et des méthodes de lutte.\nRéponds en français de manière structurée.",
+                                    "default_prompt_care_advice": "<image>\nAnalyse cette plante et donne des conseils de soins détaillés :\n1. État général de la plante : Évalue sa santé actuelle.\n2. Besoins spécifiques : Précise ses besoins en eau, lumière, nutriments et substrat.\n3. Conseils d'entretien : Donne des instructions pour l'arrosage, la fertilisation et la taille.\n4. Améliorations recommandées : Suggère des actions pour optimiser sa croissance et sa santé.\nRéponds en français de manière structurée."
+                                },
+                                "en": {
+                                    "default_prompt_full_diagnosis": "<image>\nAnalyze this plant image and provide a comprehensive diagnosis:\n1. **Overall Plant Health:** Describe its general appearance and vitality.\n2. **Problem Identification:** List visible diseases, pests, or deficiencies.\n3. **Probable Diagnosis:** Indicate the most likely disease or problem.\n4. **Possible Causes:** Explain what might have caused this issue.\n5. **Treatment Recommendations:** Propose concrete and appropriate solutions.\n6. **Preventive Advice:** Give tips to avoid the problem from recurring.\nRespond in a structured and clear manner in English.",
+                                    "default_prompt_disease_id": "<image>\nDiagnose this plant focusing on diseases and pests:\n1. Identify visual symptoms specific to diseases or pests.\n2. Determine the most likely disease or pest.\n3. Explain the conditions that favor their development.\n4. Propose targeted treatments and control methods.\nRespond in a structured manner in English.",
+                                    "default_prompt_care_advice": "<image>\nAnalyze this plant and provide detailed care advice:\n1. Overall plant condition: Assess its current health.\n2. Specific needs: Specify its requirements for water, light, nutrients, and substrate.\n3. Maintenance tips: Give instructions for watering, fertilizing, and pruning.\n4. Recommended improvements: Suggest actions to optimize its growth and health.\nRespond in a structured manner in English."
+                                }
+                            }
+                            return prompts[lang].get(key, key) # Retourne la clé si non trouvée
+
+                        final_prompt = get_default_prompt(st.session_state.language, default_prompt_key)
 
                     analysis_result = analyze_image_multilingual(resized_image, prompt_text=final_prompt)
 
                     if analysis_result:
-                        st.success("✅ Analyse terminée !")
-                        st.markdown("### 📋 Résultats de l'analyse")
+                        st.success(t("analysis_complete_success"))
+                        st.markdown(f"### {t('results_title')}")
                         st.markdown(analysis_result)
                     else:
-                        st.error("❌ Échec de l'analyse de l'image.")
+                        st.error(t("analysis_failed_error"))
             else:
-                st.warning("⚠️ Modèle IA non chargé. Veuillez d'abord charger le modèle depuis la barre latérale.")
+                st.warning(t("model_not_loaded_warning"))
 
 with tab2:
     st.header(t("text_analysis_title"))
@@ -477,24 +601,24 @@ with tab2:
     text_description_input = st.text_area(
         t("enter_description"),
         height=200,
-        placeholder="Décrivez ici les symptômes observés sur votre plante : feuilles jaunes, taches, flétrissement, présence d'insectes, etc."
+        placeholder=t("enter_description_placeholder") # Placeholder pour la description
     )
 
-    if st.button("🔍 Analyser la description", type="primary", key="analyze_text_button"):
+    if st.button(t("analyze_text_button"), type="primary", key="analyze_text_button"):
         if text_description_input.strip():
             if st.session_state.model_loaded and check_model_health():
                 analysis_result = analyze_text_multilingual(text_description_input)
 
                 if analysis_result:
-                    st.success("✅ Analyse terminée !")
-                    st.markdown("### 📋 Résultats de l'analyse")
+                    st.success(t("analysis_complete_success"))
+                    st.markdown(f"### {t('results_title')}")
                     st.markdown(analysis_result)
                 else:
-                    st.error("❌ Échec de l'analyse textuelle.")
+                    st.error(t("text_analysis_failed_error"))
             else:
-                st.warning("⚠️ Modèle IA non chargé. Veuillez d'abord charger le modèle depuis la barre latérale.")
+                st.warning(t("model_not_loaded_warning"))
         else:
-            st.warning("⚠️ Veuillez entrer une description des symptômes de votre plante.")
+            st.warning(t("please_enter_description_warning")) # Avertissement si pas de description
 
 with tab3:
     st.header(t("config_title"))
@@ -502,45 +626,42 @@ with tab3:
     col1, col2 = st.columns(2)
 
     with col1:
-        st.subheader("🔧 Informations Système")
-
+        st.subheader(t("system_info_title"))
         try:
             ram = psutil.virtual_memory()
-            st.write(f"**RAM Totale :** {ram.total / (1024**3):.1f} GB")
-            st.write(f"**RAM Utilisée :** {ram.used / (1024**3):.1f} GB ({ram.percent:.1f}%)")
+            st.write(f"**{t('sys_ram_total')}** {ram.total / (1024**3):.1f} GB")
+            st.write(f"**{t('sys_ram_used')}** {ram.used / (1024**3):.1f} GB ({ram.percent:.1f}%)")
 
             disk = psutil.disk_usage('/')
-            st.write(f"**Espace Disque Libre (/) :** {disk.free / (1024**3):.1f} GB")
+            st.write(f"**{t('sys_disk_free')}** {disk.free / (1024**3):.1f} GB")
 
             if torch.cuda.is_available():
-                st.write(f"**GPU Détecté :** {torch.cuda.get_device_name(0)}")
+                st.write(f"**{t('sys_gpu_detected')}** {torch.cuda.get_device_name(0)}")
                 gpu_props = torch.cuda.get_device_properties(0)
-                st.write(f"**Mémoire GPU Totale :** {gpu_props.total_memory / (1024**3):.1f} GB")
+                st.write(f"**{t('sys_gpu_total_mem')}** {gpu_props.total_memory / (1024**3):.1f} GB")
             else:
-                st.write("**GPU :** Non disponible (fonctionnement sur CPU)")
+                st.write(f"**{t('sys_gpu_not_available')}**")
         except Exception as e:
-            st.error(f"Erreur lors de la récupération des informations système : {e}")
+            st.error(f"{t('sys_info_error')} {e}")
 
     with col2:
-        st.subheader("📊 Statistiques du Modèle IA")
-
+        st.subheader(t("model_stats_title"))
         if st.session_state.model_loaded and check_model_health():
-            st.write("**Statut :** ✅ Chargé et fonctionnel")
+            st.write(f"**{t('model_status')}:** {t('model_status_loaded')}")
             if st.session_state.model is not None:
-                st.write(f"**Type de modèle :** `{type(st.session_state.model).__name__}`")
+                st.write(f"**{t('model_type_label')}** `{type(st.session_state.model).__name__}`")
                 if hasattr(st.session_state.model, 'device'):
-                    st.write(f"**Device utilisé :** `{st.session_state.model.device}`")
+                    st.write(f"**{t('device_used_label')}** `{st.session_state.model.device}`")
             if st.session_state.model_load_time:
                 load_time_str = time.strftime('%H:%M:%S', time.localtime(st.session_state.model_load_time))
-                st.write(f"**Heure de chargement :** {load_time_str}")
+                st.write(f"**{t('load_time_label')}** `{load_time_str}`")
         else:
-            st.write("**Statut :** ❌ Non chargé")
-            st.write("**Type de modèle :** N/A")
-            st.write("**Device utilisé :** N/A")
+            st.write(f"**{t('model_status')}:** {t('model_status_not_loaded')}")
+            st.write(f"**{t('model_type_label')}** N/A")
+            st.write(f"**{t('device_used_label')}** N/A")
 
 with tab4:
     st.header(t("about_title"))
-
     st.markdown("""
     ## 🌱 AgriLens AI : Votre Assistant d'Analyse de Plantes
     **AgriLens AI** est une application alimentée par l'intelligence artificielle qui vous aide à identifier les problèmes de vos plantes, à diagnostiquer les maladies et à obtenir des conseils de traitement personnalisés. Que vous soyez un jardinier débutant ou expérimenté, AgriLens AI est là pour vous accompagner.
@@ -550,10 +671,10 @@ with tab4:
     - **Recommandations Précises :** Recevez des conseils de traitement, des suggestions de soins et des mesures préventives adaptées à chaque situation.
     - **Support Multilingue :** L'interface et les réponses sont disponibles en français et en anglais pour une accessibilité maximale.
     ### 🤖 Technologie Utilisée :
-    - **Modèle IA :** Google Gemma 3n E4B IT, un modèle multimodal performant pour l'analyse de plantes.
+    - **Modèle IA :** Google Gemma 3n E4B IT, un modèle multimodal performant pour l'analyse de plantes. ([Voir sur Hugging Face](https://huggingface.co/google/gemma-3n-E4B-it))
     - **Bibliothèques :** `transformers`, `torch`, `streamlit`, `Pillow`, `psutil`, `requests`, `huggingface-hub`.
     ### 📝 Comment Utiliser AgriLens AI :
-    1. **Chargez le Modèle IA :** Dans la barre latérale, cliquez sur "Charger le Modèle IA". Attendez que le statut passe à "Chargé et fonctionnel".
+    1. **Chargez le Modèle IA :** Dans la barre latérale, cliquez sur "Charger le Modèle IA". Attendez que le statut passe à "Chargé et fonctionnel". Cela peut prendre quelques minutes.
     2. **Analysez votre Plante :**
         - **Via Image :** Allez à l'onglet "📸 Analyse d'Image". Uploadez une photo de votre plante ou utilisez votre webcam. Choisissez le type d'analyse et cliquez sur "Analyser l'image".
         - **Via Texte :** Allez à l'onglet "📝 Analyse de Texte". Décrivez les symptômes de votre plante dans la zone de texte et cliquez sur "Analyser la description".
@@ -565,13 +686,13 @@ with tab4:
     *Développé avec passion pour aider les jardiniers et amoureux des plantes à prendre soin de leurs cultures grâce à la puissance de l'IA.*
     """)
 
-# Pied de page
+# --- Pied de page ---
 st.divider()
 st.markdown("""
 <div style='text-align: center; color: #666;'>
-  🌱 AgriLens AI - Assistant d'Analyse de Plantes |
-  <a href='#' target='_blank'>Documentation</a> |
-  <a href='#' target='_blank'>Support</a> |
-  <a href='https://huggingface.co/google/gemma-3n-E4B-it' target='_blank'>Modèle Gemma 3n</a>
+ 🌱 AgriLens AI - Assistant d'Analyse de Plantes |
+ <a href='#' target='_blank'>Documentation</a> |
+ <a href='#' target='_blank'>Support</a> |
+ <a href='https://huggingface.co/google/gemma-3n-E4B-it' target='_blank'>Modèle Gemma 3n</a>
 </div>
 """, unsafe_allow_html=True)