Update src/streamlit_app.py

src/streamlit_app.py

@@ -1,131 +1,162 @@
-# codex_simple_extractor.py
+# codex_cxc_extractor_final.py
 import requests
 from bs4 import BeautifulSoup
 import re
 import time
+import csv
+from datetime import datetime
 
-# URL de la page à scraper
-url = "https://www.fao.org/fao-who-codexalimentarius/codex-texts/codes-of-practice/fr/"
-
+# --- Configuration ---
+# URL de la page à scraper pour les Codes de Pratique
+URL = "https://www.fao.org/fao-who-codexalimentarius/codex-texts/codes-of-practice/fr/"
 # 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'
+HEADERS = {
+    'User-Agent': 'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/117.0.0.0 Safari/537.36'
 }
+# Timeout pour la requête (en secondes)
+TIMEOUT = 30
+# Nom du fichier de sortie
+OUTPUT_FILENAME = f"codex_cxc_documents_{datetime.now().strftime('%Y%m%d_%H%M%S')}.csv"
+# --- Fin Configuration ---
 
-print(f"Tentative d'extraction depuis: {url}")
+def extract_cxc_documents():
+    """
+    Fonction principale pour extraire les Codes de Pratique (CXC).
+    """
+    print(f"--- Démarrage de l'extraction depuis : {URL} ---")
+    
+    documents = []
+    seen_codes = set() # Pour éviter les doublons
 
-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}")
+    try:
+        # 1. Récupérer la page web
+        print("1. Connexion au site Codex...")
+        start_time = time.time()
+        response = requests.get(URL, headers=HEADERS, timeout=TIMEOUT)
+        response.raise_for_status() # Lève une exception pour les codes d'erreur 4xx/5xx
+        end_time = time.time()
+        print(f"   -> Page récupérée avec succès (Statut: {response.status_code}) en {end_time - start_time:.2f} secondes.")
 
-    # 2. Analyser le contenu HTML
-    soup = BeautifulSoup(response.content, 'html.parser')
-    print("Analyse HTML terminée.")
+        # 2. Analyser le contenu HTML
+        print("2. Analyse du contenu HTML...")
+        soup = BeautifulSoup(response.content, 'html.parser')
+        print("   -> Analyse HTML terminée.")
 
-    # 3. Trouver tous les tableaux
-    tables = soup.find_all('table')
-    print(f"Nombre de tableaux trouvés sur la page: {len(tables)}")
+        # 3. Trouver les tableaux
+        print("3. Recherche des tableaux dans la page...")
+        tables = soup.find_all('table')
+        print(f"   -> Nombre de tableaux trouvés : {len(tables)}")
 
-    documents = []
-    seen_codes = set() # Pour éviter les doublons
+        if not tables:
+            print("   -> Aucun tableau trouvé. Arrêt de l'extraction.")
+            return documents # Retourne une liste vide
 
-    if tables:
-        print("Analyse des tableaux pour trouver les documents...")
-        # Parcourir chaque tableau
-        for i, table in enumerate(tables):
-            # print(f"  Analyse du tableau {i+1}...")
+        # 4. Parcourir les tableaux pour trouver les documents
+        print("4. Analyse des tableaux pour extraire les documents CXC...")
+        documents_found_in_tables = 0
+        
+        # Parcourir chaque tableau trouvé
+        for table_index, table in enumerate(tables):
+            # print(f"     -> Analyse du tableau {table_index + 1}...")
             rows = table.find_all('tr')
+            
+            # Parcourir chaque ligne du tableau
             for row in rows:
                 cells = row.find_all(['td', 'th']) # Inclure th au cas où
-                # Un document valide a généralement au moins 4 cellules
+                
+                # Vérifier s'il y a suffisamment de cellules (au moins 4: code, titre, comité, année)
                 if len(cells) >= 4:
-                    # Extraire le texte de chaque cellule
+                    # Extraire le texte brut de chaque cellule
                     cell_texts = [cell.get_text(strip=True) for cell in cells]
                     
-                    # Essayer de trouver un code Codex CXC dans la première cellule
+                    # --- Extraction des données ---
+                    # 1. Code (de la première cellule)
                     code_candidate = cell_texts[0] if cell_texts else ""
