helioc

app.py

@@ -1,323 +1,75 @@
-#!/usr/bin/env python3
-# -*- coding: utf-8 -*-
-"""
-Extraction de données de bulletins BRVM via Hugging Face.
+# app.py
 
-Ce script optimisé :
-1. Télécharge un fichier ZIP de rapports PDF depuis un Hugging Face Dataset.
-2. Extrait le texte de chaque PDF.
-3. Utilise un modèle Mistral quantifié pour extraire les données structurées en JSON.
-4. Gère les erreurs de manière robuste (parsing, extraction).
-5. Uploade les résultats JSON vers un autre Hugging Face Dataset.
-
-Auteur: Gemini (avec optimisations)
-"""
-
-import fitz  # PyMuPDF
+import gradio as gr
+import threading
 import json
 from pathlib import Path
-from tqdm import tqdm
-import torch
-from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
-import os
-from huggingface_hub import hf_hub_download, HfApi
 from datetime import datetime
 import uuid
-import zipfile
+import os
 
-# ---------- CONFIGURATION CENTRALE ----------
-# --- Modèle et Quantification ---
-MODEL_ID = "mistralai/Mistral-7B-Instruct-v0.3"
+from script_brvm import (
+    initialize_model_pipeline,
+    download_and_extract_pdfs,
+    process_single_pdf,
+    upload_results_to_hf_single
+)
 
-# --- Dépôts Hugging Face ---
+# ---------- CONFIGURATION ----------
 HF_DATASET_PDFS_REPO_ID = "lamekemal/brvm-reports-pdfs"
-HF_DATASET_JSON_REPO_ID = "lamekemal/brvm-reports-json"
 ZIP_FILENAME_IN_DATASET = "brvm_reports.zip"
-
-# --- Token et Dossiers Locaux ---
-HF_TOKEN = os.getenv('HF_TOKEN') # Le token est récupéré des variables d'environnement (secrets)
 LOCAL_PDF_FOLDER = Path("brvm_reports_extracted")
-LOCAL_JSON_OUTPUT_BASE_FOLDER = Path("brvm_json_outputs")
 LOCAL_CACHE_DIR = Path("./hf_cache")
+HF_TOKEN = os.getenv("HF_TOKEN")
+HF_DATASET_JSON_REPO_ID = "lamekemal/brvm-reports-json"
+LOCAL_JSON_OUTPUT_BASE_FOLDER = Path("brvm_json_outputs")
 
