Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,259 +1,487 @@
-# app.py
 import streamlit as st
+import requests
 import pandas as pd
+import re
+from datetime import datetime, timedelta
 import json
-import os
-import extract_codex # Importer le module d'extraction
+import plotly.express as px
+import plotly.graph_objects as go
+from bs4 import BeautifulSoup
+import time
 
 # Configuration de la page
 st.set_page_config(
     page_title="Moniteur Codex Alimentarius",
     page_icon="📋",
     layout="wide",
-    initial_sidebar_state="expanded",
+    initial_sidebar_state="expanded"
 )
 
-# Titre principal
-st.title("📋 Moniteur Codex Alimentarius")
-st.subheader("Analyse en temps réel des documents de sécurité alimentaire du Codex")
-
-# Initialisation de l'état de session
-if 'data_loaded' not in st.session_state:
-    st.session_state.data_loaded = False
-if 'all_documents_df' not in st.session_state:
-    st.session_state.all_documents_df = pd.DataFrame()
-if 'last_extraction_file' not in st.session_state:
-    st.session_state.last_extraction_file = None
+# URLs du Codex Alimentarius
+CODEX_URLS = {
+    'guidelines': {
+        'name': 'Directives (CXG)',
+        'url': 'https://www.fao.org/fao-who-codexalimentarius/codex-texts/guidelines/fr/',
+        'prefix': 'CXG'
+    },
+    'standards': {
+        'name': 'Normes (CXS)',
+        'url': 'https://www.fao.org/fao-who-codexalimentarius/codex-texts/list-standards/fr/',
+        'prefix': 'CXS'
+    },
+    'codes': {
+        'name': 'Codes de Pratique (CXC)',
+        'url': 'https://www.fao.org/fao-who-codexalimentarius/codex-texts/codes-of-practice/fr/',
+        'prefix': 'CXC'
+    },
+    'misc': {
+        'name': 'Documents Divers',
+        'url': 'https://www.fao.org/fao-who-codexalimentarius/codex-texts/miscellaneous/fr/',
+        'prefix': 'CXM'
+    }
+}
 
-# Barre latérale
-with st.sidebar:
-    st.header("Contrôles")
-    
-    # Bouton pour charger/exécuter l'extraction
-    if st.button("🔍 Charger/Actualiser les Données"):
-        with st.spinner("Extraction des données du site Codex Alimentarius..."):
-            extraction_file_path = extract_codex.run_extraction(output_dir="data")
-            if extraction_file_path and os.path.exists(extraction_file_path):
-                try:
-                    with open(extraction_file_path, 'r', encoding='utf-8') as f:
-                        data = json.load(f)
-                    
-                    # Transformer les données en DataFrame
-                    documents_list = []
-                    for category_key, docs in data.get("categories", {}).items():
-                        for doc in docs:
-                            doc['category_key'] = category_key
-                            # Ajouter un nom de catégorie lisible
-                            category_names = {
-                                "guidelines": "Directives (CXG)",
-                                "standards": "Normes (CXS)",
-                                "codes_of_practice": "Codes de Pratique (CXC)",
-                                "miscellaneous": "Divers (CXM)"
-                            }
-                            doc['category_name'] = category_names.get(category_key, category_key)
-                            doc['is_new'] = int(doc.get('year', 0)) >= 2023
-                            doc['is_2024'] = str(doc.get('year', '')) == '2024'
-                            documents_list.append(doc)
-                    
-                    if documents_list:
-                        df = pd.DataFrame(documents_list)
-                        # Trier par année décroissante, puis par code
-                        df['year'] = pd.to_numeric(df['year'], errors='coerce').fillna(0).astype(int)
-                        df = df.sort_values(by=['year', 'code'], ascending=[False, True]).reset_index(drop=True)
-                        
-                        st.session_state.all_documents_df = df
-                        st.session_state.data_loaded = True
-                        st.session_state.last_extraction_file = extraction_file_path
-                        st.success(f"✅ Données chargées avec succès depuis {extraction_file_path}!")
-                        st.experimental_rerun() # Recharger pour afficher les filtres
-                    else:
-                        st.error("❌ Aucun document n'a pu être extrait.")
-                except Exception as e:
-                    st.error(f"❌ Erreur lors du chargement des données extraites: {e}")
-            else:
-                st.error("❌ L'extraction a échoué ou le fichier n'a pas été créé.")
+@st.cache_data(ttl=3600)  # Cache pour 1 heure
+def extract_documents_from_url(url, category):
+    """Extrait les documents d'une page du Codex Alimentarius"""
+    try:
+        headers = {
+            'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36'
+        }
+        
+        response = requests.get(url, headers=headers, timeout=30)
+        response.raise_for_status()
+        
+        # Parser le HTML
+        soup = BeautifulSoup(response.content, 'html.parser')
+        
+        # Extraire le texte et chercher les patterns de documents
+        text = soup.get_text()
+        
+        # Pattern pour les documents: CODE | TITRE | COMITE | ANNEE | |
+        pattern = r'(CX[GSC][\w\-R]*\d+(?:-\d+)?)\s*\|\s*([^|]+?)\s*\|\s*([^|]+?)\s*\|\s*(\d{4})\s*\|'
+        
+        documents = []
+        matches = re.findall(pattern, text)
+        
+        for match in matches:
+            code, title, committee, year = match
+            documents.append({
+                'code': code.strip(),
+                'title': title.strip(),
+                'committee': committee.strip(),
+                'year': int(year),
+                'category': category,
+                'category_name': CODEX_URLS[category]['name'],
+                'is_new': int(year) >= 2023,
+                'is_2024': int(year) == 2024,
+                'source_url': url,
+                'extracted_at': datetime.now().isoformat()
+            })
+        
+        return documents
+        
+    except Exception as e:
+        st.error(f"Erreur lors de l'extraction de {CODEX_URLS[category]['name']}: {str(e)}")
+        return []
 