-                    # 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)
+                    # Pattern regex pour identifier les codes CXC (ex: CXC 80-2020, CXC 43R-1995)
+                    # Amélioration: Gère mieux les tirets et 'R'
+                    code_match = re.match(r'^(CXC)\s+([\w\-R]*\d+(?:-\d+)?[R]?)$', code_candidate)
                     
                     if code_match:
                         prefix = code_match.group(1)
                         number_part = code_match.group(2)
                         full_code = f"{prefix} {number_part}"
                         
+                        # Éviter les doublons
                         if full_code not in seen_codes:
                             seen_codes.add(full_code)
+                            documents_found_in_tables += 1
                             
-                            # Extraire les autres informations
+                            # 2. Titre (de la deuxième cellule)
                             title = cell_texts[1] if len(cell_texts) > 1 else "Titre non trouvé"
+                            
+                            # 3. Comité (de la troisième cellule)
                             committee = cell_texts[2] if len(cell_texts) > 2 else "COMITE"
+                            
+                            # 4. Année (de la quatriè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
+                                year = 0 # Valeur par défaut si l'année n'est pas valide
 
+                            # Ajouter le document à la liste
                             documents.append({
                                 'code': full_code,
                                 'title': title,
                                 'committee': committee,
                                 'year': year
                             })
-        print(f"Extraction terminée. Documents trouvés via analyse de tableau: {len(documents)}")
-    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)
+                            # print(f"       Document trouvé : {full_code}")
 
-        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
+        print(f"   -> Extraction terminée. Documents trouvés via analyse de tableau : {documents_found_in_tables}")
+
+        # 5. Afficher les résultats
+        if documents:
+            print(f"\n--- Résumé de l'extraction ---")
+            print(f"Nombre total de documents CXC extraits : {len(documents)}")
+            
+            # Trier par année (décroissante) puis par code
+            documents.sort(key=lambda x: (-x['year'], x['code']))
+            
+            print("\n--- 10 premiers documents extraits ---")
+            for i, doc in enumerate(documents[:10]):
+                 print(f"  {i+1}. {doc['code']} | {doc['title'][:60]}... | {doc['committee']} | {doc['year']}")
 
-            if full_code not in seen_codes:
-                seen_codes.add(full_code)
-                documents.append({
-                    'code': full_code,
-                    'title': title,
-                    'committee': committee,
-                    'year': year
-                })
-        print(f"Extraction terminée. Documents trouvés via analyse de texte brut: {len(documents)}")
+            # 6. Sauvegarder dans un fichier CSV
+            print(f"\n--- Sauvegarde des données ---")
+            try:
+                with open(OUTPUT_FILENAME, 'w', newline='', encoding='utf-8') as csvfile:
+                    fieldnames = ['code', 'title', 'committee', 'year']
+                    writer = csv.DictWriter(csvfile, fieldnames=fieldnames, delimiter=';') # ';' pour compatibilité Excel FR
+                    writer.writeheader()
+                    for doc in documents:
+                        writer.writerow(doc)
+                print(f"   -> Données sauvegardées dans '{OUTPUT_FILENAME}'")
+            except Exception as e:
+                print(f"   -> Erreur lors de la sauvegarde du fichier CSV : {e}")
 
+        else:
+            print("\n--- Aucun document CXC n'a pu être extrait via l'analyse de tableau. ---")
+            
+            # Option de secours : Afficher un échantillon du texte brut
+            print("\n--- Diagnostic : Échantillon du texte brut de la page ---")
+            text_sample = soup.get_text()
+            print(text_sample[:2000]) # Afficher les 2000 premiers caractères
+            print("--- Fin de l'échantillon ---")
 
-    # 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 ---")
+    except requests.exceptions.Timeout:
+        print(f"Erreur : La requête a expiré après {TIMEOUT} secondes.")
+    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}")
+        import traceback
+        traceback.print_exc() # Affiche la pile d'appel pour le débogage
 
+    return documents
 
-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}")
+# --- Point d'entrée du script ---
+if __name__ == "__main__":
+    extracted_docs = extract_cxc_documents()
+    # Le script se termine ici. Les résultats sont affichés et sauvegardés.
+    print("\n--- Script terminé ---")