-# --- Paramètres du Pipeline ---
-# Assez grand pour contenir le JSON complet, même pour des rapports denses.
-MAX_NEW_TOKENS = 8192
-
-# --- Prompt Optimisé ---
-# Plus direct, plus concis, et sans marqueurs custom.
-# Le modèle est instruit de ne retourner QUE le JSON, ce qui simplifie le parsing.
-PROMPT_TEMPLATE = """
-[INST]Tu es un expert en analyse de données financières de la BRVM. Extrais les informations du texte suivant et retourne-les sous la forme d'un objet JSON unique et valide. Ta réponse doit commencer par `{{` et se terminer par `}}`. N'inclus aucun texte, explication ou formatage en dehors de l'objet JSON.
-
-**JSON Schema attendu :**
-```json
-{{
-  "indicateurs": {{
-    "brvm_10": {{ "niveau": float, "var_jour_pct": float, "var_annuelle_pct": float }},
-    "brvm_composite": {{ "niveau": float, "var_jour_pct": float, "var_annuelle_pct": float }},
-    "capitalisation_actions_fcfa": float,
-    "capitalisation_obligations_fcfa": float,
-    "volume_echange": float,
-    "valeur_transigee_fcfa": float
-  }},
-  "plus_fortes_hausses": [
-    {{ "symbol": string, "nom": string, "cours": float, "var_jour_pct": float, "var_annuelle_pct": float }}
-  ],
-  "plus_fortes_baisses": [
-    {{ "symbol": string, "nom": string, "cours": float, "var_jour_pct": float, "var_annuelle_pct": float }}
-  ],
-  "actions": [
-    {{ "symbol": string, "nom": string, "cours_jour": float, "var_jour_pct": float, "volume": float, "valeur_fcfa": float, "dernier_dividende": float|null, "date_dividende": string|null }}
-  ],
-  "dividendes": [
-    {{ "symbol": string, "nom": string, "montant_fcfa": float, "date_paiement": string }}
-  ],
-  "obligations": [
-    {{ "code": string, "emetteur": string, "coupon_pct": float, "echeance": string, "nominal": float, "cours": float }}
-  ]
-}}
-```
-
-**Contraintes :**
-- Si une donnée est manquante, utilise la valeur `null`.
-- Utilise un point `.` comme séparateur décimal.
-
-**Texte du bulletin à analyser :**
-{texte_pdf}[/INST]
-"""
-
-# ---------- FONCTIONS ----------
-
-def initialize_model_pipeline():
-    """
-    Charge le modèle et le tokenizer avec une quantification 4-bit et crée le pipeline.
-    Retourne le pipeline ou None en cas d'erreur.
-    """
-    try:
-        print(f"Chargement du modèle '{MODEL_ID}' avec quantification 4-bit...")
-
-        # Configuration de la quantification pour réduire l'empreinte mémoire
-        bnb_config = BitsAndBytesConfig(
-            load_in_4bit=True,
-            bnb_4bit_quant_type="nf4",       # Type de quantification (NormalFloat4) - bon équilibre performance/précision
-            bnb_4bit_compute_dtype=torch.bfloat16, # Type pour les calculs, bfloat16 est rapide sur les GPU récents
-            bnb_4bit_use_double_quant=True, # Améliore la précision avec une surcoût mémoire minime
-        )
-
-        tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
-        model = AutoModelForCausalLM.from_pretrained(
-            MODEL_ID,
-            quantization_config=bnb_config,
-            device_map="auto", # Répartit automatiquement le modèle sur les ressources disponibles (GPU/CPU)
-            torch_dtype=torch.bfloat16,
-            trust_remote_code=True # Nécessaire pour certains modèles
-        )
-
-        # Assurer que le pad_token est défini pour éviter les avertissements
-        if tokenizer.pad_token is None:
-            tokenizer.pad_token = tokenizer.eos_token
-
-        extractor_pipeline = pipeline(
-            "text-generation",
-            model=model,
-            tokenizer=tokenizer,
-        )
-        print("✅ Modèle et pipeline chargés avec succès.")
-        return extractor_pipeline
-    except Exception as e:
-        print(f"❌ Erreur critique lors du chargement du modèle : {e}")
-        return None
-
-def download_and_extract_pdfs(repo_id, zip_filename, target_folder, cache_folder):
-    """
-    Télécharge un ZIP depuis un dataset HF et en extrait les fichiers PDF.
-    """
-    print(f"Téléchargement de '{zip_filename}' depuis le dataset '{repo_id}'...")
-    try:
-        local_zip_path = hf_hub_download(
-            repo_id=repo_id,
-            filename=zip_filename,
-            repo_type="dataset",
-            cache_dir=cache_folder
-        )
-        print(f"Fichier ZIP téléchargé dans : {local_zip_path}")
-
-        target_folder.mkdir(parents=True, exist_ok=True)
-        
-        extracted_files = []
-        with zipfile.ZipFile(local_zip_path, 'r') as z:
-            for member in z.infolist():
-                # Sécurité : Ignorer les chemins absolus ou contenant '..'
-                if member.is_dir() or member.filename.startswith('/') or '..' in member.filename:
-                    continue
-                
-                if member.filename.lower().endswith('.pdf'):
-                    target_path = target_folder / Path(member.filename).name
-                    with z.open(member) as source, open(target_path, "wb") as target:
-                        target.write(source.read())
-                    extracted_files.append(target_path)
-
-        print(f"✅ {len(extracted_files)} fichiers PDF extraits dans '{target_folder}'.")
-        return extracted_files
-    except Exception as e:
-        print(f"❌ Erreur lors du téléchargement ou de l'extraction : {e}")
-        return []
-
-def extract_text_from_pdf(pdf_path):
-    """
-    Extrait le contenu textuel brut d'un fichier PDF.
-    """
-    try:
-        with fitz.open(pdf_path) as doc:
-            return "\n".join(page.get_text() for page in doc)
-    except Exception as e:
-        print(f"⚠️  Avertissement : Impossible de lire le PDF '{pdf_path.name}'. Erreur : {e}")
-        return ""
-
-def parse_json_from_model_output(raw_output):
-    """
-    Extrait une chaîne JSON de la sortie brute du modèle et tente de la réparer.
-    """
-    try:
-        # 1. Isoler le texte généré par le modèle
-        generated_text = raw_output.split("[/INST]")[-1].strip()
-
-        # 2. Trouver les accolades de début et de fin
-        start_index = generated_text.find('{')
-        end_index = generated_text.rfind('}')
-
-        if start_index != -1 and end_index != -1 and end_index > start_index:
-            json_str = generated_text[start_index : end_index + 1]
-
-            # 3. Tenter de réparer les guillemets simples sur les clés
-            #    Attention : ceci est une solution de contournement, le modèle devrait générer du JSON valide.
-            #    Un regex simple pour remplacer les clés non-entre-guillemets
-            #    json_str = re.sub(r'([\{\s,]+)(\w+)(:)', r'\1"\2"\3', json_str)
-            #
-            # Pour la démonstration, on se contente de la tentative de parsing
-            return json.loads(json_str)
-        else:
-            raise ValueError("Accolades JSON non trouvées dans la sortie.")
-
-    except json.JSONDecodeError as e:
-        print(f"Erreur de décodage JSON : {e}")
-        # Retourner la sortie brute pour l'analyse
-        return {"error": "JSONDecodeError", "details": str(e), "raw_output": raw_output}
-    except Exception as e:
-        print(f"Erreur inattendue lors du parsing : {e}")
-        return {"error": "ParsingFailed", "details": str(e), "raw_output": raw_output}
-
-def process_single_pdf(pdf_path, pipeline):
-    """
-    Traite un seul fichier PDF : extraction de texte, appel du modèle et parsing du JSON.
-    """
-    print(f"--- Traitement de : {pdf_path.name} ---")
-    
-    # 1. Extraire le texte
-    text = extract_text_from_pdf(pdf_path)
-    if not text.strip():
-        return {"error": "PDF vide ou illisible", "source_file": pdf_path.name}
+extractor_pipeline = None
+processed_files = []
 