-    # Afficher le statut de chargement
-    if st.session_state.data_loaded:
-        st.success("Données chargées.")
-        if st.session_state.last_extraction_file:
-             st.info(f"Dernière extraction: {os.path.basename(st.session_state.last_extraction_file)}")
-    else:
-        st.info("Les données n'ont pas encore été chargées.")
+def parse_sample_data():
+    """Parse les données d'exemple intégrées"""
+    sample_guidelines = """CXG 105-2024 | Guidelines on the use of technology to provide food information in food labelling | CCFL | 2024 | |
+CXG 104-2024 | Guidelines on the provision of food information for pre-packaged foods to be offered via e-commerce | CCFL | 2024 | |
+CXG 103-2024 | Guidelines for food hygiene control measures in traditional markets for food | CCFH | 2024 | |
+CXG 100-2023 | Guidelines for the Safe Use and Reuse of Water in Food Production and Processing | CCFH | 2024 | |
+CXG 99-2023 | Directives pour la maîtrise des Escherichia coli producteurs de shiga-toxines (stec) dans le bœuf cru, les légumes-feuilles frais, le lait cru et les fromages au lait cru, ainsi que les graines germées | CCFH | 2024 | |
+CXG 36-1989 | Noms de catégorie et système international de numérotation des additifs alimentaires | CCFA | 2024 | |
+CXG 2-1985 | Directives concernant l'étiquetage nutritionnel | CCFL | 2024 | |
+CXG 101-2023 | Guidelines on Recognition and Maintenance of Equivalence of National Food Control Systems (NFCS) | CCFICS | 2023 | |
+CXG 102-2023 | Principles and Guidelines on the Use of Remote Audit and Inspection in Regulatory Frameworks | CCFICS | 2023 | |
+CXG 95-2022 | Lignes directrices pour les aliments thérapeutiques prêts à l'emploi | CCNFSDU | 2023 | |
+CXG 10-1979 | Listes consultatives d'éléments nutritifs utilisables dans les aliments diététiques ou de régime pour nourrissons et enfants en bas âge | CCNFSDU | 2023 | |
+CXG 50-2004 | Directives générales sur l'échantillonnage | CCMAS | 2023 | |
+CXG 38-2001 | Directives pour la conception, l'établissement, la délivrance et l'utilisation des certificats officiels génériques | CCFICS | 2021 | |
+CXG 77-2011 | Lignes directrices pour l'analyse des risques liés à la résistance aux antimicrobiens d'origine alimentaire | TFAMR | 2021 | |
+CXG 93-2021 | Principes et directives pour l'evaluation et l'utilisation de programmes volontaires d'assurance par des tiers | CCFICS | 2021 | |
+CXG 94-2021 | Directives sur le suivi et la surveillance intégrés de la résistance aux antimicrobiens d'origine alimentaire | TFAMR | 2021 | |
+CXG 96-2022 | Directives pour la gestion des épidémies biologiques d'origine alimentaire | CCFH | 2022 | |
+CXG 97-2022 | Guidelines for the Recognition of Active Substances or Authorized Uses of Active Substances of Low Public Health Concern that are Considered Exempted from the Establishment of Maximum Residue Limits or do not give rise to Residues | CCPR | 2022 | |
+CXG 98-2022 | Directives relatives à l'élaboration d'une législation harmonisée sur la sécurité sanitaire des aliments dans la région couverte par le Comité FAO/OMS de Coordination pour l'Afrique | CCAFRICA | 2022 | |
+CXG 87-2016 | Directives sur la maîtrise des salmonella spp. non typhiques dans la viande de boeuf et la viande de porc | CCFH | 2016 | |
+CXG 88-2016 | Directives pour l'application des principes généraux d'hygiène alimentaire à la maîtrise des parasites d'origine alimentaire | CCFH | 2016 | |
+CXG 89-2016 | Principes et directives sur l'échange d'informations entre des pays importateurs et exportateurs pour soutenir le commerce alimentaire | CCFICS | 2016 | |
+CXG 90-2017 | Directive sur les critères de performance pour les méthodes d'analyse en vue de la détermination des résidus de pesticides dans les produits destinés à l'alimentation humaine et animale | CCPR | 2017 | |
+CXG 91-2017 | Principes et directives pour le suivi des performances de systemes nationaux de controle des aliments | CCFICS | 2017 | |
+CXG 8-1991 | Lignes directrices pour la mise au point des préparations alimentaires complémentaires destinées aux nourrissons du deuxième âge et aux enfants en bas âge | CCNFSDU | 2017 | |
+CXG 84-2012 | Principes et directives pour la sélection de produits représentatifs en vue d'extrapolation de limites maximales de résidus de pesticides aux groupes de produits | CCPR | 2017 | |
+CXG 86-2015 | Directives sur la maîtrise des Trichinella Spp. dans la viande de suidés | CCFH | 2015 | |
+CXG 83-2013 | Principes régissant l'application des procédures d'échantillonnage et d'essai dans le commerce international des denrées alimentaires | CCMAS | 2015 | |
+CXG 82-2013 | Principes et directives concernant les systèmes nationaux de contrôle des aliments | CCFICS | 2013 | |
+CXG 21-1997 | Principes et directives pour l'établissement et l'application de critères microbiologiques relatifs aux aliments | CCFH | 2013 | |
+CXG 32-1999 | Directives concernant la production, la transformation, l'étiquetage et la commercialisation des aliments issus de l'agriculture biologique | CCFL | 2013 | |
+CXG 23-1997 | Directives pour l'emploi des allégations relatives à la nutrition et à la santé | CCFL | 2013 | |
+CXG 69-2008 | Directives relatives à la validation des mesures de maîtrise de la sécurite alimentaire | CCFH | 2013 | |"""
 
