Update app.py

app.py

@@ -10,25 +10,61 @@ from langchain_core.messages import HumanMessage
 from langchain_core.caches import BaseCache
 from langchain_core.callbacks import Callbacks
 ChatGoogleGenerativeAI.model_rebuild()
-import PyPDF2
-import docx
 import pandas as pd
-from pptx import Presentation
 import io
 import tempfile
 from urllib.parse import urlparse
 import re
 
-# Import et rebuild de ChatGoogleGenerativeAI en différé
+# Import DocLing and necessary configuration classes
+from docling.document_converter import DocumentConverter, PdfFormatOption
+from docling.datamodel.pipeline_options import PdfPipelineOptions
+from docling.datamodel.base_models import InputFormat
+
+# Import and rebuild ChatGoogleGenerativeAI deferred
 try:
     from langchain_google_genai import ChatGoogleGenerativeAI
     from langchain_core.caches import BaseCache
     ChatGoogleGenerativeAI.model_rebuild()
 except Exception as e:
-    print(f"Avertissement lors du rebuild: {e}")
+    print(f"Warning during rebuild: {e}")
     from langchain_google_genai import ChatGoogleGenerativeAI
 
-# Configuration des modèles
+# --- START OF OCR CONFIGURATION ---
+# Create a single, pre-configured DocumentConverter instance to be reused.
+# This is more efficient than creating it on every function call.
+
+# 1. Define the pipeline options to enable OCR for PDFs.
+# Configure a single global DocLing converter with Tesseract OCR enabled and all languages
+# Note: With tesseract-ocr-all installed, all language data files are available.
+pdf_options = PdfPipelineOptions(
+    do_ocr=True,
+    ocr_model="tesseract",
+    # Provide a broad default set. With tesseract-ocr-all, many language packs exist.
+    # You can keep this small for speed or expand it. Here we include a practical wide set.
+    ocr_languages=[
+        "eng","fra","deu","spa","ita","por","nld","pol","tur","ces","rus","ukr","ell","ron","hun",
+        "bul","hrv","srp","slk","slv","lit","lav","est","cat","eus","glg","isl","dan","nor","swe",
+        "fin","alb","mlt","afr","zul","swa","amh","uzb","aze","kaz","kir","mon","tgl","ind","msa",
+        "tha","vie","khm","lao","mya","ben","hin","mar","guj","pan","mal","tam","tel","kan","nep",
+        "sin","urd","fas","pus","kur","aze_cyrl","tat","uig","heb","ara","yid","grc","chr","epo",
+        "hye","kat","kat_old","aze_latn","mkd","bel","srp_latn","srp_cyrillic",
+        # CJK — these are heavier and slower; include only if needed:
+        "chi_sim","chi_tra","jpn","kor"
+    ]
+)
+
+# 2. Create the format-specific configuration.
+format_options = {
+    InputFormat.PDF: PdfFormatOption(pipeline_options=pdf_options)
+}
+
+# 3. Initialize the converter with the OCR configuration.
+# This converter will now automatically perform OCR on any PDF file.
+docling_converter = DocumentConverter(format_options=format_options)
+# --- END OF OCR CONFIGURATION ---
+
+# Model configuration
 MODELS = {
     "Gemini 2.5 Flash (Google AI)": {
         "provider": "Google AI",
@@ -56,61 +92,67 @@ MODELS = {
     }
 }
 
-# API par défaut pour Gemini 2.5 Flash via HF Spaces Secrets
+# Default API for Gemini 2.5 Flash via HF Spaces Secrets
 DEFAULT_GEMINI_API = os.getenv("FLASH_GOOGLE_API_KEY")
 
 def extract_text_from_file(file):
-    """Extrait le texte d'un fichier uploadé"""
+    """
+    Extract text from an uploaded file or path (str).
+    - Accepts an object with .name attribute (e.g. Gradio upload) OR a file path (str).
+    - DocLing for: .pdf (Tesseract OCR enabled if configured), .docx, .xlsx, .pptx
+    - Converts .csv /.xls -> temporary .xlsx then DocLing
+    - .txt read directly
+    """
     if file is None:
         return ""
-    file_extension = os.path.splitext(file.name)[1].lower()
+
+    # Normalize to a filesystem path string
+    path = file.name if hasattr(file, "name") else str(file)
+    ext = os.path.splitext(path)[1].lower()
+
+    docling_direct = {".pdf", ".docx", ".xlsx", ".pptx"}
+    to_xlsx_first = {".csv", ".xls"}
+
     try:
-        if file_extension == '.pdf':
-            with open(file.name, 'rb') as f:
-                reader = PyPDF2.PdfReader(f)
-                text = ""
-                for page in reader.pages:
-                    text += page.extract_text() + "\n"
-                return text
-        elif file_extension == '.docx':
-            doc = docx.Document(file.name)
-            text = ""
-            for paragraph in doc.paragraphs:
-                text += paragraph.text + "\n"
-            return text
-        elif file_extension == '.txt':
-            with open(file.name, 'r', encoding='utf-8') as f:
+        if ext in docling_direct:
+            result = docling_converter.convert(path)
+            return result.document.export_to_markdown()
+
+        elif ext in to_xlsx_first:
+            # Convert CSV/XLS -> XLSX
+            if ext == ".csv":
+                df = pd.read_csv(path)
+            else:  # .xls
+                df = pd.read_excel(path)
+
+            with tempfile.NamedTemporaryFile(delete=True, suffix=".xlsx") as tmp:
+                df.to_excel(tmp.name, index=False)
+                result = docling_converter.convert(tmp.name)
+                return result.document.export_to_markdown()
+
+        elif ext == ".txt":
+            with open(path, "r", encoding="utf-8") as f:
                 return f.read()
-        elif file_extension in ['.xlsx', '.xls']:
-            df = pd.read_excel(file.name)
-            return df.to_string()
-        elif file_extension == '.pptx':
-            prs = Presentation(file.name)
-            text = ""
-            for slide in prs.slides:
-                for shape in slide.shapes:
-                    if hasattr(shape, "text"):
-                        text += shape.text + "\n"
-            return text
+
         else:
-            return "Format de fichier non supporté"
+            return "Unsupported file format"
     except Exception as e:
-        return f"Erreur lors de la lecture du fichier: {str(e)}"
+        return f"Error reading file: {str(e)}"
 
 def extract_text_from_url(url):
-    """Extrait le texte d'une URL"""
+    """Extract text from a URL"""
     try:
         response = requests.get(url, timeout=10)
         response.raise_for_status()
         content = response.text
         content = re.sub(r'<[^>]+>', '', content)
         content = re.sub(r'\s+', ' ', content).strip()
-        return content[:10000]  # Limite à 10k caractères
+        return content[:10000]  # Limit to 10k characters
     except Exception as e:
-        return f"Erreur lors de la récupération de l'URL: {str(e)}"
+        return f"Error retrieving URL: {str(e)}"
 
 def get_document_content(text_input, url_input, file_input):
-    """Récupère le contenu du document selon la source"""
+    """Retrieve document content based on source"""
     if text_input.strip():
         return text_input.strip()
     elif url_input.strip():
@@ -121,7 +163,7 @@ def get_document_content(text_input, url_input, file_input):
         return ""
 
 def create_llm_instance(model_name, api_key):
-    """Crée une instance du modèle LLM"""
+    """Create an LLM model instance"""
     model_config = MODELS[model_name]
     if model_config["provider"] == "OpenAI":
         return model_config["class"](
@@ -144,24 +186,24 @@ def create_llm_instance(model_name, api_key):
         )
 
 def generate_html(model_name, api_key, text_input, url_input, file_input):
-    """Génère le fichier HTML éducatif"""
+    """Generate educational HTML file"""
     start_time = time.time()
     if model_name != "Gemini 2.5 Flash (Google AI)" and not api_key.strip():
-        return None, "❌ Erreur: Veuillez fournir une clé API pour ce modèle.", 0
+        return None, "❌ Error: Please provide an API key for this model.", 0
 
     document_content = get_document_content(text_input, url_input, file_input)
     if not document_content:
-        return None, "❌ Erreur: Veuillez fournir un document (texte, URL ou fichier).", 0
+        return None, "❌ Error: Please provide a document (text, URL or file).", 0
 
     try:
-        # Création de l'instance LLM
+        # Create LLM instance
         llm = create_llm_instance(model_name, api_key)
 
-        # Lecture du prompt template
+        # Read prompt template
         with open("creation_educational_html_from_any_document_18082025.txt", "r", encoding="utf-8") as f:
             prompt_template = f.read()
 
-        # Remplacement des variables
+        # Replace variables
         model_config = MODELS[model_name]
         prompt = prompt_template.format(
             model_name=model_config["model_name"],
@@ -169,33 +211,33 @@ def generate_html(model_name, api_key, text_input, url_input, file_input):
             document=document_content
         )
 
-        # Génération du contenu
+        # Generate content
         message = HumanMessage(content=prompt)
         response = llm.invoke([message])
         html_content = response.content
 
-        # Nettoyage des éventuelles balises de code des modèles
+        # Clean any code tags from models
         html_content = html_content.replace("```html", "")
         html_content = html_content.replace("```", "")
 
-        # Calcul du temps de génération
+        # Calculate generation time
         generation_time = time.time() - start_time
 
-        # Sauvegarde du fichier HTML
+        # Save HTML file
         timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
-        filename = f"document_educatif_{timestamp}.html"
+        filename = f"educational_document_{timestamp}.html"
         with open(filename, "w", encoding="utf-8") as f:
             f.write(html_content)
 
-        success_message = f"✅ Fichier HTML généré avec succès en {generation_time:.2f} secondes!"
+        success_message = f"✅ HTML file generated successfully in {generation_time:.2f} seconds!"
         return filename, success_message, generation_time
 
     except Exception as e:
-        error_message = f"❌ Erreur lors de la génération: {str(e)}"
+        error_message = f"❌ Error during generation: {str(e)}"
         return None, error_message, 0
 
 def reset_form():
-    """Remet à zéro le formulaire"""
+    """Reset the form to zero"""
     return (
         "Gemini 2.5 Flash (Google AI)",  # model_name
         "",  # api_key
@@ -208,23 +250,23 @@ def reset_form():
     )
 
 def update_api_info(model_name):
-    """Met à jour les informations sur l'API selon le modèle sélectionné"""
+    """Update API information based on selected model"""
     if model_name == "Gemini 2.5 Flash (Google AI)":
         return gr.update(
-            label="Clé API (optionnelle)",
-            placeholder="API gratuite disponible jusqu'à épuisement, ou utilisez votre propre clé",
-            info="💡 Une API gratuite est déjà configurée pour ce modèle. Vous pouvez utiliser votre propre clé si vous le souhaitez."
+            label="API Key (optional)",
+            placeholder="Free API available until exhausted, or use your own key",
+            info="💡 A free API is already configured for this model. You can use your own key if you wish."
         )
     else:
         return gr.update(
-            label="Clé API (obligatoire)",
-            placeholder="Entrez votre clé API",
-            info="🔑 Clé API requise pour ce modèle"
+            label="API Key (required)",
+            placeholder="Enter your API key",
+            info="🔑 API key required for this model"
         )
 
-# Interface Gradio (Apple-like)
+# Gradio Interface (Apple-like)
 with gr.Blocks(
-    title="EduHTML Creator - Générateur de contenu éducatif HTML",
+    title="EduHTML Creator - Educational HTML Content Generator",
     theme=gr.themes.Soft(),
     css="""
 /* ==== Apple-inspired Global Reset & Typography ==== */
@@ -351,14 +393,14 @@ html, body {
   border-radius: var(--radius-lg);
   overflow: hidden;
   background: var(--apple-black);
-  color: #ffff !important;    /* Force texte blanc */
+  color: #ffff !important;    /* Force white text */
   box-shadow: var(--shadow-soft);
 }
 .header, .header * {
-  color: #ffff !important;    /* Tout le contenu en blanc */
+  color: #ffff !important;    /* All content in white */
 }
 .header a, .header a:visited, .header a:active {
-  color: #ffff !important;    /* Liens blancs */
+  color: #ffff !important;    /* White links */
   text-decoration: underline;
   text-underline-offset: var(--link-underline-offset);
 }
@@ -542,14 +584,14 @@ input:focus, textarea:focus {
   border-radius: var(--radius-lg);
   overflow: hidden;
   background: var(--apple-black);
-  color: #ffff !important;    /* Force texte blanc */
+  color: #ffff !important;    /* Force white text */
   box-shadow: var(--shadow-soft);
 }
 .footer, .footer * {
-  color: #ffff !important;    /* Tout le contenu en blanc */
+  color: #ffff !important;    /* All content in white */
 }
 .footer a, .footer a:visited, .footer a:active {
-  color: #ffff !important;    /* Liens blancs */
+  color: #ffff !important;    /* White links */
   text-decoration: underline;
   text-underline-offset: var(--link-underline-offset);
 }
@@ -585,155 +627,155 @@ a { text-decoration: underline; text-underline-offset: var(--link-underline-offs
         <div class="header-inner">
             <h1>🎓 EduHTML Creator</h1>
             <p>
-                Transformez n'importe quel document en contenu éducatif HTML interactif, avec un design premium inspiré d'Apple.
-                Fidélité au document, structuration claire, interactivité, et mise en valeur des informations clés.
+                Transform any document into interactive educational HTML content, with a premium Apple-inspired design.
+                Document fidelity, clear structure, interactivity, and highlighting of key information.
             </p>
         </div>
     </div>
     """)
 
     with gr.Column(elem_classes=["main-container"]):
-        # Section Configuration du modèle
+        # Model Configuration Section
         gr.HTML("<div class='section'>")
         model_dropdown = gr.Dropdown(
             choices=list(MODELS.keys()),
             value="Gemini 2.5 Flash (Google AI)",
-            label="Modèle LLM",
-            info="Sélectionnez le modèle à utiliser pour la génération"
+            label="LLM Model",
+            info="Select the model to use for generation"
         )
 
         api_input = gr.Textbox(
-            label="Clé API (optionnelle)",
-            placeholder="API gratuite (Gemini Flash) disponible. Vous pouvez entrer votre propre clé.",
-            info="Pour OpenAI/Anthropic, une clé est obligatoire.",
+            label="API Key (optional)",
+            placeholder="Free API (Gemini Flash) available. You can enter your own key.",
+            info="For OpenAI/Anthropic, a key is required.",
             type="password"
         )
         gr.HTML("</div>")
 
-        # Section Source du document avec onglets
+        # Document Source Section with tabs
         gr.HTML("<div class='section alt'>")
-        gr.HTML("<h3>Source du document</h3>")
+        gr.HTML("<h3>Document Source</h3>")
         
         with gr.Tabs():
-            with gr.TabItem("📝 Texte"):
+            with gr.TabItem("📝 Text"):
                 text_input = gr.Textbox(
-                    label="Texte copié/collé",
-                    placeholder="Collez votre texte ici...",
+                    label="Copied/pasted text",
+                    placeholder="Paste your text here...",
                     lines=4
                 )
             
             with gr.TabItem("🌐 URL"):
                 url_input = gr.Textbox(
-                    label="Lien Web",
-                    placeholder="https://exemple.com/article"
+                    label="Web Link",
+                    placeholder="https://example.com/article"
                 )
             
-            with gr.TabItem("📁 Fichier"):
+            with gr.TabItem("📁 File"):
                 file_input = gr.File(
-                    label="Fichier",
+                    label="File",
                     file_types=[".pdf", ".txt", ".docx", ".xlsx", ".xls", ".pptx"]
                 )
         
         gr.HTML("</div>")
 
-        # Boutons d'action
+        # Action buttons
         with gr.Row():
-            submit_btn = gr.Button("Générer le HTML", variant="primary", elem_classes=["apple-button"])
+            submit_btn = gr.Button("Generate HTML", variant="primary", elem_classes=["apple-button"])
             reset_btn = gr.Button("Reset", elem_classes=["reset-button"])
 
-        # Section Résultats
-        status_output = gr.HTML(label="Statut")
+        # Results Section
+        status_output = gr.HTML(label="Status")
         gr.HTML("<div class='section preview-card'>")
-        gr.HTML("<div class='preview-header'><div class='preview-dot' aria-hidden='true'></div><div>Prévisualisation</div></div>")
-        html_preview = gr.HTML(label="Prévisualisation", visible=False, elem_id="html-preview", elem_classes=["preview-body"])
-        html_file_output = gr.File(label="Fichier HTML téléchargeable", visible=False)
+        gr.HTML("<div class='preview-header'><div class='preview-dot' aria-hidden='true'></div><div>Preview</div></div>")
+        html_preview = gr.HTML(label="Preview", visible=False, elem_id="html-preview", elem_classes=["preview-body"])
+        html_file_output = gr.File(label="Downloadable HTML file", visible=False)
         gr.HTML("</div>")
 
-    # Footer (black)
-    gr.HTML("""
-    <div class="footer" role="contentinfo">
-        <div class="footer-inner">
-            <span>Design inspiré d'Apple • Contrastes élevés • Interactions fluides</span>
+        # Footer (black)
+        gr.HTML("""
+        <div class="footer" role="contentinfo">
+            <div class="footer-inner">
+                <span>Apple-inspired design • High contrasts • Smooth interactions</span>
+            </div>
         </div>
-    </div>
-    """)
+        """)
+
+        # Light JS: smooth scroll to top, inline burger, focus handling
+        gr.HTML("""
+        <script>
+        (function() {
+            const menuBtn = document.getElementById('inlineMenuBtn');
+            const menu = document.getElementById('inlineMenu');
+            const topLink = document.getElementById('scrollTopLink');
+
+            function closeMenu() {
+                if (!menu) return;
+                menu.classList.remove('open');
+                menu.setAttribute('aria-hidden', 'true');
+            }
 
-    # Light JS: smooth scroll to top, inline burger, focus handling
-    gr.HTML("""
-    <script>
-    (function() {
-        const menuBtn = document.getElementById('inlineMenuBtn');
-        const menu = document.getElementById('inlineMenu');
-        const topLink = document.getElementById('scrollTopLink');
-
-        function closeMenu() {
-            if (!menu) return;
-            menu.classList.remove('open');
-            menu.setAttribute('aria-hidden', 'true');
-        }
-
-        if (menuBtn && menu) {
-            menuBtn.addEventListener('click', function(e) {
-                e.preventDefault();
-                const isOpen = menu.classList.contains('open');
-                if (isOpen) {
+            if (menuBtn && menu) {
+                menuBtn.addEventListener('click', function(e) {
+                    e.preventDefault();
+                    const isOpen = menu.classList.contains('open');
+                    if (isOpen) {
+                        closeMenu();
+                    } else {
+                        menu.classList.add('open');
+                        menu.setAttribute('aria-hidden', 'false');
+                    }
+                });
+            }
+
+            if (topLink) {
+                topLink.addEventListener('click', function(e) {
+                    e.preventDefault();
+                    window.scrollTo({ top: 0, behavior: 'smooth' });
+                    closeMenu();
+                });
+            }
+
+            // Close when clicking outside
+            document.addEventListener('click', function(e) {
+                if (!menu || !menuBtn) return;
+                if (!menu.contains(e.target) && !menuBtn.contains(e.target)) {
                     closeMenu();
-                } else {
-                    menu.classList.add('open');
-                    menu.setAttribute('aria-hidden', 'false');
                 }
             });
-        }
 
-        if (topLink) {
-            topLink.addEventListener('click', function(e) {
-                e.preventDefault();
-                window.scrollTo({ top: 0, behavior: 'smooth' });
-                closeMenu();
+            // Accessibility: close on Escape
+            document.addEventListener('keydown', function(e) {
+                if (e.key === 'Escape') closeMenu();
             });
-        }
-
-        // Close when clicking outside
-        document.addEventListener('click', function(e) {
-            if (!menu || !menuBtn) return;
-            if (!menu.contains(e.target) && !menuBtn.contains(e.target)) {
-                closeMenu();
-            }
-        });
-
-        // Accessibility: close on Escape
-        document.addEventListener('keydown', function(e) {
-            if (e.key === 'Escape') closeMenu();
-        });
-    })();
-    </script>
-    """)
-
-    # Événements
-    model_dropdown.change(
-        fn=update_api_info,
-        inputs=[model_dropdown],
-        outputs=[api_input]
-    )
+        })();
+        </script>
+        """)
+
+        # Events
+        model_dropdown.change(
+            fn=update_api_info,
+            inputs=[model_dropdown],
+            outputs=[api_input]
+        )
 
-    submit_btn.click(
-        fn=generate_html,
-        inputs=[model_dropdown, api_input, text_input, url_input, file_input],
-        outputs=[html_file_output, status_output, gr.State()]
-    ).then(
-        fn=lambda file, status, _: (
-            gr.update(visible=file is not None),
-            status,
-            gr.update(visible=file is not None, value=(open(file, 'r', encoding='utf-8').read() if file else ""))
-        ),
-        inputs=[html_file_output, status_output, gr.State()],
-        outputs=[html_file_output, status_output, html_preview]
-    )
+        submit_btn.click(
+            fn=generate_html,
+            inputs=[model_dropdown, api_input, text_input, url_input, file_input],
+            outputs=[html_file_output, status_output, gr.State()]
+        ).then(
+            fn=lambda file, status, _: (
+                gr.update(visible=file is not None),
+                status,
+                gr.update(visible=file is not None, value=(open(file, 'r', encoding='utf-8').read() if file else ""))
+            ),
+            inputs=[html_file_output, status_output, gr.State()],
+            outputs=[html_file_output, status_output, html_preview]
+        )
 
-    reset_btn.click(
-        fn=reset_form,
-        outputs=[model_dropdown, api_input, text_input, url_input, file_input, status_output, html_file_output, html_preview]
-    )
+        reset_btn.click(
+            fn=reset_form,
+            outputs=[model_dropdown, api_input, text_input, url_input, file_input, status_output, html_file_output, html_preview]
+        )
 
 if __name__ == "__main__":
     app.launch(