Update app.py

app.py

@@ -1,9 +1,13 @@
 import os
-import json
-import zipfile
 import time
+import zipfile
 from pathlib import Path
 from typing import List
+import shutil
+import json
+import yaml
+import datetime
+import easyocr
 import pandas as pd
 import streamlit as st
 from docling.document_converter import DocumentConverter, PdfFormatOption
@@ -14,6 +18,7 @@ from docling.datamodel.pipeline_options import (
     AcceleratorOptions,
     AcceleratorDevice,
     TableStructureOptions,
+    TableFormerMode,
     EasyOcrOptions,
     TesseractCliOcrOptions,
     TesseractOcrOptions,
@@ -23,24 +28,66 @@ from docling.datamodel.pipeline_options import (
 
 # Répertoires de sortie
 OUTPUT_DIR = Path("output")
-OUTPUT_DIR.mkdir(exist_ok=True)
-
 FIGURES_DIR = OUTPUT_DIR / "figures"
-FIGURES_DIR.mkdir(exist_ok=True)
-
 TABLES_DIR = OUTPUT_DIR / "tables"
-TABLES_DIR.mkdir(exist_ok=True)
-
-# Fonction de création de DocumentConverter
-def create_document_converter(
-    use_ocr: bool,
-    export_figures: bool,
-    export_tables: bool,
-    accelerator: str,
-    ocr_engine: str,
-    table_mode: str,
-    ocr_languages: List[str],
-) -> DocumentConverter:
+
+for directory in [OUTPUT_DIR, FIGURES_DIR, TABLES_DIR]:
+    directory.mkdir(exist_ok=True)
+
+# Récupération des langues supportées par EasyOCR
+supported_languages = easyocr.Reader(lang_list=None).lang_list
+
+# Configuration Streamlit
+st.set_page_config(page_title="Docling API UI", layout="wide")
+
+st.title("Docling Document Conversion API")
+st.sidebar.header("Configuration")
+
+# Formulaire de configuration
+use_ocr = st.sidebar.checkbox("Activer l'OCR", value=True)
+export_figures = st.sidebar.checkbox("Exporter les figures", value=True)
+export_tables = st.sidebar.checkbox("Exporter les tableaux", value=True)
+
+accelerator = st.sidebar.selectbox(
+    "Accélérateur",
+    ["auto", "cpu", "cuda", "mps"],
+    index=0,
+    format_func=lambda x: x.upper(),
+)
+
+ocr_engine = st.sidebar.selectbox(
+    "Moteur OCR",
+    ["easyocr", "tesseract_cli", "tesserocr", "rapidocr", "ocrmac"],
+    index=0,
+)
+
+ocr_languages = st.sidebar.multiselect(
+    "Langues OCR",
+    options=supported_languages,
+    default=["en"],
+)
+
+table_mode = st.sidebar.selectbox(
+    "Mode Table",
+    ["accurate", "fast"],
+    index=0,
+    format_func=lambda x: x.capitalize(),
+)
+
+export_formats = st.sidebar.multiselect(
+    "Formats d'export",
+    ["json", "yaml", "md", "multimodal"],
+    default=["md"],
+)
+
+uploaded_files = st.file_uploader(
+    "Uploader vos fichiers (PDF, DOCX, PPTX, HTML, IMAGES)",
+    type=["pdf", "docx", "pptx", "html", "png", "jpg", "jpeg"],
+    accept_multiple_files=True,
+)
+
+# Fonction pour créer le convertisseur
+def create_document_converter():
     accelerator_options = AcceleratorOptions(
         num_threads=8,
         device=AcceleratorDevice[accelerator.upper()],
@@ -51,6 +98,11 @@ def create_document_converter(
         do_cell_matching=True,
     )
 
+    # Validation des langues
+    if not all(lang in supported_languages for lang in ocr_languages):
+        st.error(f"Certaines langues sélectionnées ne sont pas prises en charge : {ocr_languages}")
+        st.stop()
+
     if ocr_engine == "easyocr":
         ocr_options = EasyOcrOptions(lang=ocr_languages)
     elif ocr_engine == "tesseract_cli":
@@ -87,46 +139,13 @@ def create_document_converter(
         },
     )
 
-# Fonction pour créer un fichier ZIP
-def create_zip_file(output_dir: Path, zip_name: str) -> str:
-    zip_path = output_dir / zip_name
-    with zipfile.ZipFile(zip_path, "w") as zipf:
-        for file_path in output_dir.rglob("*"):
-            if file_path.is_file():
-                zipf.write(file_path, arcname=file_path.relative_to(output_dir))
-    return str(zip_path)
-
-# Fonction pour calculer les métriques (exemple : temps d'inférence, nombre de tables, figures, etc.)
-def compute_metrics(conversion_results, start_time):
-    metrics = {
-        "total_documents": len(conversion_results),
-        "successful_conversions": sum(1 for res in conversion_results if res.status == ConversionStatus.SUCCESS),
-        "failed_conversions": sum(1 for res in conversion_results if res.status != ConversionStatus.SUCCESS),
-        "total_time": time.time() - start_time,
-        "tables_extracted": sum(len(res.document.tables) for res in conversion_results if res.status == ConversionStatus.SUCCESS),
-        "figures_extracted": sum(len(res.document.pictures) for res in conversion_results if res.status == ConversionStatus.SUCCESS),
-    }
-    return metrics
-
-# Interface Streamlit
-st.set_page_config(page_title="Docling Dynamic Processor", layout="wide")
-st.title("Docling Dynamic Processor - Analyse et Extraction de Documents")
-
-# Formulaire de configuration
-st.sidebar.header("Options de configuration")
-use_ocr = st.sidebar.checkbox("Activer l'OCR", value=True)
-export_figures = st.sidebar.checkbox("Exporter les figures", value=True)
-export_tables = st.sidebar.checkbox("Exporter les tableaux", value=True)
-accelerator = st.sidebar.selectbox("Accélérateur", ["cpu", "cuda", "mps"], index=0)
-ocr_engine = st.sidebar.selectbox("Moteur OCR", ["easyocr", "tesseract_cli", "tesserocr", "rapidocr", "ocrmac"])
-table_mode = st.sidebar.selectbox("Mode Table", ["accurate", "fast"], index=0)
-ocr_languages = st.sidebar.text_input("Langues OCR (ex: eng, fra)", value="eng").split(",")
+# Traitement des fichiers
+if st.button("Lancer la conversion") and uploaded_files:
+    st.info("Conversion en cours, veuillez patienter...")
 
-# Zone de téléchargement
-uploaded_files = st.file_uploader("Téléchargez vos fichiers (PDF, DOCX, etc.)", type=["pdf", "docx", "pptx"], accept_multiple_files=True)
+    converter = create_document_converter()
 
-if st.button("Lancer le traitement") and uploaded_files:
-    # Sauvegarder les fichiers téléchargés
+    # Préparer les fichiers pour le traitement
     input_paths = []
     for uploaded_file in uploaded_files:
         file_path = OUTPUT_DIR / uploaded_file.name
@@ -134,54 +153,62 @@ if st.button("Lancer le traitement") and uploaded_files:
             f.write(uploaded_file.read())
         input_paths.append(file_path)
 
-    # Démarrer le traitement
-    start_time = time.time()
-    converter = create_document_converter(
-        use_ocr,
-        export_figures,
-        export_tables,
-        accelerator,
-        ocr_engine,
-        table_mode,
-        ocr_languages,
-    )
+    # Conversion des fichiers
     conv_results = list(converter.convert_all(input_paths, raises_on_error=False))
-
-    # Traiter les fichiers et collecter les résultats
+    success_count, failure_count = 0, 0
     exported_files = {"figures": [], "tables": [], "exports": []}
+
     for conv_res in conv_results:
         if conv_res.status == ConversionStatus.SUCCESS:
+            success_count += 1
             doc_filename = conv_res.input.file.stem
 
             # Export des tableaux
             for table_ix, table in enumerate(conv_res.document.tables):
-                csv_file = OUTPUT_DIR / f"{doc_filename}-table-{table_ix+1}.csv"
+                csv_file = TABLES_DIR / f"{doc_filename}-table-{table_ix+1}.csv"
                 table.export_to_dataframe().to_csv(csv_file, index=False)
                 exported_files["tables"].append(str(csv_file))
 
-            # Export des figures (sous forme d'images)
-            for fig_ix, figure in enumerate(conv_res.document.pictures):
-                fig_file = FIGURES_DIR / f"{doc_filename}-figure-{fig_ix+1}.png"
-                figure.image.save(fig_file)
-                exported_files["figures"].append(str(fig_file))
-
-    # Générer un ZIP contenant tous les fichiers
-    zip_file = create_zip_file(OUTPUT_DIR, "exported_results.zip")
-
-    # Calcul des métriques
-    metrics = compute_metrics(conv_results, start_time)
-
-    # Afficher les résultats
-    st.success("Traitement terminé!")
-    st.metric("Documents traités avec succès", metrics["successful_conversions"])
-    st.metric("Échecs", metrics["failed_conversions"])
-    st.metric("Temps total (s)", f"{metrics['total_time']:.2f}")
-    st.metric("Total des tableaux extraits", metrics["tables_extracted"])
-    st.metric("Total des figures extraites", metrics["figures_extracted"])
-
+            # Export des formats demandés
+            for fmt in export_formats:
+                output_file = OUTPUT_DIR / f"{doc_filename}.{fmt}"
+                if fmt == "json":
+                    with open(output_file, "w", encoding="utf-8") as jf:
+                        json.dump(conv_res.document.export_to_dict(), jf, ensure_ascii=False, indent=2)
+                elif fmt == "yaml":
+                    with open(output_file, "w", encoding="utf-8") as yf:
+                        yaml.dump(conv_res.document.export_to_dict(), yf, allow_unicode=True)
+                elif fmt == "md":
+                    with open(output_file, "w", encoding="utf-8") as mf:
+                        mf.write(conv_res.document.export_to_markdown())
+                exported_files["exports"].append(str(output_file))
+
+        else:
+            failure_count += 1
+
+    # Création du fichier ZIP
+    zip_path = OUTPUT_DIR / "exports.zip"
+    with zipfile.ZipFile(zip_path, "w") as zipf:
+        for category, files in exported_files.items():
+            for file in files:
+                zipf.write(file, arcname=Path(file).name)
+
+    # Affichage des résultats
+    st.success(f"Conversion terminée : {success_count} fichiers convertis avec succès.")
+    if failure_count > 0:
+        st.warning(f"{failure_count} fichiers n'ont pas pu être convertis.")
+    
     st.download_button(
         label="Télécharger tous les résultats (ZIP)",
-        data=open(zip_file, "rb").read(),
-        file_name="exported_results.zip",
+        data=zip_path.read_bytes(),
+        file_name="exports.zip",
         mime="application/zip",
-    )
+    )
+
+    # Affichage des métriques
+    st.subheader("Métriques de conversion")
+    st.write(f"Fichiers traités : {len(uploaded_files)}")
+    st.write(f"Conversions réussies : {success_count}")
+    st.write(f"Échecs : {failure_count}")
+else:
+    st.info("Ajoutez des fichiers pour commencer la conversion.")