-    # Section pour exporter les données actuelles
-    st.markdown("---")
-    st.header("Exporter")
-    if st.session_state.data_loaded and not st.session_state.all_documents_df.empty:
-        json_data = st.session_state.all_documents_df.to_json(orient='records', date_format='iso')
-        st.download_button(
-            label="💾 Télécharger les données (JSON)",
-            data=json_data,
-            file_name=f"codex_data_{pd.Timestamp.now().strftime('%Y%m%d_%H%M%S')}.json",
-            mime='application/json'
-        )
-    else:
-        st.button("💾 Télécharger les données (JSON)", disabled=True)
+    sample_standards = """CXS 359-2024 | Standard for dried or dehydrated roots, rhizomes and bulbs – Turmeric | CCSCH | 2024 | |
+CXS 358-2024 | Standard for spices derived from dried or dehydrated fruits and berries - Allspice, juniper berry and star anise | CCSCH | 2024 | |
+CXS 357-2024 | Standard for spices derived from dried or dehydrated fruits and berries – Small cardamom | CCSCH | 2024 | |
+CXS 193-1995 | Norme générale pour les contaminants et les toxines présents dans les produits de consommation humaine et animale | CCCF | 2024 | |
+CXS 1-1985 | Norme générale pour l'étiquetage des denrées alimentaires préemballées | CCFL | 2024 | |
+CXS 283-1978 | Norme générale pour le fromage | CCMMP | 2024 | |
+CXS 192-1995 | Norme générale pour les additifs alimentaires | CCFA | 2024 | |
+CXS 72-1981 | Norme pour les préparations destinées aux nourrissons et les préparations données à des fins médicales spéciales aux nourrissons | CCNFSDU | 2024 | |
+CXS 66-1981 | Norme pour les olives de table | CCPFV | 2024 | |
+CXS 33-1981 | Norme pour les huiles d'olive et les huiles de grignons d'olive | CCFO | 2024 | |
+CXS 19-1981 | Norme pour les graisses et les huiles comestibles non visées par des normes individuelles | CCFO | 2024 | |
+CXS 240-2003 | Norme pour les produits aqueux a base de noix de coco – Lait de coco et crème de coco | CCPFV | 2024 | |
+CXS 288-1976 | Norme pour la crème et les crèmes préparées | CCMMP | 2024 | |
+CXS 115-1981 | Norme pour les cornichons (concombres) en conserve | CCPFV | 2024 | |
+CXS 256-1999 | Norme pour les matières grasses tartinables et les mélanges tartinables | CCFO | 2024 | |
+CXS 243-2003 | Norme pour les laits fermentés | CCMMP | 2024 | |
+CXS 247-2005 | Norme générale pour les jus et les nectars de fruits | CCPFV | 2024 | |
+CXS 296-2009 | Norme pour les confitures, gelées et marmelades | CCPFV | 2024 | |
+CXS 210-1999 | Norme pour les huiles végétales portant un nom spécifique | CCFO | 2024 | |
+CXS 211-1999 | Norme pour les graisses animales portant un nom spécifique | CCFO | 2024 | |
+CXS 329-2017 | Norme pour les huiles de poisson | CCFO | 2024 | |
+CXS 234-1999 | Méthodes d'analyse et d'échantillonnage recommandées | CCMAS | 2024 | |
+CXS 356R-2023 | Norme régionale sur le jus de noni fermenté | CCNASWP | 2023 | |
+CXS 354R-2023 | Norme régionale sur les produits à base de soja fermenté sous l'action de Bacillus spp. (Asia) | CCASIA | 2023 | |
+CXS 355R-2023 | Norme régionale sur le riz cuit enveloppé dans des feuilles | CCASIA | 2023 | |
+CXS 306-2023 | Norme pour la sauce au piment (sauce «chili») («piments forts») | CCPFV | 2023 | |
+CXS 294-2023 | Norme pour la pâte de soja fermentée au piment fort | CCPFV | 2023 | |
+CXS 151-1985 | Norme pour le gari | CCCPL | 2023 | |
+CXS 152-1985 | Norme pour la farine de blé | CCCPL | 2023 | |
+CXS 155-1985 | Norme pour la farine de maïs dégermé et le gruau de maïs dégermé | CCCPL | 2023 | |
+CXS 169-1989 | Norme pour le mil chandelle en grains entiers et décortiqués | CCCPL | 2023 | |
+CXS 172-1989 | Norme pour le sorgho en grains | CCCPL | 2023 | |
+CXS 173-1989 | Norme pour la farine de sorgho | CCCPL | 2023 | |
+CXS 176-1989 | Norme pour la farine comestible de manioc | CCCPL | 2023 | |
+CXS 178-1991 | Norme pour la semoule et farine de blé dur | CCCPL | 2023 | |
+CXS 38-1981 | Norme pour les champignons comestibles et produits dérivés | CCPFV | 2023 | |
+CXS 39-1981 | Norme pour les champignons comestibles séchés | CCPFV | 2023 | |
+CXS 60-1981 | Norme pour les framboises en conserve | CCPFV | 2023 | |
+CXS 131-1981 | Norme pour les pistaches non décortiquées | CCPFV | 2023 | |
+CXS 160-1987 | Norme pour le chutney de mangue | CCPFV | 2023 | |
+CXS 281-1971 | Norme pour les laits concentrés | CCMMP | 2023 | |
+CXS 282-1971 | Norme pour les laits concentrés sucrés | CCMMP | 2023 | |
+CXS 290-1995 | Norme pour la caséine alimentaire et produits dérivés | CCMMP | 2023 | |
+CXS 13-1981 | Norme pour les tomates en conserve | CCPFV | 2023 | |
+CXS 73-1981 | Norme pour les aliments diversifiés de l'enfance ("baby foods") | CCNFSDU | 2023 | |
+CXS 74-1981 | Norme pour les aliments transformés à base de céréales destinés aux nourrissons et enfants en bas âge | CCNFSDU | 2023 | |
+CXS 181-1991 | Norme pour les préparations alimentaires utilisées dans les régimes amaigrissants | CCNFSDU | 2023 | |
+CXS 203-1995 | Norme pour les préparations alimentaires utilisées dans les régimes amaigrissants à valeur énergétique très faible | CCNFSDU | 2023 | |
+CXS 348-2022 | Norme pour les oignons et les echalotes | CCFFV | 2022 | |
+CXS 349-2022 | Norme pour les baies | CCFFV | 2022 | |
+CXS 352-2022 | Norme pour les graines séchées – Noix de muscade | CCSCH | 2022 | |
+CXS 350R-2022 | Norme régionale sur la viande séchée | CCAFRICA | 2022 | |
+CXS 353-2022 | Norme pour le piment et le paprika séchés ou déshydratés | CCSCH | 2022 | |
+CXS 351-2022 | Standard for dried floral parts –saffron | CCSCH | 2022 | |
+CXS 342-2021 | Norme pour l'origan séché | CCSCH | 2022 | |
+CXS 343-2021 | Norme pour les racines, les rhizomes et les bulbes séchés : gingembre séché ou déshydraté | CCSCH | 2022 | |
+CXS 344-2021 | Norme pour les parties florales séchées: clous de girofle | CCSCH | 2022 | |
+CXS 345-2021 | Norme pour le basilic séché | CCSCH | 2022 | |
+CXS 347-2019 | Norme pour l'ail séché ou déshydraté | CCSCH | 2022 | |"""
 
