Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,784 +1,131 @@
-# streamlit_app.py
-
-import streamlit as st
+# codex_simple_extractor.py
 import requests
-import pandas as pd
-import re
-from datetime import datetime
-import json
-import plotly.express as px
-import plotly.graph_objects as go
 from bs4 import BeautifulSoup
+import re
 import time
 
-# Configuration de la page
-st.set_page_config(
-    page_title="Moniteur Codex Alimentarius",
-    page_icon="📋",
-    layout="wide",
-    initial_sidebar_state="expanded"
-)
+# URL de la page à scraper
+url = "https://www.fao.org/fao-who-codexalimentarius/codex-texts/codes-of-practice/fr/"
 
-# URLs du Codex Alimentarius - Nettoyées
-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'
-    }
+# Entête pour simuler un navigateur
+headers = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36'
 }
 
-# Nettoyer les URLs au démarrage
-for key in CODEX_URLS:
-    CODEX_URLS[key]['url'] = CODEX_URLS[key]['url'].strip()
-
-# Cache pour la disponibilité des PDF (TTL 10 minutes)
-@st.cache_data(ttl=600)
-def check_pdf_availability_cached(url):
-    """Vérifie si un PDF est disponible à l'URL donnée (version mise en cache)"""
-    return check_pdf_availability(url)
+print(f"Tentative d'extraction depuis: {url}")
 
-@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/100.0.4896.127 Safari/537.36'
-        }
+try:
+    # 1. Récupérer la page web
+    response = requests.get(url, headers=headers, timeout=30)
+    response.raise_for_status() # Lève une exception si le statut est une erreur (4xx, 5xx)
+    print(f"Page récupérée avec succès. Statut: {response.status_code}")
 
-        response = requests.get(url, headers=headers, timeout=30)
-        response.raise_for_status()
+    # 2. Analyser le contenu HTML
+    soup = BeautifulSoup(response.content, 'html.parser')
+    print("Analyse HTML terminée.")
 
-        # Parser le HTML
-        soup = BeautifulSoup(response.content, 'html.parser')
+    # 3. Trouver tous les tableaux
+    tables = soup.find_all('table')
+    print(f"Nombre de tableaux trouvés sur la page: {len(tables)}")
 
-        documents = []
-        seen_codes = set() # Pour éviter les doublons
-
-        # --- Méthode principale: Analyser les balises <table> pour trouver les documents ---
-        # Les documents sont dans des tableaux
-        tables = soup.find_all('table')
-        
-        if not tables:
-            st.warning(f"Aucun tableau trouvé sur la page {url}.")
-            return []
+    documents = []
+    seen_codes = set() # Pour éviter les doublons
 
+    if tables:
+        print("Analyse des tableaux pour trouver les documents...")
         # Parcourir chaque tableau
-        for table in tables:
+        for i, table in enumerate(tables):
+            # print(f"  Analyse du tableau {i+1}...")
             rows = table.find_all('tr')
             for row in rows:
-                # Chercher les cellules dans la ligne
                 cells = row.find_all(['td', 'th']) # Inclure th au cas où
-                # Un document valide a généralement au moins 4 cellules (code, titre, comité, année)
+                # Un document valide a généralement au moins 4 cellules
                 if len(cells) >= 4:
                     # Extraire le texte de chaque cellule
                     cell_texts = [cell.get_text(strip=True) for cell in cells]
                     
-                    # Essayer de trouver un code Codex dans la première cellule
+                    # Essayer de trouver un code Codex CXC dans la première cellule
                     code_candidate = cell_texts[0] if cell_texts else ""
-                    # Amélioration du pattern regex pour gérer les tirets et 'R'
-                    code_match = re.match(r'^(CX[GSCXM])\s*([\w\-]*\d+(?:-\d+)?[R]?)$', code_candidate)
+                    # Pattern pour CXC suivi d'un numéro (ex: CXC 80-2020, CXC 43R-1995)
+                    code_match = re.match(r'^(CXC)\s*([\w\-R]*\d+(?:-\d+)?)$', code_candidate)
                     
                     if code_match:
                         prefix = code_match.group(1)
                         number_part = code_match.group(2)
                         full_code = f"{prefix} {number_part}"
                         