-    # 2. Préparer le prompt
-    prompt = PROMPT_TEMPLATE.format(texte_pdf=text[:30000]) # Tronquer pour être sûr de ne pas dépasser la limite de contexte
+def load_model():
+    global extractor_pipeline
+    extractor_pipeline = initialize_model_pipeline()
 
-    # 3. Appeler le modèle
-    try:
-        response = pipeline(
-            prompt,
-            max_new_tokens=MAX_NEW_TOKENS,
-             temperature=0.2,
-            do_sample=False, # Pour des résultats déterministes
-            return_full_text=False, # Ne retourne que le texte généré
-            pad_token_id=pipeline.tokenizer.eos_token_id # Évite un avertissement
+def start_background_processing(status_box):
+    def background_task():
+        pdf_files = download_and_extract_pdfs(
+            HF_DATASET_PDFS_REPO_ID,
+            ZIP_FILENAME_IN_DATASET,
+            LOCAL_PDF_FOLDER,
+            LOCAL_CACHE_DIR
         )
-        raw_output = response[0]['generated_text']
-        
-        # 4. Parser le JSON
-        data = parse_json_from_model_output(f"[INST]{prompt}[/INST]{raw_output}") # Reconstituer pour le parser
-        data['source_file'] = pdf_path.name # Ajouter la source pour la traçabilité
-        return data
-
-    except Exception as e:
-        print(f"❌ Erreur lors de l'appel du pipeline pour '{pdf_path.name}': {e}")
-        return {"error": "PipelineExecutionError", "details": str(e), "source_file": pdf_path.name}
-
 
-def upload_results_to_hf(local_folder, repo_id, hf_token):
-    """
-    Uploade le contenu d'un dossier vers un dataset sur le Hub Hugging Face.
-    """
-    if not hf_token:
-        print("⚠️  Avertissement : HF_TOKEN non configuré. L'upload est ignoré.")
-        print(f"Les résultats sont disponibles localement dans : {local_folder}")
-        return
-
-    try:
-        api = HfApi(token=hf_token)
-        repo_url = api.create_repo(repo_id, repo_type="dataset", exist_ok=True).repo_url
-        
-        commit_message = f"Rapport d'extraction BRVM du {datetime.now().strftime('%Y-%m-%d %H:%M')}"
-        
-        print(f"Début de l'upload de '{local_folder}' vers '{repo_id}'...")
-        api.upload_folder(
-            folder_path=str(local_folder),
-            repo_id=repo_id,
-            repo_type="dataset",
-            commit_message=commit_message
-        )
-        print(f"✅ Upload terminé avec succès ! Consultez les résultats sur : {repo_url}")
-    except Exception as e:
-        print(f"❌ Erreur lors de l'upload vers Hugging Face : {e}")
-        print("Veuillez vérifier votre HF_TOKEN et les permissions d'écriture sur le dépôt.")
+        run_id = datetime.now().strftime("%Y-%m-%d_%H-%M-%S") + "_" + uuid.uuid4().hex[:8]
+        local_output_dir = LOCAL_JSON_OUTPUT_BASE_FOLDER / run_id
+        local_output_dir.mkdir(parents=True, exist_ok=True)
 
+        for pdf_path in pdf_files:
+            result = process_single_pdf(pdf_path, extractor_pipeline)
 
-def main():
-    """
-    Fonction principale orchestrant le processus complet.
-    """
-    # Initialisation du modèle en premier pour échouer rapidement si nécessaire
-    extractor_pipeline = initialize_model_pipeline()
-    if not extractor_pipeline:
-        return # Arrêt si le modèle ne peut pas être chargé
+            output_json_path = local_output_dir / f"{pdf_path.stem}.json"
+            with open(output_json_path, "w", encoding="utf-8") as f:
+                json.dump(result, f, ensure_ascii=False, indent=2)
 
-    # Téléchargement et extraction des PDFs
-    pdf_files = download_and_extract_pdfs(
-        HF_DATASET_PDFS_REPO_ID, 
-        ZIP_FILENAME_IN_DATASET, 
-        LOCAL_PDF_FOLDER, 
-        LOCAL_CACHE_DIR
-    )
-    if not pdf_files:
-        print("Aucun PDF à traiter. Arrêt du script.")
-        return
+            upload_results_to_hf_single(result, HF_DATASET_JSON_REPO_ID, HF_TOKEN)
 
-    # Création d'un dossier de sortie unique pour cette exécution
-    run_id = datetime.now().strftime("%Y-%m-%d_%H-%M-%S") + "_" + uuid.uuid4().hex[:8]
-    local_output_dir = LOCAL_JSON_OUTPUT_BASE_FOLDER / run_id
-    local_output_dir.mkdir(parents=True, exist_ok=True)
-    print(f"Les résultats JSON seront sauvegardés dans : {local_output_dir}")
+            processed_files.append(pdf_path.name)
+            status_box.update(value="\n".join(processed_files))
 
-    all_results = []
-    for pdf_path in tqdm(pdf_files, desc="Traitement des PDFs"):
-        result = process_single_pdf(pdf_path, extractor_pipeline)
-        all_results.append(result)
+    thread = threading.Thread(target=background_task)
+    thread.start()
 
-        # Sauvegarder le résultat individuel
-        output_json_path = local_output_dir / f"{pdf_path.stem}.json"
-        with open(output_json_path, "w", encoding="utf-8") as f:
-            json.dump(result, f, ensure_ascii=False, indent=2)
+def launch_processing(status_box):
+    start_background_processing(status_box)
+    return "✅ Traitement lancé."
 
-    # Sauvegarder le fichier agrégé
-    aggregate_file_path = local_output_dir / "_aggregate_results.json"
-    with open(aggregate_file_path, "w", encoding="utf-8") as f:
-        json.dump(all_results, f, ensure_ascii=False, indent=2)
+with gr.Blocks() as demo:
+    gr.Markdown("# 📊 Extraction BRVM automatisée")
+    gr.Markdown("Le modèle est chargé au démarrage. Cliquez sur le bouton pour lancer le traitement des bulletins.")
     
-    print(f"Traitement terminé. {len(pdf_files)} fichiers traités.")
-
-    # Upload des résultats
-    upload_results_to_hf(local_output_dir, HF_DATASET_JSON_REPO_ID, HF_TOKEN)
-
+    status_box = gr.Textbox(label="Fichiers traités", lines=20)
+    launch_button = gr.Button("🚀 Lancer le traitement")
+    launch_button.click(launch_processing, inputs=[status_box], outputs=[status_box])
 
-if __name__ == "__main__":
-    main()
+load_model()
+demo.launch()

requirements.txt

@@ -7,3 +7,4 @@ huggingface_hub
 bitsandbytes
 sentencepiece # NOUVELLE DÉPENDANCE
 accelerate
+gradio

script_brvm.py

@@ -0,0 +1,148 @@
+# script_brvm.py
+
+import fitz  # PyMuPDF
+import json
+from pathlib import Path
+import torch
+from transformers import pipeline, AutoModelForCausalLM, AutoTokenizer, BitsAndBytesConfig
+import os
+from huggingface_hub import hf_hub_download, HfApi
+from datetime import datetime
+import zipfile
+
+# ---------- CONFIGURATION ----------
+MODEL_ID = "mistralai/Mistral-7B-Instruct-v0.3"
+PROMPT_TEMPLATE = """
+[INST]Tu es un expert en analyse de données financières de la BRVM. Extrais les informations du texte suivant et retourne-les sous la forme d'un objet JSON unique et valide. Ta réponse doit commencer par `{{` et se terminer par `}}`. N'inclus aucun texte, explication ou formatage en dehors de l'objet JSON.
+
+**Texte du bulletin à analyser :**
+{texte_pdf}[/INST]
+"""
+
+MAX_NEW_TOKENS = 8192
+
+# ---------- MODÈLE ----------
+def initialize_model_pipeline():
+    try:
+        bnb_config = BitsAndBytesConfig(
+            load_in_4bit=True,
+            bnb_4bit_quant_type="nf4",
+            bnb_4bit_compute_dtype=torch.bfloat16,
+            bnb_4bit_use_double_quant=True,
+        )
+
+        tokenizer = AutoTokenizer.from_pretrained(MODEL_ID)
+        model = AutoModelForCausalLM.from_pretrained(
+            MODEL_ID,
+            quantization_config=bnb_config,
+            device_map="auto",
+            torch_dtype=torch.bfloat16,
+            trust_remote_code=True
+        )
+
+        if tokenizer.pad_token is None:
+            tokenizer.pad_token = tokenizer.eos_token
+
+        extractor_pipeline = pipeline(
+            "text-generation",
+            model=model,
+            tokenizer=tokenizer,
+        )
+        return extractor_pipeline
+    except Exception as e:
+        print(f"Erreur chargement modèle : {e}")
+        return None
+
+# ---------- PDF ----------
+def download_and_extract_pdfs(repo_id, zip_filename, target_folder, cache_folder):
+    try:
+        local_zip_path = hf_hub_download(
+            repo_id=repo_id,
+            filename=zip_filename,
+            repo_type="dataset",
+            cache_dir=cache_folder
+        )
+
+        target_folder.mkdir(parents=True, exist_ok=True)
+        extracted_files = []
+
+        with zipfile.ZipFile(local_zip_path, 'r') as z:
+            for member in z.infolist():
+                if member.is_dir() or member.filename.startswith('/') or '..' in member.filename:
+                    continue
+                if member.filename.lower().endswith('.pdf'):
+                    target_path = target_folder / Path(member.filename).name
+                    with z.open(member) as source, open(target_path, "wb") as target:
+                        target.write(source.read())
+                    extracted_files.append(target_path)
+
+        return extracted_files
+    except Exception as e:
+        print(f"Erreur extraction PDF : {e}")
+        return []
+
+def extract_text_from_pdf(pdf_path):
+    try:
+        with fitz.open(pdf_path) as doc:
+            return "\n".join(page.get_text() for page in doc)
+    except Exception as e:
+        print(f"Erreur lecture PDF : {e}")
+        return ""
+
+# ---------- TRAITEMENT ----------
+def parse_json_from_model_output(raw_output):
+    try:
+        generated_text = raw_output.split("[/INST]")[-1].strip()
+        start_index = generated_text.find('{')
+        end_index = generated_text.rfind('}')
+        if start_index != -1 and end_index != -1 and end_index > start_index:
+            json_str = generated_text[start_index : end_index + 1]
+            return json.loads(json_str)
+        else:
+            raise ValueError("Accolades JSON non trouvées.")
+    except Exception as e:
+        return {"error": "ParsingFailed", "details": str(e), "raw_output": raw_output}
+
+def process_single_pdf(pdf_path, pipeline):
+    text = extract_text_from_pdf(pdf_path)
+    if not text.strip():
+        return {"error": "PDF vide", "source_file": pdf_path.name}
+
+    prompt = PROMPT_TEMPLATE.format(texte_pdf=text[:30000])
+    try:
+        response = pipeline(
+            prompt,
+            max_new_tokens=MAX_NEW_TOKENS,
+            temperature=0.2,
+            do_sample=False,
+            return_full_text=False,
+            pad_token_id=pipeline.tokenizer.eos_token_id
+        )
+        raw_output = response[0]['generated_text']
+        data = parse_json_from_model_output(f"[INST]{prompt}[/INST]{raw_output}")
+        data['source_file'] = pdf_path.name
+        return data
+    except Exception as e:
+        return {"error": "PipelineError", "details": str(e), "source_file": pdf_path.name}
+
+# ---------- UPLOAD ----------
+def upload_results_to_hf_single(result, repo_id, hf_token):
+    if not hf_token:
+        print("HF_TOKEN manquant.")
+        return
+    try:
+        api = HfApi(token=hf_token)
+        temp_path = Path("temp_result.json")
+        with open(temp_path, "w", encoding="utf-8") as f:
+            json.dump(result, f, ensure_ascii=False, indent=2)
+
+        api.upload_file(
+            path_or_fileobj=str(temp_path),
+            repo_id=repo_id,
+            repo_type="dataset",
+            path_in_repo=f"{result['source_file']}.json",
+            commit_message=f"Upload {result['source_file']}"
+        )
+        temp_path.unlink()
+    except Exception as e:
+        print(f"Erreur upload : {e}")