-# Corps principal de l'application
-if not st.session_state.data_loaded or st.session_state.all_documents_df.empty:
-    st.info("🔍 Cliquez sur 'Charger/Actualiser les Données' dans la barre latérale pour commencer.")
-    st.write("L'application va extraire et analyser tous les documents disponibles des Directives, Normes, Codes de Pratique et Divers du Codex Alimentarius.")
-    
-    # Afficher les fichiers d'extraction précédents s'ils existent
-    data_dir = "data"
-    if os.path.exists(data_dir):
-        existing_files = [f for f in os.listdir(data_dir) if f.startswith("codex_data_") and f.endswith(".json")]
-        if existing_files:
-            st.markdown("---")
-            st.subheader("Chargements précédents")
-            st.write("Vous pouvez charger un fichier d'extraction précédent :")
-            selected_file = st.selectbox("Sélectionner un fichier :", [""] + sorted(existing_files, reverse=True))
-            if selected_file:
-                file_path = os.path.join(data_dir, selected_file)
-                if st.button(f"Charger {selected_file}"):
-                    try:
-                        with open(file_path, 'r', encoding='utf-8') as f:
-                            data = json.load(f)
-                        documents_list = []
-                        for category_key, docs in data.get("categories", {}).items():
-                            for doc in docs:
-                                doc['category_key'] = category_key
-                                category_names = {
-                                    "guidelines": "Directives (CXG)",
-                                    "standards": "Normes (CXS)",
-                                    "codes_of_practice": "Codes de Pratique (CXC)",
-                                    "miscellaneous": "Divers (CXM)"
-                                }
-                                doc['category_name'] = category_names.get(category_key, category_key)
-                                doc['is_new'] = int(doc.get('year', 0)) >= 2023
-                                doc['is_2024'] = str(doc.get('year', '')) == '2024'
-                                documents_list.append(doc)
-                        if documents_list:
-                            df = pd.DataFrame(documents_list)
-                            df['year'] = pd.to_numeric(df['year'], errors='coerce').fillna(0).astype(int)
-                            df = df.sort_values(by=['year', 'code'], ascending=[False, True]).reset_index(drop=True)
-                            st.session_state.all_documents_df = df
-                            st.session_state.data_loaded = True
-                            st.session_state.last_extraction_file = file_path
-                            st.success(f"✅ Données chargées depuis {selected_file}!")
-                            st.experimental_rerun()
-                        else:
-                             st.error("❌ Aucun document trouvé dans le fichier sélectionné.")
-                    except Exception as e:
-                        st.error(f"❌ Erreur lors du chargement du fichier {selected_file}: {e}")
+    documents = []
+    
+    # Parser les directives
+    for line in sample_guidelines.strip().split('\n'):
+        if '|' in line:
+            parts = line.split('|')
+            if len(parts) >= 4:
+                documents.append({
+                    'code': parts[0].strip(),
+                    'title': parts[1].strip(),
+                    'committee': parts[2].strip(),
+                    'year': int(parts[3].strip()),
+                    'category': 'guidelines',
+                    'category_name': 'Directives (CXG)',
+                    'is_new': int(parts[3].strip()) >= 2023,
+                    'is_2024': int(parts[3].strip()) == 2024,
+                    'source_url': CODEX_URLS['guidelines']['url'],
+                    'extracted_at': datetime.now().isoformat()
+                })
+    
+    # Parser les normes
+    for line in sample_standards.strip().split('\n'):
+        if '|' in line:
+            parts = line.split('|')
+            if len(parts) >= 4:
+                documents.append({
+                    'code': parts[0].strip(),
+                    'title': parts[1].strip(),
+                    'committee': parts[2].strip(),
+                    'year': int(parts[3].strip()),
+                    'category': 'standards',
+                    'category_name': 'Normes (CXS)',
+                    'is_new': int(parts[3].strip()) >= 2023,
+                    'is_2024': int(parts[3].strip()) == 2024,
+                    'source_url': CODEX_URLS['standards']['url'],
+                    'extracted_at': datetime.now().isoformat()
+                })
+    
+    return documents
 