-                        # Extraire le titre (2ème cellule)
-                        title = cell_texts[1] if len(cell_texts) > 1 else "Titre non trouvé"
-                        
-                        # Extraire le comité (3ème cellule)
-                        committee = cell_texts[2] if len(cell_texts) > 2 else "COMITE"
-                        
-                        # Extraire l'année (4ème cellule)
-                        year_str = cell_texts[3] if len(cell_texts) > 3 else ""
-                        try:
-                            year = int(year_str) if year_str.isdigit() else 0
-                        except ValueError:
-                            year = 0 # Valeur par défaut si l'année n'est pas valide
-
                         if full_code not in seen_codes:
                             seen_codes.add(full_code)
+                            
+                            # Extraire les autres informations
+                            title = cell_texts[1] if len(cell_texts) > 1 else "Titre non trouvé"
+                            committee = cell_texts[2] if len(cell_texts) > 2 else "COMITE"
+                            year_str = cell_texts[3] if len(cell_texts) > 3 else ""
+                            try:
+                                year = int(year_str) if year_str.isdigit() else 0
+                            except ValueError:
+                                year = 0
+
                             documents.append({
                                 'code': full_code,
                                 'title': title,
                                 'committee': committee,
-                                'year': year,
-                                'category': category,
-                                'category_name': CODEX_URLS[category]['name'],
-                                'is_new': year >= 2023,
-                                'is_2024': year == 2024,
-                                'source_url': url,
-                                'pdf_url': get_best_pdf_link(full_code, year),
-                                'extracted_at': datetime.now().isoformat()
+                                'year': year
                             })