-else:
-    df = st.session_state.all_documents_df.copy()
+def main():
+    # Header
+    st.title("📋 Moniteur Codex Alimentarius")
+    st.markdown("""
+    **Surveillance et analyse en temps réel des documents de sécurité alimentaire**
+    
+    Cette application extrait et analyse automatiquement les documents du Codex Alimentarius pour votre veille réglementaire en food safety.
+    """)
     
-    # Statistiques
-    st.subheader("Statistiques")
+    # Sidebar
+    st.sidebar.header("🎛️ Configuration")
+    
+    # Option de source de données
+    data_source = st.sidebar.radio(
+        "Source des données:",
+        ["Données d'exemple", "Extraction en temps réel"]
+    )
+    
+    # Bouton de chargement
+    if st.sidebar.button("🔄 Charger les données", type="primary"):
+        with st.spinner("Chargement des données..."):
+            if data_source == "Données d'exemple":
+                st.session_state.documents = parse_sample_data()
+                st.success(f"✅ {len(st.session_state.documents)} documents d'exemple chargés!")
+            else:
+                # Extraction en temps réel
+                all_documents = []
+                progress_bar = st.progress(0)
+                
+                for i, (category, info) in enumerate(CODEX_URLS.items()):
+                    st.info(f"Extraction des {info['name']}...")
+                    documents = extract_documents_from_url(info['url'], category)
+                    all_documents.extend(documents)
+                    progress_bar.progress((i + 1) / len(CODEX_URLS))
+                    time.sleep(1)  # Pause pour éviter de surcharger le serveur
+                
+                st.session_state.documents = all_documents
+                st.success(f"✅ {len(all_documents)} documents extraits en temps réel!")
+    
+    # Vérifier si on a des données
+    if 'documents' not in st.session_state:
+        st.info("👆 Utilisez le panneau latéral pour charger les données")
+        return
+    
+    df = pd.DataFrame(st.session_state.documents)
+    
+    if df.empty:
+        st.warning("Aucun document trouvé")
+        return
+    
+    # Statistiques principales
     col1, col2, col3, col4 = st.columns(4)
-    col1.metric("Documents Total", len(df))
-    col2.metric("Nouveaux (2023+)", len(df[df['is_new']]))
-    col3.metric("Mis à jour en 2024", len(df[df['is_2024']]))
-    col4.metric("Comités Actifs", df['committee'].nunique())
-
+    
+    with col1:
+        st.metric("📊 Total Documents", len(df))
+    
+    with col2:
+        new_docs = len(df[df['is_new']])
+        st.metric("🆕 Nouveaux (2023+)", new_docs)
+    
+    with col3:
+        docs_2024 = len(df[df['is_2024']])
+        st.metric("📅 Mis à jour 2024", docs_2024)
+    
+    with col4:
+        committees = df['committee'].nunique()
+        st.metric("🏢 Comités Actifs", committees)
+    
+    st.divider()
+    
     # Filtres
-    st.markdown("---")
-    st.subheader("Filtres")
-    
-    col_filter1, col_filter2, col_filter3, col_filter4 = st.columns(4)
-    
-    with col_filter1:
-        search_term = st.text_input("🔍 Recherche (Titre, Code, Comité)", "")
-    with col_filter2:
-        category_options = ["Toutes les catégories"] + sorted(df['category_name'].unique())
-        selected_category = st.selectbox("Catégorie", category_options)
-    with col_filter3:
-        year_options = ["Toutes les années"] + sorted(df['year'].unique(), reverse=True)
-        selected_year = st.selectbox("Année", year_options)
-    with col_filter4:
-        new_options = ["Tous", "Nouveaux seulement (2023+)", "Mis à jour en 2024"]
-        selected_new = st.selectbox("Nouveaux documents", new_options)
-
-    # Appliquer les filtres
+    st.sidebar.header("🔍 Filtres")
+    
+    # Filtre par catégorie
+    categories = ['Toutes'] + list(df['category_name'].unique())
+    selected_category = st.sidebar.selectbox("Catégorie:", categories)
+    
+    # Filtre par année
+    years = ['Toutes'] + sorted(df['year'].unique(), reverse=True)
+    selected_year = st.sidebar.selectbox("Année:", years)
+    
+    # Filtre par comité
+    committees = ['Tous'] + sorted(df['committee'].unique())
+    selected_committee = st.sidebar.selectbox("Comité:", committees)
+    
+    # Filtre par nouveauté
+    filter_new = st.sidebar.checkbox("Seulement les nouveaux documents (2023+)")
+    filter_2024 = st.sidebar.checkbox("Seulement les mises à jour 2024")
+    
+    # Recherche textuelle
+    search_term = st.sidebar.text_input("🔍 Recherche dans les titres:")
+    
+    # Application des filtres
     filtered_df = df.copy()
-    if search_term:
-        mask = (
-            filtered_df['title'].str.contains(search_term, case=False, na=False) |
-            filtered_df['code'].str.contains(search_term, case=False, na=False) |
-            filtered_df['committee'].str.contains(search_term, case=False, na=False)
-        )
-        filtered_df = filtered_df[mask]
-    if selected_category != "Toutes les catégories":
+    
+    if selected_category != 'Toutes':
         filtered_df = filtered_df[filtered_df['category_name'] == selected_category]