-
-        # --- Méthode de secours: Parser le texte brut pour les formats alternatifs ---
-        # Par exemple, pour les pages comme codes-of-practice qui ont un format texte brut
-        if not documents:
-            st.info(f"Aucun document trouvé via l'analyse des tableaux pour {CODEX_URLS[category]['name']}. Tentative via le texte brut...")
-            text_content = soup.get_text()
-            # Pattern pour extraire les documents dans le texte brut
-            # Exemple: | CXC 20-1979| Code de déontologie...| CCGP| 2010||
-            # Ce pattern gère les espaces variables et les barres verticales
-            # Amélioration du pattern pour gérer 'R' et les tirets
-            pattern = r'\|\s*(CX[GSCXM])\s*([\w\-]*\d+(?:-\d+)?[R]?)\s*\|\s*([^|]+?)\s*\|\s*([A-Z0-9]{2,15})\s*\|\s*(\d{4})'
-            matches = re.findall(pattern, text_content, re.DOTALL)
-
-            for match in matches:
-                prefix, number_part, title, committee, year_str = match
-                full_code = f"{prefix} {number_part}"
-                title = title.strip()
-                committee = committee.strip()
-                try:
-                    year = int(year_str.strip())
-                except ValueError:
-                    year = 0
-
-                if full_code not in seen_codes:
-                    seen_codes.add(full_code)
-                    documents.append({
-                        'code': full_code,
-                        'title': title,
-                        'committee': committee,
-                        'year': year,
-                        'category': category,
-                        'category_name': CODEX_URLS[category]['name'],
-                        'is_new': year >= 2023,
-                        'is_2024': year == 2024,
-                        'source_url': url,
-                        'pdf_url': get_best_pdf_link(full_code, year),
-                        'extracted_at': datetime.now().isoformat()
-                    })
-
-        if documents:
-            st.success(f"{len(documents)} documents extraits de {CODEX_URLS[category]['name']}")
-        else:
-             st.warning(f"Aucun document trouvé dans {CODEX_URLS[category]['name']} - utilisation des données de sauvegarde")
-
-        return documents
-
-    except requests.exceptions.RequestException as e:
-        st.error(f"Erreur réseau lors de l'extraction de {CODEX_URLS[category]['name']}: {str(e)}")
-        st.info("Utilisation des données de sauvegarde...")
-        return get_fallback_data(category)
-    except Exception as e:
-        st.error(f"Erreur lors de l'extraction de {CODEX_URLS[category]['name']}: {str(e)}")
-        st.info("Utilisation des données de sauvegarde...")
-        return get_fallback_data(category)
-
-
-def get_fallback_data(category):
-    """Données de sauvegarde en cas d'échec de l'extraction"""
-    fallback_guidelines = [
-        {'code': 'CXG 105-2024', 'title': 'Guidelines on the use of technology to provide food information in food labelling', 'committee': 'CCFL', 'year': 2024},
-        {'code': 'CXG 104-2024', 'title': 'Guidelines on the provision of food information for pre-packaged foods to be offered via e-commerce', 'committee': 'CCFL', 'year': 2024},
-        {'code': 'CXG 103-2024', 'title': 'Guidelines for food hygiene control measures in traditional markets for food', 'committee': 'CCFH', 'year': 2024},
-        {'code': 'CXG 99-2023', 'title': 'Directives pour la maîtrise des Escherichia coli producteurs de shiga-toxines (stec)', 'committee': 'CCFH', 'year': 2023},
-        {'code': 'CXG 100-2023', 'title': 'Guidelines for the Safe Use and Reuse of Water in Food Production and Processing', 'committee': 'CCFH', 'year': 2023},
-        {'code': 'CXG 101-2023', 'title': 'Guidelines on Recognition and Maintenance of Equivalence of National Food Control Systems', 'committee': 'CCFICS', 'year': 2023},
-        {'code': 'CXG 102-2023', 'title': 'Principles and Guidelines on the Use of Remote Audit and Inspection in Regulatory Frameworks', 'committee': 'CCFICS', 'year': 2023},
-        {'code': 'CXG 96-2022', 'title': 'Directives pour la gestion des épidémies biologiques d’origine alimentaire', 'committee': 'CCFH', 'year': 2022},
-        {'code': 'CXG 97-2022', 'title': 'Guidelines for the Recognition of Active Substances or Authorized Uses of Active Substances of Low Public Health Concern...', 'committee': 'CCPR', 'year': 2022},
-    ]
-
-    fallback_standards = [
-        {'code': 'CXS 359-2024', 'title': 'Standard for dried or dehydrated roots, rhizomes and bulbs – Turmeric', 'committee': 'CCSCH', 'year': 2024},
-        {'code': 'CXS 358-2024', 'title': 'Standard for spices derived from dried or dehydrated fruits and berries - Allspice, juniper berry and star anise', 'committee': 'CCSCH', 'year': 2024},
-        {'code': 'CXS 357-2024', 'title': 'Standard for spices derived from dried or dehydrated fruits and berries – Small cardamom', 'committee': 'CCSCH', 'year': 2024},
-        {'code': 'CXS 193-1995', 'title': 'Norme générale pour les contaminants et les toxines présents dans les produits de consommation humaine et animale', 'committee': 'CCCF', 'year': 2024},
-        {'code': 'CXS 1-1985', 'title': 'Norme générale pour l\'étiquetage des denrées alimentaires préemballées', 'committee': 'CCFL', 'year': 2024},
-        {'code': 'CXS 283-1978', 'title': 'Norme générale pour le fromage', 'committee': 'CCMMP', 'year': 2024},
-        {'code': 'CXS 349-2022', 'title': 'Norme pour les baies', 'committee': 'CCFFV', 'year': 2022},
-        {'code': 'CXS 352-2022', 'title': 'Norme pour les graines séchées – Noix de muscade', 'committee': 'CCSCH', 'year': 2022},
-        {'code': 'CXS 329-2017', 'title': 'Norme pour les huiles de poisson', 'committee': 'CCFO', 'year': 2024},
-        {'code': 'CXS 288-1976', 'title': 'Norme pour la crème et les crèmes préparées', 'committee': 'CCMMP', 'year': 2024},
-        {'code': 'CXS 222-2001', 'title': 'Norme pour les croquettes de poisson de mer et d\'eau douce, crustacés et mollusques', 'committee': 'CCFFP', 'year': 2024},
-    ]
-    
-    fallback_codes = [
-        {'code': 'CXC 1-1969', 'title': 'Principes généraux d\'hygiène alimentaire', 'committee': 'CCFH', 'year': 2022},
-        {'code': 'CXC 20-1979', 'title': 'Code de déontologie du commerce international des denrées alimentaires', 'committee': 'CCGP', 'year': 2010},
-        {'code': 'CXC 58-2005', 'title': 'Code d’usages en matière d’hygiène pour la viande', 'committee': 'CCMPH', 'year': 2005},
-        {'code': 'CXC 75-2015', 'title': 'Code d\'usages en matière d\'hygiène pour les aliments à faible teneur en eau', 'committee': 'CCFH', 'year': 2018},
-        {'code': 'CXC 80-2020', 'title': 'Code d’usages sur la gestion des allergènes alimentaires pour les exploitants du secteur alimentaire', 'committee': 'CCFH', 'year': 2020},
-    ]
-
-    if category == 'guidelines':
-        data = fallback_guidelines
-    elif category == 'standards':
-        data = fallback_standards
-    elif category == 'codes':
-        data = fallback_codes
-    else:
-        return []  # Pas de données pour misc
-
-    return [
-        {
-            **item,
-            'category': category,
-            'category_name': CODEX_URLS[category]['name'],
-            'is_new': item['year'] >= 2023,
-            'is_2024': item['year'] == 2024,
-            'source_url': CODEX_URLS[category]['url'],
-            'pdf_url': get_best_pdf_link(item['code'], item['year']),
-            'extracted_at': datetime.now().isoformat()
-        }
-        for item in data
-    ]
-
-
-def generate_pdf_links(code, year):
-    """Génère les liens PDF potentiels pour un document Codex"""
-    potential_urls = []
-
-    # Nettoyer le code pour l'URL
-    # Ex: CXS 12 -> CXS_012
-    # Ex: CXG 105 -> CXG_105
-    # Ex: CXS 12-1981 -> CXS_012-1981
-    # Ex: CXS 298R-2009 -> CXS_298R-2009
-    code_parts = code.split()
-    if len(code_parts) != 2:
-        # Format inattendu, essayer de deviner
-        clean_code_for_url = code.replace(' ', '_')
+        print(f"Extraction terminée. Documents trouvés via analyse de tableau: {len(documents)}")
     else:
-        prefix = code_parts[0]
-        number_part = code_parts[1]
-        
-        # Gérer les numéros avec tirets et 'R' (ex: 298R-2009)
-        if '-' in number_part:
-            parts = number_part.split('-', 1) # Split seulement sur le premier tiret
-            main_number_str = parts[0]
-            suffix_and_year = parts[1] if len(parts) > 1 else ""
+        print("Aucun tableau trouvé. Tentative d'extraction via le texte brut...")
+        # Méthode de secours: Parser le texte brut
+        text_content = soup.get_text()
+        # Pattern pour extraire les documents dans le texte brut (format | CODE | Titre | Comité | Année |)
+        pattern = r'\|\s*(CXC)\s*([\w\-R]*\d+(?:-\d+)?)\s*\|\s*([^|]+?)\s*\|\s*([A-Z0-9]{2,15})\s*\|\s*(\d{4})'
+        matches = re.findall(pattern, text_content, re.DOTALL)
+
+        for match in matches:
+            prefix, number_part, title, committee, year_str = match
+            full_code = f"{prefix} {number_part}"
+            title = title.strip()
+            committee = committee.strip()
             try:
-                # Essayer de pad le numéro principal
-                main_number = int(main_number_str.rstrip('R')) # Enlever 'R' temporairement
-                padded_main_number = f"{main_number:03d}"
-                # Réassembler avec 'R' si présent
-                if main_number_str.endswith('R'):
-                    padded_main_number += 'R'
-                clean_code_for_url = f"{prefix}_{padded_main_number}-{suffix_and_year}"
+                year = int(year_str.strip())
             except ValueError:
-                # Si le numéro principal n'est pas un entier pur
-                clean_code_for_url = f"{prefix}_{number_part}"
-        else:
-            # Pas de tiret, juste un numéro (ex: 12)
-            try:
-                number = int(number_part.rstrip('R'))
-                padded_number = f"{number:03d}"
-                if number_part.endswith('R'):
-                    padded_number += 'R'
-                clean_code_for_url = f"{prefix}_{padded_number}"
-            except ValueError:
-                # Si ce n'est pas un nombre pur
-                clean_code_for_url = f"{prefix}_{number_part}"
-
-    # Chemins possibles
-    base_paths = [
-        "https://www.fao.org/fileadmin/templates/codexalimentarius/pdf/CODEX_STANDARDS/",
-        "https://www.fao.org/fileadmin/user_upload/CODEX_STANDARDS/",
-        "https://www.fao.org/fileadmin/CODEX_STANDARDS/",
-        "https://www.fao.org/fileadmin/templates/codexalimentarius/Standards/" # Un autre chemin possible
-    ]
-
-    # Variants courants: final (f), consolidated (c), revue (r), standard (s), annex (a), english (e)
-    # Pour les documents régionaux (R), le 'R' est déjà dans le nom du fichier
-    variants = ['f', 'c', 'r', 's', 'a', 'e', ''] # '' pour le lien sans variant
-
-    for base_path in base_paths:
-        for variant in variants:
-            if variant:
-                potential_urls.append(f"{base_path}{clean_code_for_url}{variant}.pdf")
-            else:
-                potential_urls.append(f"{base_path}{clean_code_for_url}.pdf")
-
-    return potential_urls
-
-def check_pdf_availability(url):
-    """Vérifie si un PDF est disponible à l'URL donnée"""
-    try:
-        # Utiliser HEAD pour vérifier rapidement
-        response = requests.head(url, timeout=5, allow_redirects=True)
-        # Certains serveurs renvoient 302/301 même si le fichier existe, suivi d'une 200
-        # Donc on vérifie si le statut final est 200
-        # Ou si le Content-Type est application/pdf
-        if response.status_code == 200:
-            content_type = response.headers.get('Content-Type', '')
-            if 'application/pdf' in content_type:
-                return True
-        # Si HEAD ne fonctionne pas bien, essayer GET avec un petit timeout
-        # Mais ce n'est pas idéal pour les gros fichiers
-        # On peut aussi vérifier si le HEAD redirige vers un PDF
-        elif response.status_code in [301, 302, 307, 308]:
-             # Suivre la redirection manuellement une fois pour vérifier
-             try:
-                 final_response = requests.get(url, timeout=5, allow_redirects=True, stream=True)
-                 if final_response.status_code == 200:
-                     content_type = final_response.headers.get('Content-Type', '')
-                     if 'application/pdf' in content_type:
-                         return True
-                 final_response.close()
-             except:
-                 pass
-        return False
-    except:
-        return False
-
-def get_best_pdf_link(code, year):
-    """Retourne le meilleur lien PDF disponible pour un document"""
-    potential_urls = generate_pdf_links(code, year)
-
-    # Tester les URLs par ordre de préférence
-    for url in potential_urls:
-        if check_pdf_availability_cached(url): # Utiliser la version mise en cache
-            return url
-
-    # Si aucun PDF direct trouvé, retourner le lien de recherche
-    search_term = code.replace(' ', '%20')
-    return f"https://www.fao.org/fao-who-codexalimentarius/search/en/?q={search_term}"
-
-
-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.
-    """)
-
-    # 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 = (
-                    get_fallback_data('guidelines') +
-                    get_fallback_data('standards') +
-                    get_fallback_data('codes')
-                )
-                st.success(f"✅ {len(st.session_state.documents)} documents d'exemple chargés!")
-            else:
-                # Extraction en temps réel avec gestion d'erreurs améliorée
-                all_documents = []
-                progress_bar = st.progress(0)
-                status_placeholder = st.empty()
-
-                # Traiter toutes les catégories
-                categories_to_process = ['standards', 'guidelines', 'codes', 'misc']
-
-                for i, category in enumerate(categories_to_process):
-                    info = CODEX_URLS[category]
-                    status_placeholder.info(f"Extraction des {info['name']}...")
-
-                    try:
-                        documents = extract_documents_from_url(info['url'], category)
-                        all_documents.extend(documents)
-
-                    except Exception as e:
-                        st.error(f"❌ Erreur avec {info['name']}: {str(e)}")
-
-                    progress_bar.progress((i + 1) / len(categories_to_process))
-                    time.sleep(0.3)  # Pause plus courte
-
-                status_placeholder.empty()
-
-                if all_documents:
-                    st.session_state.documents = all_documents
-                    st.success(f"✅ {len(all_documents)} documents extraits au total!")
-                else:
-                    st.error("❌ Aucun document extrait. Utilisation des données d'exemple...")
-                    st.session_state.documents = (
-                        get_fallback_data('guidelines') +
-                        get_fallback_data('standards') +
-                        get_fallback_data('codes')
-                    )
-                    st.info(f"📊 {len(st.session_state.documents)} documents d'exemple chargés en fallback")
-
-    # Bouton pour forcer le mode démo
-    if st.sidebar.button("🎯 Forcer le mode démo", help="Charge les données d'exemple directement"):
-        st.session_state.documents = (
-            get_fallback_data('guidelines') +
-            get_fallback_data('standards') +
-            get_fallback_data('codes')
-        )
-        st.success(f"✅ Mode démo activé - {len(st.session_state.documents)} documents chargés!")
-
-    # Section de debug
-    if st.sidebar.checkbox("🔧 Mode Debug"):
-        st.sidebar.subheader("Debug Info")
-
-        test_url_key = st.sidebar.selectbox(
-            "Tester une URL:",
-            list(CODEX_URLS.keys()),
-            format_func=lambda x: CODEX_URLS[x]['name']
-        )
-
-        if st.sidebar.button("🔍 Tester extraction"):
-            with st.expander("Résultats du test d'extraction", expanded=True):
-                try:
-                    url = CODEX_URLS[test_url_key]['url']
-                    st.write(f"**URL testée:** {url}")
-
-                    # Test de connexion
-                    headers = {
-                        'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/100.0.4896.127 Safari/537.36'
-                    }
-                    with st.spinner("Connexion au site..."):
-                        response = requests.get(url, headers=headers, timeout=15)
-                    st.write(f"**Status HTTP:** {response.status_code}")
-                    st.write(f"**Taille de la réponse:** {len(response.text)} caractères")
-
-                    # Extraire un échantillon du texte
-                    soup = BeautifulSoup(response.content, 'html.parser')
-                    text_sample = soup.get_text()[:3000]
-                    st.text_area("Échantillon du texte extrait:", text_sample, height=200)
-
-                    # Analyse des structures HTML
-                    tables = soup.find_all('table')
-                    st.write(f"**Tables trouvées:** {len(tables)}")
-                    if tables:
-                        rows_in_first_table = tables[0].find_all('tr')
-                        st.write(f"**Lignes dans la première table:** {len(rows_in_first_table)}")
-                        if rows_in_first_table:
-                            first_row_cells = rows_in_first_table[0].find_all(['td', 'th'])
-                            st.write(f"**Cellules dans la première ligne:** {len(first_row_cells)}")
-                            st.write("**Contenu de la première ligne:**", [c.get_text(strip=True) for c in first_row_cells])
-
-                    # Test des patterns regex
-                    pattern_table = r'^(CX[GSCXM])\s*([\w\-]*\d+(?:-\d+)?[R]?)$'
-                    pattern_text = r'\|\s*(CX[GSCXM])\s*([\w\-]*\d+(?:-\d+)?[R]?)\s*\|\s*([^|]+?)\s*\|\s*([A-Z0-9]{2,15})\s*\|\s*(\d{4})'
-
-                    rows = soup.find_all('tr')
-                    table_matches_count = 0
-                    sample_matches = []
-                    for i, row in enumerate(rows):
-                        cells = row.find_all('td')
-                        if cells:
-                            code_candidate = cells[0].get_text(strip=True) if cells else ""
-                            match = re.match(pattern_table, code_candidate)
-                            if match:
-                                table_matches_count += 1
-                                if len(sample_matches) < 5: # Montrer les 5 premiers matches
-                                    sample_matches.append((i, match.groups()))
-
-                    text_matches = re.findall(pattern_text, soup.get_text(), re.DOTALL)
-
-                    st.write(f"**Pattern Tableau:** {table_matches_count} lignes de document trouvées")
-                    if sample_matches:
-                        st.write("**Exemples de matches dans le tableau:**")
-                        for idx, groups in sample_matches:
-                            st.write(f"  - Ligne {idx}: {groups}")
-                    st.write(f"**Pattern Texte Brut:** {len(text_matches)} documents trouvés")
-                    if text_matches:
-                        st.write("**Exemples de matches dans le texte brut:**", text_matches[:3])
-
-                    # Test d'extraction complète
-                    st.write("---")
-                    st.subheader("Extraction des documents...")
-                    with st.spinner("Extraction en cours..."):
-                        documents = extract_documents_from_url(url, test_url_key)
-                    st.write(f"**Documents extraits:** {len(documents)}")
-                    if documents:
-                        st.write("Premiers documents:", documents[:3])
-
-                except Exception as e:
-                    st.error(f"Erreur lors du test: {str(e)}")
-                    import traceback
-                    st.code(traceback.format_exc())
-
-    # 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)
-
-    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.sidebar.header("🔍 Filtres")
-
-    # Filtre par catégorie
-    categories = ['Toutes'] + list(df['category_name'].unique())
-    selected_category = st.sidebar.selectbox("Catégorie:", categories)
-
-    # Filtre par comité
-    committees = ['Tous'] + sorted(df['committee'].unique())
-    selected_committee = st.sidebar.selectbox("Comité:", committees)
-
-    # Filtre par année - Amélioré avec une plage
-    st.sidebar.subheader("Année")
-    min_year = int(df['year'].min()) if not df.empty and df['year'].min() > 0 else 1960
-    max_year = max(int(df['year'].max()), datetime.now().year) if not df.empty else datetime.now().year
-    
-    # Option 1: Sélection unique
-    # years = ['Toutes'] + sorted(df['year'].unique(), reverse=True)
-    # selected_year = st.sidebar.selectbox("Année:", years)
-    
-    # Option 2: Plage d'années (plus flexible)
-    year_range = st.sidebar.slider(
-        "Plage d'années:",
-        min_value=min_year,
-        max_value=max_year,
-        value=(min_year, max_year),
-        step=1
-    )
-
-    # 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 ou codes:")
-
-    # Application des filtres
-    filtered_df = df.copy()
-
-    if selected_category != 'Toutes':
-        filtered_df = filtered_df[filtered_df['category_name'] == selected_category]
-
-    if selected_committee != 'Tous':
-        filtered_df = filtered_df[filtered_df['committee'] == selected_committee]
-
-    # if selected_year != 'Toutes':
-    #     filtered_df = filtered_df[filtered_df['year'] == selected_year]
-    # Filtrer par plage d'années
-    filtered_df = filtered_df[
-        (filtered_df['year'] >= year_range[0]) & 
-        (filtered_df['year'] <= year_range[1])
-    ]
-
-    if filter_new:
-        filtered_df = filtered_df[filtered_df['is_new']]
-
-    if filter_2024:
-        filtered_df = filtered_df[filtered_df['is_2024']]
-
-    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)")
-
-        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(border=True): # Ajout d'une bordure pour chaque document
-                    col1, col2 = st.columns([4, 1])
-
-                    with col1:
-                        # Badges - Améliorés
-                        badges_html = f"<strong>{doc['code']}</strong> "
-                        if doc['is_new']:
-                            badges_html += "<span style='background-color: #90EE90; color: black; padding: 2px 6px; border-radius: 4px; font-size: 0.8em;'>NOUVEAU</span> "
-                        if doc['is_2024']:
-                            badges_html += "<span style='background-color: #ADD8E6; color: black; padding: 2px 6px; border-radius: 4px; font-size: 0.8em;'>2024</span> "
-                        badges_html += f"<span style='background-color: #D3D3D3; color: black; padding: 2px 6px; border-radius: 4px; font-size: 0.8em;'>{doc['category_name']}</span>"
-                        st.markdown(badges_html, unsafe_allow_html=True)
-                        
-                        st.markdown(f"**{doc['title']}**")
-                        st.caption(f"🏢 {doc['committee']} • 📅 {doc['year']}")
-
-                    with col2:
-                        # Boutons d'action - Liens HTML pour un meilleur contrôle
-                        st.markdown(f"[📄 Voir Document]({doc['pdf_url']}){{target='_blank'}}", unsafe_allow_html=True)
-                        st.markdown(f"[🔗 Voir Section]({doc['source_url']}){{target='_blank'}}", unsafe_allow_html=True)
-
-                    # st.divider() # Supprimé car le container a déjà une bordure
-        else:
-            st.info("Aucun document ne correspond aux critères sélectionnés")
-
-    with tab2:
-        st.header("📊 Analyses des Documents")
-
-        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)
-
-            # 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)
-
-            # 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)
-
-            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_%H%M%S')}.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_%H%M%S')}.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"{int(filtered_df['year'].min()) if not filtered_df.empty else 'N/A'} - {int(filtered_df['year'].max()) if not filtered_df.empty else 'N/A'}",
-            "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")
-        display_df = filtered_df[['code', 'title', 'committee', 'year', 'category_name']].head(20)
-        st.dataframe(display_df, use_container_width=True)
-
-        # Test des liens PDF
-        if st.checkbox("🔍 Tester les liens PDF (peut prendre du temps)"):
-            st.info("Test des liens PDF en cours... Cela peut prendre quelques minutes.")
-
-            pdf_results = []
-            progress_bar = st.progress(0)
-            status_text = st.empty()
-
-            test_sample = filtered_df.head(20)  # Tester plus de documents
-
-            for i, (_, doc) in enumerate(test_sample.iterrows()):
-                status_text.text(f"Test du PDF {i+1}/{len(test_sample)}: {doc['code']}")
-                pdf_available = check_pdf_availability_cached(doc['pdf_url']) # Utiliser la version mise en cache
-                pdf_results.append({
-                    'Code': doc['code'],
-                    'Titre': doc['title'][:50] + "..." if len(doc['title']) > 50 else doc['title'],
-                    'PDF Disponible': '✅' if pdf_available else '❌',
-                    'Lien PDF': doc['pdf_url']
+                year = 0
+
+            if full_code not in seen_codes:
+                seen_codes.add(full_code)
+                documents.append({
+                    'code': full_code,
+                    'title': title,
+                    'committee': committee,
+                    'year': year
                 })
-                progress_bar.progress((i + 1) / len(test_sample))
+        print(f"Extraction terminée. Documents trouvés via analyse de texte brut: {len(documents)}")
+
 
-            st.subheader("📋 Résultats du Test PDF")
-            pdf_df = pd.DataFrame(pdf_results)
-            st.dataframe(pdf_df[['Code', 'Titre', 'PDF Disponible', 'Lien PDF']], use_container_width=True)
+    # 4. Afficher les résultats
+    if documents:
+        print("\n--- Documents Extraits (5 premiers) ---")
+        # Trier par année décroissante
+        documents.sort(key=lambda x: x['year'], reverse=True)
+        for doc in documents[:5]:
+            print(f"  - {doc['code']} | {doc['title'][:50]}... | {doc['committee']} | {doc['year']}")
+        print(f"\n--- Nombre Total de Documents Extraits: {len(documents)} ---")
+        
+        # Optionnel: Sauvegarder dans un fichier
+        # with open("codes_of_practice_simple.txt", "w", encoding='utf-8') as f:
+        #     for doc in documents:
+        #         f.write(f"{doc['code']} | {doc['title']} | {doc['committee']} | {doc['year']}\n")
+        # print("Résultats sauvegardés dans 'codes_of_practice_simple.txt'")
+        
+    else:
+        print("\nAucun document n'a pu être extrait.")
+        # Afficher un échantillon du texte pour débogage
+        print("\n--- Échantillon du texte de la page (1000 premiers caractères) ---")
+        print(soup.get_text()[:1000])
+        print("--- Fin de l'échantillon ---")
 
-            available_pdfs = sum(1 for r in pdf_results if '✅' in r['PDF Disponible'])
-            st.metric("📊 PDFs Disponibles", f"{available_pdfs}/{len(pdf_results)}")
 
-if __name__ == "__main__":
-    main()
+except requests.exceptions.RequestException as e:
+    print(f"Erreur lors de la requête HTTP : {e}")
+except Exception as e:
+    print(f"Une erreur inattendue s'est produite : {e}")