-    if selected_year != "Toutes les années":
-        filtered_df = filtered_df[filtered_df['year'] == int(selected_year)]
-    if selected_new == "Nouveaux seulement (2023+)":
+    
+    if selected_year != 'Toutes':
+        filtered_df = filtered_df[filtered_df['year'] == selected_year]
+    
+    if selected_committee != 'Tous':
+        filtered_df = filtered_df[filtered_df['committee'] == selected_committee]
+    
+    if filter_new:
         filtered_df = filtered_df[filtered_df['is_new']]
-    elif selected_new == "Mis à jour en 2024":
+    
+    if filter_2024:
         filtered_df = filtered_df[filtered_df['is_2024']]
-
-    # Tri
-    st.markdown("---")
-    st.subheader("Documents")
-    sort_options = {
-        "Année (Décroissante)": ['year', False],
-        "Année (Croissante)": ['year', True],
-        "Code": ['code', True],
-        "Titre": ['title', True],
-        "Comité": ['committee', True]
-    }
-    selected_sort = st.selectbox("Trier par :", list(sort_options.keys()))
-    sort_col, ascending = sort_options[selected_sort]
-    # Pour le tri sur 'title' et 'committee', pandas triera par ordre lexicographique
-    filtered_df = filtered_df.sort_values(by=[sort_col], ascending=ascending).reset_index(drop=True)
-
-
-    # Affichage des documents
-    if filtered_df.empty:
-        st.info("🔍 Aucun document trouvé pour les critères sélectionnés.")
-    else:
-        # Afficher le nombre de résultats
-        st.write(f"Affichage de {len(filtered_df)} document(s) sur {len(df)}.")
-        
-        # Utiliser st.dataframe pour un affichage interactif
-        # Ou créer une liste personnalisée comme dans l'HTML
+    
+    if search_term:
+        filtered_df = filtered_df[
+            filtered_df['title'].str.contains(search_term, case=False, na=False) |
+            filtered_df['code'].str.contains(search_term, case=False, na=False)
+        ]
+    
+    # Graphiques
+    tab1, tab2, tab3 = st.tabs(["📋 Documents", "📊 Analyses", "💾 Export"])
+    
+    with tab1:
+        st.header(f"📋 Documents ({len(filtered_df)} résultats)")
         
-        # Option 1: st.dataframe (simple mais moins personnalisé)
-        # st.dataframe(filtered_df[['code', 'title', 'committee', 'year', 'category_name']])
+        if not filtered_df.empty:
+            # Trier par année décroissante puis par code
+            filtered_df = filtered_df.sort_values(['year', 'code'], ascending=[False, True])
+            
+            for _, doc in filtered_df.iterrows():
+                with st.container():
+                    col1, col2 = st.columns([4, 1])
+                    
+                    with col1:
+                        # Badges
+                        badges = f"**{doc['code']}** "
+                        if doc['is_new']:
+                            badges += "🆕 `NOUVEAU` "
+                        if doc['is_2024']:
+                            badges += "📅 `2024` "
+                        badges += f"`{doc['category_name']}`"
+                        
+                        st.markdown(badges)
+                        st.markdown(f"**{doc['title']}**")
+                        st.caption(f"🏢 {doc['committee']} • 📅 {doc['year']}")
+                    
+                    with col2:
+                        st.link_button("🔗 Voir Section", doc['source_url'])
+                    
+                    st.divider()
+        else:
+            st.info("Aucun document ne correspond aux critères sélectionnés")
+    
+    with tab2:
+        st.header("📊 Analyses des Documents")
         
-        # Option 2: Affichage personnalisé (similaire à l'HTML)
-        for index, row in filtered_df.iterrows():
-            # Déterminer les badges
-            badges = []
-            if row['is_new']:
-                badges.append("🆕 Nouveau")
-            if row['is_2024']:
-                badges.append("📅 2024")
-            badges.append(f"📁 {row['category_name']}")
+        if not df.empty:
+            # Répartition par catégorie
+            col1, col2 = st.columns(2)
+            
+            with col1:
+                category_counts = df['category_name'].value_counts()
+                fig1 = px.pie(
+                    values=category_counts.values,
+                    names=category_counts.index,
+                    title="Répartition par Catégorie"
+                )
+                st.plotly_chart(fig1, use_container_width=True)
+            
+            with col2:
+                # Top 10 des comités les plus actifs
+                committee_counts = df['committee'].value_counts().head(10)
+                fig2 = px.bar(
+                    x=committee_counts.values,
+                    y=committee_counts.index,
+                    orientation='h',
+                    title="Top 10 Comités les Plus Actifs"
+                )
+                fig2.update_layout(yaxis={'categoryorder': 'total ascending'})
+                st.plotly_chart(fig2, use_container_width=True)
+            
+            # Évolution temporelle
+            year_counts = df.groupby(['year', 'category_name']).size().reset_index(name='count')
+            fig3 = px.line(
+                year_counts,
+                x='year',
+                y='count',
+                color='category_name',
+                title="Évolution des Documents par Année"
+            )
+            st.plotly_chart(fig3, use_container_width=True)
             
-            badge_html = " ".join([f"<span style='background-color: #e0e0e0; padding: 2px 6px; border-radius: 4px; margin-right: 5px; font-size: 0.8em;'>{badge}</span>" for badge in badges])
+            # Documents récents
+            st.subheader("🆕 Documents Récents (2023-2024)")
+            recent_docs = df[df['is_new']].groupby(['year', 'category_name']).size().reset_index(name='count')
+            if not recent_docs.empty:
+                fig4 = px.bar(
+                    recent_docs,
+                    x='year',
+                    y='count',
+                    color='category_name',
+                    title="Nouveaux Documents par Année"
+                )
+                st.plotly_chart(fig4, use_container_width=True)
             
-            # URL de base pour le lien
-            base_url_map = {
-                "guidelines": "https://www.fao.org/fao-who-codexalimentarius/codex-texts/guidelines/fr/",
-                "standards": "https://www.fao.org/fao-who-codexalimentarius/codex-texts/list-standards/fr/",
-                "codes_of_practice": "https://www.fao.org/fao-who-codexalimentarius/codex-texts/codes-of-practice/fr/",
-                "miscellaneous": "https://www.fao.org/fao-who-codexalimentarius/codex-texts/miscellaneous/fr/"
-            }
-            doc_url = base_url_map.get(row['category_key'], "https://www.fao.org/fao-who-codexalimentarius/codex-texts/fr/")
+            # Analyse par comité
+            st.subheader("📊 Analyse Détaillée par Comité")
+            committee_analysis = df.groupby('committee').agg({
+                'code': 'count',
+                'is_new': 'sum',
+                'is_2024': 'sum'
+            }).rename(columns={
+                'code': 'Total',
+                'is_new': 'Nouveaux',
+                'is_2024': 'Mis à jour 2024'
+            }).sort_values('Total', ascending=False)
             
-            with st.container():
-                st.markdown(f"""
-                <div style="border: 1px solid #e0e0e0; border-radius: 5px; padding: 15px; margin-bottom: 10px;">
-                    <div style="display: flex; justify-content: space-between; align-items: flex-start;">
-                        <div>
-                            <h4 style="margin: 0; color: #1f77b4;">{row['code']}</h4>
-                            {badge_html}
-                        </div>
-                        <a href="{doc_url}" target="_blank" style="background-color: #1f77b4; color: white; padding: 5px 10px; text-decoration: none; border-radius: 3px; font-size: 0.8em;">🔗 Voir Section</a>
-                    </div>
-                    <p style="margin: 10px 0;"><strong>{row['title']}</strong></p>
-                    <div style="display: flex; gap: 20px; font-size: 0.9em; color: #666;">
-                        <span>🏢 Comité: {row['committee']}</span>
-                        <span>📅 Année: {row['year']}</span>
-                    </div>
-                </div>
-                """, unsafe_allow_html=True)
+            st.dataframe(committee_analysis, use_container_width=True)
+    
+    with tab3:
+        st.header("💾 Export des Données")
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            # Export CSV
+            csv = filtered_df.to_csv(index=False)
+            st.download_button(
+                label="📄 Télécharger CSV",
+                data=csv,
+                file_name=f"codex_documents_{datetime.now().strftime('%Y%m%d')}.csv",
+                mime="text/csv"
+            )
+        
+        with col2:
+            # Export JSON
+            json_data = filtered_df.to_json(orient='records', indent=2)
+            st.download_button(
+                label="📋 Télécharger JSON",
+                data=json_data,
+                file_name=f"codex_documents_{datetime.now().strftime('%Y%m%d')}.json",
+                mime="application/json"
+            )
+        
+        # Statistiques d'export
+        st.subheader("📊 Statistiques d'Export")
+        export_stats = {
+            "Total documents": len(filtered_df),
+            "Nouveaux documents (2023+)": len(filtered_df[filtered_df['is_new']]),
+            "Documents 2024": len(filtered_df[filtered_df['is_2024']]),
+            "Comités uniques": filtered_df['committee'].nunique(),
+            "Catégories": list(filtered_df['category_name'].unique()),
+            "Période couverte": f"{filtered_df['year'].min()} - {filtered_df['year'].max()}",
+            "Date d'extraction": datetime.now().strftime('%Y-%m-%d %H:%M:%S')
+        }
+        
+        st.json(export_stats)
+        
+        # Aperçu des données filtrées
+        st.subheader("👀 Aperçu des Données Filtrées")
+        st.dataframe(
+            filtered_df[['code', 'title', 'committee', 'year', 'category_name']].head(20),
+            use_container_width=True
+        )
+
+if __name__ == "__main__":
+    main()