doc-ai-runtime 0.1.0__py3-none-any.whl

doc_ai_runtime-0.1.0.dist-info/METADATA

@@ -0,0 +1,106 @@
+Metadata-Version: 2.4
+Name: doc-ai-runtime
+Version: 0.1.0
+Summary: Modular Document AI Runtime for RAG and Markdown exports.
+Author-email: Alain Kalombo <alain.kalombo@anztech.dev>
+License: MIT
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: python-docx
+Requires-Dist: python-pptx
+Requires-Dist: openpyxl
+Requires-Dist: pytesseract
+Requires-Dist: Pillow
+Requires-Dist: PyMuPDF
+Requires-Dist: surya-ocr
+Requires-Dist: ollama
+Dynamic: license-file
+
+# 📄 Document AI Runtime
+
+Un pipeline modulaire et extensible pour l'extraction de documents (OCR et Bureautique), conçu pour transformer des PDF, images et Word en formats structurés (Markdown et RAG).
+
+Inspiré des capacités de solutions comme ABBYY, ce runtime repose sur une architecture de plugins indépendants manipulant un modèle de données canonique (DOM). 
+
+## 🚀 Fonctionnalités
+
+* **Multi-Formats natifs et OCR :**
+  * **Bureautique (Path B)** : DOCX, XLSX (Excel), PPTX (PowerPoint) extraits nativement.
+  * **PDF Hybride** : Extrait le calque texte natif, et bascule automatiquement sur l'OCR (Surya + Tesseract) pour les pages scannées.
+  * **Images (Path A)** : JPG, PNG traités via IA (Surya Layout + Tesseract OCR).
+* **Moteur XY-Cut** : Algorithme récursif de coupe verticale/horizontale pour reconstruire l'ordre de lecture des documents multi-colonnes complexes.
+* **Exports spécialisés :** Markdown (structuré) et RAG (JSON chunké avec métadonnées).
+
+## 📦 Installation
+
+Installer la bibliothèque et ses dépendances :
+
+	```bash
+	pip install -e .
+
+## 🛠 Architecture
+
+Le projet est construit autour de 4 piliers :
+1. **Le DOM (Document Object Model) :** Des classes Python (`Document`, `Page`, `Region`, `Block`, `Table`, `Cell`) qui modélisent le document de bout en bout.
+2. **Les Interfaces :** `IDocumentLoader` et `IDocumentPlugin` garantissent que tous les modules (Surya, Tesseract, python-docx) communiquent avec le même langage.
+3. **Les Plugins :** Chaque étape (chargement, layout, OCR) est un module interchangeable dans `src/plugins/`. *Remplacer Surya par un autre moteur de layout n'impacte pas le reste du code.*
+4. **Le Pipeline Runner :** L'orchestrateur qui détecte le type de fichier et exécute le bon chemin (A ou B) automatiquement.
+
+## 📦 Installation
+
+### 1. Prérequis Python
+Clonez le dépôt et installez les dépendances Python :
+	```bash
+	pip install python-docx pytesseract Pillow PyMuPDF surya-ocr
+
+### 2. Dépendances Système
+	Tesseract OCR :
+		Windows : Téléchargez l'installeur sur UB-Mannheim et ajoutez-le au PATH.
+		Linux : sudo apt install tesseract-ocr
+	Surya OCR (Optionnel) : Nécessite llama.cpp pour fonctionner. Le runner peut fonctionner avec Tesseract seul si Surya n'est pas configuré.
+
+🏃 Utilisation
+
+	Le runtime s'utilise via le script test_runtime.py (ou votre propre script) qui appelle le PipelineRunner.
+
+	from src.core.pipeline.runner import PipelineRunner
+
+	runner = PipelineRunner()
+
+# Pour un PDF ou une Image -> Export Markdown
+
+	result_md = runner.process("mon_document.pdf", export_mode="markdown")
+	print(result_md)
+
+# Pour un Word -> Export RAG
+
+	result_rag = runner.process("mon_document.docx", export_mode="rag")
+	print(result_rag)
+
+🏃 Utilisation (CLI)
+
+	python main.py --file mon_document.pdf --export markdown
+
+🗂 Structure du dépôt
+
+	doc-ai-runtime/
+	├── src/
+	│   ├── core/               # Le cœur (DOM, Interfaces, Runner)
+	│   │   ├── dom/            # Modèles de données (Document, Page, Block...)
+	│   │   └── pipeline/       # Orchestrateur (runner.py)
+	│   ├── plugins/            # Les briques interchangeables
+	│   │   ├── loaders/        # ImageLoader, PdfLoader, DocxLoader
+	│   │   ├── layout/         # SuryaLayoutPlugin
+	│   │   └── ocr/           # TesseractOCRPlugin
+	│   └── exporters/         # MarkdownExporter, RagExporter
+	├── test_runtime.py         # Script de démonstration
+	└── README.md
+
+🗺 Feuille de route (Roadmap)
+
+	 Document Object Model (DOM)
+	 Loaders (DOCX, Images, PDF)
+	 Layout Analysis (Surya) & OCR (Tesseract)
+	 Exporters Markdown et RAG
+	 Image Quality Analyzer (pré-traitement des scans)
+	 Amélioration du moteur d'ordre de lecture (Reading Order Engine)

doc_ai_runtime-0.1.0.dist-info/RECORD

@@ -0,0 +1,20 @@
+doc_ai_runtime-0.1.0.dist-info/licenses/LICENSE,sha256=tL9eo6BFrOVRvdUfn_h1vai0pGZjWcqKS_uiux8SZcc,1093
+src/core/config.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+src/core/interfaces.py,sha256=XXeVNfhq4mjdcgkndN5xseomPd-2rwqE26JCM5Iacsw,1290
+src/core/dom/models.py,sha256=k3yunJwLEKUONEpFOOi8FYq6rMfQ3zlaDkzKjrvt_4I,4037
+src/core/pipeline/runner.py,sha256=KY6_Ze62snjR956zRCkcSrDRkjwDTcIeCZZIG3dRmU8,3342
+src/exporters/markdown.py,sha256=GoKNdBv-OkhOnmk_SB0qkAUALP7GICdkaE7G1Kfb_98,2669
+src/exporters/rag.py,sha256=ZQ0uagGCeJwam9w4cSp7Y3S6QBCT5P5FU4dWYqSJtQM,3372
+src/plugins/layout/surya_layout.py,sha256=-yCSGxhkSj_KkYw4UjIXVzVyot2VTAyyhz1BYVougmw,3082
+src/plugins/loaders/docx_loader.py,sha256=69jfe1xzNYAfBtVAQlAJfKRUw3t_AbXKvE213HaOTRg,3687
+src/plugins/loaders/image_loader.py,sha256=qxg76hhCE66tCzjRE97jkwPwcBblKv0k-z6IxOD4QFE,1431
+src/plugins/loaders/pdf_loader.py,sha256=xC5H5ejmXFnH4syIwvnEKiGK5w5uJYn79lBFlmLRBbY,4054
+src/plugins/loaders/pptx_loader.py,sha256=4t78i7-bxdhZJlSXUcrjTXyPETRpthgqzxMR7NXP0k0,2546
+src/plugins/loaders/xlsx_loader.py,sha256=w4mmwF4ptEj-dLqmSIg3X3cw9a7SP0UXlq2Dph4kiFk,1805
+src/plugins/ocr/qwen_ocr.py,sha256=JHcUbRiudisyrEXIhqmSrVyYerC2vR6saliCJ4Ul-t8,3251
+src/plugins/ocr/tesseract_ocr.py,sha256=4EE9cPCnAiTwjExf9kx9t9dRtGNEti1kt-x9JQQv8Rs,3953
+src/plugins/reading_order/reading_order_engine.py,sha256=YvEuk_XtqCpT3-9yBZmciQD7FxzpqcICjoxn5-Nesx8,4053
+doc_ai_runtime-0.1.0.dist-info/METADATA,sha256=QCx2ZNmbvbbRQomdk-0S_jolBqHVGpcyELK4uE7DTfU,4412
+doc_ai_runtime-0.1.0.dist-info/WHEEL,sha256=K260EYznzXsJYBQGqmI8VTxEdiZYNvDZwW9cBh9-_MA,91
+doc_ai_runtime-0.1.0.dist-info/top_level.txt,sha256=74rtVfumQlgAPzR5_2CgYN24MB0XARCg0t-gzk6gTrM,4
+doc_ai_runtime-0.1.0.dist-info/RECORD,,

doc_ai_runtime-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (83.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

doc_ai_runtime-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,22 @@
+MIT License
+
+Copyright (c) 2026 alain2022kalo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+

doc_ai_runtime-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+src

src/core/dom/models.py

@@ -0,0 +1,127 @@
+from __future__ import annotations
+from dataclasses import dataclass, field
+from typing import List, Optional, Dict, Any
+from enum import Enum
+
+class RegionType(Enum):
+    TITLE = "title"
+    TEXT = "text"
+    TABLE = "table"
+    IMAGE = "image"
+    LIST = "list"
+    CAPTION = "caption"
+    HEADER = "header"
+    FOOTER = "footer"
+
+class BlockType(Enum):
+    TEXT = "text"
+    TABLE_CELL = "table_cell"
+    IMAGE = "image"
+    EMPTY = "empty"
+
+@dataclass
+class BoundingBox:
+    """Représente les coordonnées spatiales d'un élément sur la page."""
+    x: float
+    y: float
+    width: float
+    height: float
+    confidence: float = 1.0
+
+@dataclass
+class Style:
+    """Définit le style typographique d'un bloc de texte."""
+    font_name: Optional[str] = None
+    font_size: Optional[float] = None
+    bold: bool = False
+    italic: bool = False
+    underline: bool = False
+    color: Optional[str] = None  # Format hexadécimal, ex: '#000000'
+
+@dataclass
+class Cell:
+    """Représente une cellule d'un tableau."""
+    bbox: BoundingBox
+    text: str = ""
+    row_span: int = 1
+    col_span: int = 1
+    is_header: bool = False
+    confidence: float = 1.0
+
+@dataclass
+class Table:
+    """Représente un tableau structuré."""
+    bbox: BoundingBox
+    rows: int = 0
+    cols: int = 0
+    cells: List[Cell] = field(default_factory=list)
+    reading_order: int = 0
+
+    def get_markdown(self) -> str:
+        """Méthode utilitaire pour un export Markdown rapide (utile plus tard)."""
+        if not self.cells:
+            return ""
+        # Logique de génération Markdown basique à implémenter
+        return "[Tableau Markdown]"
+
+@dataclass
+class Image:
+    """Représente une image détectée dans le document."""
+    bbox: BoundingBox
+    image_data: Optional[bytes] = None  # Stockage binaire ou base64
+    image_path: Optional[str] = None   # Chemin si sauvegardée sur disque
+    caption: Optional[str] = None
+    reading_order: int = 0
+
+@dataclass
+class Block:
+    """L'unité de base de contenu (texte, image, etc.)."""
+    bbox: BoundingBox
+    block_type: BlockType = BlockType.TEXT
+    text: str = ""
+    style: Style = field(default_factory=Style)
+    reading_order: int = 0  # Indispensable pour le RAG et le Markdown
+    confidence: float = 1.0
+    heading_level: Optional[int] = None  # <-- AJOUT : None si ce n'est pas un titre, 1 pour H1, 2 pour H2, etc.
+
+@dataclass
+class Region:
+    """Une zone logique de la page regroupant des blocs."""
+    bbox: BoundingBox
+    region_type: RegionType = RegionType.TEXT
+    blocks: List[Block] = field(default_factory=list)
+    tables: List[Table] = field(default_factory=list)
+    images: List[Image] = field(default_factory=list)
+    reading_order: int = 0
+
+@dataclass
+class Page:
+    """Représente une page physique du document."""
+    page_number: int
+    width: float
+    height: float
+    regions: List[Region] = field(default_factory=list)
+    image_path: Optional[str] = None
+    
+    def get_all_blocks_in_reading_order(self) -> List[Block]:
+        """Retourne tous les blocs de la page triés par ordre de lecture."""
+        blocks = []
+        for region in sorted(self.regions, key=lambda r: r.reading_order):
+            blocks.extend(sorted(region.blocks, key=lambda b: b.reading_order))
+        return blocks
+
+@dataclass
+class Document:
+    """Le modèle racine représentant le document complet."""
+    source_file: str
+    pages: List[Page] = field(default_factory=list)
+    metadata: Dict[str, Any] = field(default_factory=dict) # Auteur, date, titre, etc.
+    
+    def get_text(self) -> str:
+        """Extrait tout le texte du document dans l'ordre de lecture (base pour le RAG)."""
+        full_text = []
+        for page in self.pages:
+            for block in page.get_all_blocks_in_reading_order():
+                if block.text:
+                    full_text.append(block.text)
+        return "\n\n".join(full_text)

src/core/interfaces.py

@@ -0,0 +1,41 @@
+from abc import ABC, abstractmethod
+from typing import Any
+from src.core.dom.models import Document
+
+class IDocumentLoader(ABC):
+    """
+    Interface pour les plugins de chargement (Étape 1 du pipeline).
+    Prend un fichier brut en entrée et génère l'objet Document initial.
+    """
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Retourne le nom du chargeur (ex: 'PdfLoader', 'DocxLoader')."""
+        pass
+
+    @abstractmethod
+    def load(self, file_path: str) -> Document:
+        """
+        Charge un fichier et retourne un objet Document partiellement ou 
+        totalement rempli (selon si c'est une image ou un doc natif).
+        """
+        pass
+
+class IDocumentPlugin(ABC):
+    """
+    Interface de base pour toutes les autres étapes du pipeline 
+    (Layout, OCR, Reconstruction, Exporters).
+    """
+    @property
+    @abstractmethod
+    def name(self) -> str:
+        """Retourne le nom du plugin (ex: 'SuryaLayoutAnalyzer')."""
+        pass
+
+    @abstractmethod
+    def run(self, document: Document) -> Document:
+        """
+        Reçoit l'objet Document, effectue un traitement (ajout de blocs, 
+        extraction de texte, etc.) et retourne l'objet Document mis à jour.
+        """
+        pass

src/core/pipeline/runner.py

@@ -0,0 +1,83 @@
+import os
+import platform
+
+if platform.system() == "Windows":
+    # Chemin pour ta machine Windows
+    os.environ["LLAMA_CPP_BINARY"] = r"c:\llama.cpp\llama-server.exe"
+else:
+    # Chemin pour ton serveur Ubuntu (Linux)
+    os.environ["LLAMA_CPP_BINARY"] = "/home/linuxbrew/.linuxbrew/bin/llama-server"
+    
+os.environ["SURYA_INFERENCE_BACKEND"] = "llamacpp"
+os.environ["SURYA_GUIDED_LAYOUT"] = "False"
+
+from src.plugins.loaders.image_loader import ImageLoader
+from src.plugins.loaders.docx_loader import DocxLoader
+from src.plugins.loaders.pdf_loader import PdfLoader
+from src.plugins.reading_order.reading_order_engine import ReadingOrderPlugin
+
+from src.plugins.loaders.xlsx_loader import XlsxLoader
+from src.plugins.loaders.pptx_loader import PptxLoader
+from src.plugins.ocr.qwen_ocr import QwenOCRPlugin
+
+from src.plugins.layout.surya_layout import SuryaLayoutPlugin
+from src.plugins.ocr.tesseract_ocr import TesseractOCRPlugin
+from src.exporters.markdown import MarkdownExporter
+from src.exporters.rag import RagExporter
+
+class PipelineRunner:
+    def __init__(self):
+        self.markdown_exporter = MarkdownExporter()
+        self.rag_exporter = RagExporter()
+
+    def process(self, file_path: str, export_mode: str = "markdown") -> str:
+        _, ext = os.path.splitext(file_path)
+        ext = ext.lower()
+        document = None
+        
+        # --- PATH B : PDF (Hybride Natif + OCR) ---
+        if ext == ".pdf":
+            print("-> Fichier PDF détecté. Analyse (Hybride)...")
+            loader = PdfLoader()
+            document = loader.load(file_path)
+            
+        elif ext == ".docx":
+            print("-> Fichier DOCX détecté. Extraction native.")
+            loader = DocxLoader()
+            document = loader.load(file_path)
+            
+        elif ext == ".xlsx":
+            print("-> Fichier XLSX détecté. Extraction native (Tableaux).")
+            loader = XlsxLoader()
+            document = loader.load(file_path)
+            
+        elif ext == ".pptx":
+            print("-> Fichier PPTX détecté. Extraction native (Slides).")
+            loader = PptxLoader()
+            document = loader.load(file_path)
+            
+        # --- PATH A : Images pures (OCR) ---
+        elif ext in [".jpg", ".jpeg", ".png", ".tiff", ".bmp"]:
+            print("-> Fichier Image détecté. Utilisation OCR.")
+            loader = ImageLoader()
+            document = loader.load(file_path)
+            
+            print("   ... Calcul de l'ordre de lecture")
+            reading_order_plugin = ReadingOrderPlugin()
+            document = reading_order_plugin.run(document)
+            
+            # 4. OCR (Qwen2.5-VL lit dans les boîtes de Surya)
+            print("   ... Extraction du texte (Qwen2.5-VL via Ollama)")
+            # ocr_plugin = TesseractOCRPlugin()  <-- On commente Tesseract
+            ocr_plugin = QwenOCRPlugin() 
+            document = ocr_plugin.run(document)
+            
+        else:
+            raise ValueError(f"Format non supporté : {ext}")
+
+        print(f"-> Export demandé : {export_mode}")
+        if export_mode == "rag":
+            return self.rag_exporter.export(document, mode="semantic_chunks")
+        else:
+            return self.markdown_exporter.export(document)
+

src/exporters/markdown.py

@@ -0,0 +1,56 @@
+from src.core.dom.models import Document, Block, Table, RegionType
+
+class MarkdownExporter:
+    def export(self, document: Document) -> str:
+        md_lines = []
+        
+        for page in document.pages:
+            for region in page.regions:
+                # On rassemble tout dans une liste pour la trier par ordre de lecture
+                elements = []
+                for block in region.blocks:
+                    # On passe le type de la région au bloc de texte pour l'export
+                    elements.append((block.reading_order, "text", block, region.region_type))
+                for table in region.tables:
+                    elements.append((table.reading_order, "table", table, None))
+                
+                elements.sort(key=lambda x: x[0])
+                
+                for _, el_type, el_data, region_type in elements:
+                    if el_type == "text":
+                        # Si le bloc vient du DOCX (heading_level)
+                        if el_data.heading_level:
+                            prefix = "#" * el_data.heading_level
+                            md_lines.append(f"{prefix} {el_data.text}\n")
+                        # Si le bloc vient de Surya et que la région est un TITRE
+                        elif region_type == RegionType.TITLE:
+                            md_lines.append(f"# {el_data.text}\n")
+                        # Sinon c'est un paragraphe normal
+                        else:
+                            md_lines.append(f"{el_data.text}\n")
+                            
+                    elif el_type == "table":
+                        md_lines.append(self.table_to_markdown(el_data) + "\n")
+                        
+        return "\n".join(md_lines)
+
+    def table_to_markdown(self, table: Table) -> str:
+        # (Garde la méthode table_to_markdown exactement comme elle était)
+        if not table.cells or table.cols == 0:
+            return ""
+            
+        grid = [["" for _ in range(table.cols)] for _ in range(table.rows)]
+        cell_idx = 0
+        for r in range(table.rows):
+            for c in range(table.cols):
+                if cell_idx < len(table.cells):
+                    grid[r][c] = table.cells[cell_idx].text.replace('\n', ' ').replace('|', '/')
+                    cell_idx += 1
+        
+        md_table = []
+        md_table.append("| " + " | ".join(grid[0]) + " |")
+        md_table.append("|" + "|".join(["---"] * table.cols) + "|")
+        for r in range(1, table.rows):
+            md_table.append("| " + " | ".join(grid[r]) + " |")
+            
+        return "\n".join(md_table)

src/exporters/rag.py

@@ -0,0 +1,78 @@
+import json
+from src.core.dom.models import Document
+from src.exporters.markdown import MarkdownExporter
+
+class RagExporter:
+    def __init__(self):
+        self.md_exporter = MarkdownExporter()
+
+    def export(self, document: Document, mode: str = "semantic_chunks") -> str:
+        """
+        Exporte le document pour le RAG.
+        :param mode: 
+            - "semantic_chunks" : Découpe par bloc (paragraphe/tableau) avec métadonnées riches.
+            - "full_document" : Renvoie un seul gros chunk Markdown pour que le runtime de l'agent gère le découpage.
+        """
+        if mode == "full_document":
+            return self._export_full_document(document)
+        else:
+            return self._export_semantic_chunks(document)
+
+    def _export_full_document(self, document: Document) -> str:
+        """Mode 1 : Laisse l'agent runtime découper le texte."""
+        markdown_text = self.md_exporter.export(document)
+        
+        payload = [{
+            "text": markdown_text,
+            "metadata": {
+                "source": document.source_file,
+                "total_pages": len(document.pages),
+                "type": "full_document",
+                "note": "Ready for external Markdown/Token splitter"
+            }
+        }]
+        return json.dumps(payload, indent=2, ensure_ascii=False)
+
+    def _export_semantic_chunks(self, document: Document) -> str:
+        """Mode 2 : On impose notre propre découpage logique."""
+        chunks = []
+        current_heading = "Document Root"
+        
+        for page in document.pages:
+            for region in page.regions:
+                elements = []
+                for block in region.blocks:
+                    elements.append((block.reading_order, "text", block))
+                for table in region.tables:
+                    elements.append((table.reading_order, "table", table))
+                
+                elements.sort(key=lambda x: x[0])
+                
+                for _, el_type, el_data in elements:
+                    if el_type == "text" and el_data.heading_level:
+                        current_heading = el_data.text
+                        
+                    if el_type == "text" and el_data.text:
+                        chunks.append({
+                            "text": el_data.text,
+                            "metadata": {
+                                "source": document.source_file,
+                                "page": page.page_number,
+                                "section": current_heading,
+                                "type": "paragraph"
+                            }
+                        })
+                        
+                    elif el_type == "table":
+                        table_md = self.md_exporter.table_to_markdown(el_data)
+                        chunks.append({
+                            "text": table_md,
+                            "metadata": {
+                                "source": document.source_file,
+                                "page": page.page_number,
+                                "section": current_heading,
+                                "type": "table"
+                            }
+                        })
+                        
+        return json.dumps(chunks, indent=2, ensure_ascii=False)

src/plugins/layout/surya_layout.py

@@ -0,0 +1,76 @@
+from PIL import Image
+from surya.layout import LayoutPredictor
+from src.core.interfaces import IDocumentPlugin
+from src.core.dom.models import Document, Region, BoundingBox, RegionType
+
+class SuryaLayoutPlugin(IDocumentPlugin):
+    """
+    Utilise Surya pour détecter les zones (Layout) sur les images du document.
+    """
+    def __init__(self):
+        # Initialisation paresseuse : on ne charge le modèle PyTorch que si on en a besoin
+        self._model = None
+
+    @property
+    def name(self) -> str:
+        return "SuryaLayoutAnalyzer"
+
+    @property
+    def model(self):
+        if self._model is None:
+            print("Chargement du modèle Surya Layout... (la première fois peut être longue)")
+            self._model = LayoutPredictor()
+        return self._model
+
+    def run(self, document: Document) -> Document:
+        for page in document.pages:
+            if not page.image_path:
+                continue
+            
+            # 1. Charger l'image liée à la page
+            img = Image.open(page.image_path)
+            
+            # 2. Prédiction du layout avec Surya
+            predictions = self.model([img])
+            
+            # 3. On vide la région "globale" initiale fournie par l'ImageLoader
+            page.regions = []
+            
+            # 4. Mapper les résultats de Surya vers notre DOM
+            surya_result = predictions[0]
+            
+            sorted_bboxes = sorted(
+                surya_result.bboxes, 
+                key=lambda b: (b.polygon[0][1], b.polygon[0][0])
+            )
+
+            for i, bbox in enumerate(sorted_bboxes):
+                # Surya fournit des polygones. On extrait le rectangle englobant (x, y, w, h)
+                # Surya utilise généralement [x_min, y_min, x_max, y_max] dans ses propriétés
+                x = bbox.polygon[0][0]
+                y = bbox.polygon[0][1]
+                w = bbox.polygon[1][0] - x
+                h = bbox.polygon[2][1] - y
+                
+                # Mapping du label Surya (Text, Table, Image, Title...) vers notre Enum
+                label = bbox.label.upper()
+                region_type = RegionType.TEXT # Valeur par défaut
+                if "TABLE" in label: region_type = RegionType.TABLE
+                elif "IMAGE" in label: region_type = RegionType.IMAGE
+                elif "TITLE" in label or "HEADER" in label: region_type = RegionType.TITLE
+                
+                # Création de la région dans notre DOM
+                region = Region(
+                    bbox=BoundingBox(
+                        x=float(x), 
+                        y=float(y), 
+                        width=float(w), 
+                        height=float(h), 
+                        confidence=float(bbox.confidence)
+                    ),
+                    region_type=region_type,
+                    reading_order=i # Ordre de lecture provisoire
+                )
+                page.regions.append(region)
+                
+        return document

src/plugins/loaders/docx_loader.py

@@ -0,0 +1,89 @@
+from docx import Document as DocxDocument
+from docx.text.paragraph import Paragraph
+from docx.table import Table as DocxTable
+from docx.oxml.ns import qn
+from src.core.interfaces import IDocumentLoader
+from src.core.dom.models import (
+    Document, Page, Region, Block, Table, Cell, 
+    BoundingBox, BlockType, RegionType, Style
+)
+
+class DocxLoader(IDocumentLoader):
+    """
+    Chargeur pour les documents Word natifs (.docx).
+    Extrait directement le texte et les tableaux sans passer par l'OCR.
+    """
+    @property
+    def name(self) -> str:
+        return "DocxLoader"
+
+    def load(self, file_path: str) -> Document:
+        docx_doc = DocxDocument(file_path)
+        
+        dom_doc = Document(source_file=file_path)
+        # Un document Word est un flux continu, on cr�e une "Page logique" unique
+        page = Page(page_number=1, width=0, height=0)
+        region = Region(
+            bbox=BoundingBox(0, 0, 0, 0), 
+            region_type=RegionType.TEXT,
+            reading_order=0
+        )
+        
+        reading_order_counter = 0
+        
+        # On lit l'arbre XML du document pour garder l'ordre r�el (texte puis tableau, puis texte, etc.)
+        body = docx_doc.element.body
+        for child in body.iterchildren():
+            # Si l'�l�ment est un paragraphe
+            if child.tag == qn('w:p'):
+                para = Paragraph(child, docx_doc)
+                text = para.text.strip()
+                if text:
+                    is_bold = any(run.bold for run in para.runs if run.bold is not None)
+                    
+                    # D�tection du niveau de titre
+                    heading_level = None
+                    style_name = para.style.name if para.style else ""
+                    if style_name.startswith("Heading"):
+                        try:
+                            heading_level = int(style_name.split()[-1])
+                        except ValueError:
+                            heading_level = 1 # Fallback si le nom du style est bizarre
+
+                    block = Block(
+                        bbox=BoundingBox(0, 0, 0, 0),
+                        block_type=BlockType.TEXT,
+                        text=text,
+                        style=Style(bold=is_bold or (heading_level is not None)),
+                        reading_order=reading_order_counter,
+                        heading_level=heading_level # <-- AJOUT
+                    )
+                    region.blocks.append(block)
+                    reading_order_counter += 1
+                    
+            # Si l'�l�ment est un tableau
+            elif child.tag == qn('w:tbl'):
+                docx_table = DocxTable(child, docx_doc)
+                dom_table = Table(
+                    bbox=BoundingBox(0, 0, 0, 0),
+                    rows=len(docx_table.rows),
+                    cols=len(docx_table.columns),
+                    reading_order=reading_order_counter # On assigne l'ordre au tableau
+                )
+                
+                for r_idx, row in enumerate(docx_table.rows):
+                    for c_idx, cell in enumerate(row.cells):
+                        dom_cell = Cell(
+                            bbox=BoundingBox(0, 0, 0, 0),
+                            text=cell.text.strip(),
+                            is_header=(r_idx == 0)
+                        )
+                        dom_table.cells.append(dom_cell)
+                
+                region.tables.append(dom_table)
+                reading_order_counter += 1
+
+        page.regions.append(region)
+        dom_doc.pages.append(page)
+        
+        return dom_doc

src/plugins/loaders/image_loader.py

@@ -0,0 +1,41 @@
+from PIL import Image
+from src.core.interfaces import IDocumentLoader
+from src.core.dom.models import Document, Page, Region, BoundingBox, RegionType
+
+class ImageLoader(IDocumentLoader):
+    """
+    Chargeur pour les fichiers images (JPG, PNG, TIFF).
+    Prépare le DOM avec les dimensions physiques de l'image.
+    """
+    @property
+    def name(self) -> str:
+        return "ImageLoader"
+
+    def load(self, file_path: str) -> Document:
+        # 1. Lecture des dimensions physiques de l'image
+        with Image.open(file_path) as img:
+            width, height = img.size
+            
+        # 2. Initialisation du DOM
+        doc = Document(source_file=file_path)
+        
+        # 3. Création de la page avec les vraies dimensions et le chemin de l'image
+        page = Page(
+            page_number=1,
+            width=float(width),
+            height=float(height),
+            image_path=file_path  # <-- Crucial pour les futurs plugins d'OCR
+        )
+        
+        # 4. Création d'une région globale vierge.
+        # Le plugin de Layout Analysis (Surya) viendra diviser cette région plus tard.
+        region = Region(
+            bbox=BoundingBox(0, 0, float(width), float(height)),
+            region_type=RegionType.TEXT,
+            reading_order=0
+        )
+        
+        page.regions.append(region)
+        doc.pages.append(page)
+        
+        return doc

src/plugins/loaders/pdf_loader.py

@@ -0,0 +1,93 @@
+import os
+import fitz  # PyMuPDF
+from src.core.interfaces import IDocumentLoader
+from src.core.dom.models import Document, Page, Region, Block, BoundingBox, BlockType, RegionType
+
+class PdfLoader(IDocumentLoader):
+    """
+    Chargeur PDF Hybride.
+    Extrait le texte natif si présent, sinon rasterise la page en image pour l'OCR.
+    """
+    @property
+    def name(self) -> str:
+        return "PdfLoader (Hybrid)"
+
+    def load(self, file_path: str) -> Document:
+        doc = Document(source_file=file_path)
+        pdf_document = fitz.open(file_path)
+        
+        base_name = os.path.splitext(os.path.basename(file_path))[0]
+        temp_dir = f"temp_{base_name}"
+        
+        for page_num in range(len(pdf_document)):
+            page = pdf_document[page_num]
+            rect = page.rect
+            
+            # On vérifie s'il y a du texte natif sur la page
+            raw_text = page.get_text("text").strip()
+            
+            dom_page = Page(
+                page_number=page_num + 1,
+                width=float(rect.width),
+                height=float(rect.height),
+                image_path=None # Par défaut, pas d'image
+            )
+            
+            # --- CAS 1 : PAGE NATIVE (Texte présent) ---
+            if len(raw_text) > 10:
+                text_dict = page.get_text("dict")
+                region_order = 0
+                block_order = 0
+                
+                for block in text_dict["blocks"]:
+                    if block["type"] == 0:
+                        b_box = block["bbox"]
+                        region = Region(
+                            bbox=BoundingBox(
+                                x=float(b_box[0]), y=float(b_box[1]),
+                                width=float(b_box[2] - b_box[0]),
+                                height=float(b_box[3] - b_box[1])
+                            ),
+                            region_type=RegionType.TEXT,
+                            reading_order=region_order
+                        )
+                        region_order += 1
+                        
+                        for line in block["lines"]:
+                            line_box = line["bbox"]
+                            line_text = "".join([span["text"] for span in line["spans"]])
+                            if line_text.strip():
+                                dom_block = Block(
+                                    bbox=BoundingBox(
+                                        x=float(line_box[0]), y=float(line_box[1]),
+                                        width=float(line_box[2] - line_box[0]),
+                                        height=float(line_box[3] - line_box[1])
+                                    ),
+                                    block_type=BlockType.TEXT,
+                                    text=line_text.strip(),
+                                    reading_order=block_order
+                                )
+                                region.blocks.append(dom_block)
+                                block_order += 1
+                        if region.blocks:
+                            dom_page.regions.append(region)
+                            
+            # --- CAS 2 : PAGE SCANNÉE (Pas de texte, on rasterise) ---
+            else:
+                if not os.path.exists(temp_dir):
+                    os.makedirs(temp_dir)
+                    
+                zoom = 2.0
+                mat = fitz.Matrix(zoom, zoom)
+                pix = page.get_pixmap(matrix=mat)
+                img_path = os.path.abspath(os.path.join(temp_dir, f"page_{page_num + 1}.png"))
+                pix.save(img_path)
+                
+                dom_page.width = float(pix.width)
+                dom_page.height = float(pix.height)
+                dom_page.image_path = img_path # On indique qu'il faut faire l'OCR sur cette page
+                
+            doc.pages.append(dom_page)
+            
+        pdf_document.close()
+        return doc

src/plugins/loaders/pptx_loader.py

@@ -0,0 +1,60 @@
+from pptx import Presentation
+from src.core.interfaces import IDocumentLoader
+from src.core.dom.models import Document, Page, Region, Block, Table, Cell, BoundingBox, BlockType, RegionType
+
+class PptxLoader(IDocumentLoader):
+    @property
+    def name(self) -> str:
+        return "PptxLoader (Native)"
+
+    def load(self, file_path: str) -> Document:
+        doc = Document(source_file=file_path)
+        prs = Presentation(file_path)
+        
+        for slide_idx, slide in enumerate(prs.slides):
+            page = Page(page_number=slide_idx + 1, width=float(prs.slide_width), height=float(prs.slide_height))
+            region = Region(
+                bbox=BoundingBox(0, 0, page.width, page.height),
+                region_type=RegionType.TEXT,
+                reading_order=0
+            )
+            
+            reading_order = 0
+            
+            for shape in slide.shapes:
+                # 1. Extraction du texte
+                if shape.has_text_frame:
+                    for para in shape.text_frame.paragraphs:
+                        text = para.text.strip()
+                        if text:
+                            region.blocks.append(Block(
+                                bbox=BoundingBox(0, 0, 0, 0),
+                                block_type=BlockType.TEXT,
+                                text=text,
+                                reading_order=reading_order
+                            ))
+                            reading_order += 1
+                            
+                # 2. Extraction des tableaux
+                if shape.has_table:
+                    tbl = shape.table
+                    dom_table = Table(
+                        bbox=BoundingBox(0, 0, 0, 0),
+                        rows=len(tbl.rows),
+                        cols=len(tbl.columns),
+                        reading_order=reading_order
+                    )
+                    for r_idx, row in enumerate(tbl.rows):
+                        for c_idx, cell in enumerate(row.cells):
+                            dom_table.cells.append(Cell(
+                                bbox=BoundingBox(0, 0, 0, 0),
+                                text=cell.text.strip(),
+                                is_header=(r_idx == 0)
+                            ))
+                    region.tables.append(dom_table)
+                    reading_order += 1
+                    
+            page.regions.append(region)
+            doc.pages.append(page)
+            
+        return doc

src/plugins/loaders/xlsx_loader.py

@@ -0,0 +1,48 @@
+import openpyxl
+from src.core.interfaces import IDocumentLoader
+from src.core.dom.models import Document, Page, Region, Table, Cell, BoundingBox, RegionType
+
+class XlsxLoader(IDocumentLoader):
+    @property
+    def name(self) -> str:
+        return "XlsxLoader (Native)"
+
+    def load(self, file_path: str) -> Document:
+        doc = Document(source_file=file_path)
+        wb = openpyxl.load_workbook(file_path, data_only=True)
+        
+        for sheet_idx, sheet_name in enumerate(wb.sheetnames):
+            sheet = wb[sheet_name]
+            
+            # Chaque feuille est une Page logique
+            page = Page(page_number=sheet_idx + 1, width=0, height=0)
+            region = Region(
+                bbox=BoundingBox(0, 0, 0, 0),
+                region_type=RegionType.TABLE,
+                reading_order=0
+            )
+            
+            # On cr�e un tableau unique pour toute la feuille
+            rows = sheet.max_row
+            cols = sheet.max_column
+            dom_table = Table(
+                bbox=BoundingBox(0, 0, 0, 0),
+                rows=rows,
+                cols=cols,
+                reading_order=0
+            )
+            
+            for r_idx, row in enumerate(sheet.iter_rows(values_only=True)):
+                for c_idx, val in enumerate(row):
+                    cell_text = str(val) if val is not None else ""
+                    dom_table.cells.append(Cell(
+                        bbox=BoundingBox(0, 0, 0, 0),
+                        text=cell_text.strip(),
+                        is_header=(r_idx == 0)
+                    ))
+                    
+            region.tables.append(dom_table)
+            page.regions.append(region)
+            doc.pages.append(page)
+            
+        return doc

src/plugins/ocr/qwen_ocr.py

@@ -0,0 +1,74 @@
+import ollama
+import io
+import base64
+from PIL import Image
+from src.core.interfaces import IDocumentPlugin
+from src.core.dom.models import Document, Region, Block, BoundingBox, BlockType, RegionType
+
+class QwenOCRPlugin(IDocumentPlugin):
+    """
+    Utilise Qwen2.5-VL via Ollama pour lire le texte dans les images.
+    Remplace Tesseract. N'a pas besoin de pré-traitement d'image.
+    """
+    @property
+    def name(self) -> str:
+        return "Qwen2.5-VL OCR"
+
+    def run(self, document: Document) -> Document:
+        for page in document.pages:
+            if not page.image_path:
+                continue
+            
+            full_img = Image.open(page.image_path)
+            
+            # Si Surya n'a rien trouvé, on traite l'image entière
+            if not page.regions:
+                page.regions.append(Region(
+                    bbox=BoundingBox(0, 0, page.width, page.height),
+                    region_type=RegionType.TEXT,
+                    reading_order=0
+                ))
+            
+            for region in page.regions:
+                # On ne fait pas d'OCR sur les régions identifiées comme des images/photos
+                if region.region_type == RegionType.IMAGE:
+                    continue
+                    
+                # 1. Découper l'image selon la région de Surya
+                x, y, w, h = region.bbox.x, region.bbox.y, region.bbox.width, region.bbox.height
+                crop = full_img.crop((int(x), int(y), int(x + w), int(y + h)))
+                
+                # 2. Convertir l'image découpée en Base64 pour Ollama
+                buffered = io.BytesIO()
+                crop.save(buffered, format="PNG")
+                img_base64 = base64.b64encode(buffered.getvalue()).decode('utf-8')
+                
+                # 3. Envoyer à Qwen2.5-VL
+                try:
+                    response = ollama.chat(
+                        model='qwen2.5vl:7b', # Change le nom si tu as une autre version
+                        messages=[{
+                            'role': 'user',
+                            'content': 'Transcris tout le texte visible sur cette image de manière exacte. Ne renvoie que le texte brut, sans commentaires ni markdown.',
+                            'images': [img_base64]
+                        }]
+                    )
+                    extracted_text = response['message']['content'].strip()
+                except Exception as e:
+                    print(f"Erreur Ollama sur la région : {e}")
+                    extracted_text = ""
+                
+                # 4. Stocker dans notre DOM
+                if extracted_text:
+                    block = Block(
+                        bbox=BoundingBox(
+                            x=float(x), y=float(y), 
+                            width=float(w), height=float(h)
+                        ),
+                        block_type=BlockType.TEXT,
+                        text=extracted_text,
+                        reading_order=0 # L'ordre global est déjà géré par le ReadingOrderEngine
+                    )
+                    region.blocks.append(block)
+                    
+        return document

src/plugins/ocr/tesseract_ocr.py

@@ -0,0 +1,75 @@
+import pytesseract
+from PIL import Image
+from src.core.interfaces import IDocumentPlugin
+from src.core.dom.models import Document, Region, Block, BoundingBox, BlockType, RegionType
+
+class TesseractOCRPlugin(IDocumentPlugin):
+    @property
+    def name(self) -> str:
+        return "TesseractOCR"
+
+    def run(self, document: Document) -> Document:
+        for page in document.pages:
+            if not page.image_path:
+                continue
+            
+            full_img = Image.open(page.image_path)
+            
+            # Si Surya a créé des régions, on les utilise. Sinon, on crée une région globale.
+            if not page.regions:
+                page.regions.append(Region(
+                    bbox=BoundingBox(0, 0, page.width, page.height),
+                    region_type=RegionType.TEXT,
+                    reading_order=0
+                ))
+            
+            for region in page.regions:
+                # 1. On découpe l'image selon la BoundingBox de la région
+                x, y, w, h = region.bbox.x, region.bbox.y, region.bbox.width, region.bbox.height
+                cropped_img = full_img.crop((int(x), int(y), int(x + w), int(y + h)))
+                                
+                # 2. OCR sur la portion découpée
+                data = pytesseract.image_to_data(cropped_img, output_type=pytesseract.Output.DICT)
+                
+                # 3. On regroupe les mots par ligne (comme on l'avait fait)
+                lines_data = {}
+                for i in range(len(data['text'])):
+                    text = data['text'][i].strip()
+                    if text and int(data['conf'][i]) > 0:
+                        line_key = (data['block_num'][i], data['par_num'][i], data['line_num'][i])
+                        
+                        if line_key not in lines_data:
+                            lines_data[line_key] = {
+                                'words': [],
+                                'left': data['left'][i],
+                                'top': data['top'][i],
+                                'right': data['left'][i] + data['width'][i],
+                                'bottom': data['top'][i] + data['height'][i]
+                            }
+                        lines_data[line_key]['words'].append(text)
+                        lines_data[line_key]['left'] = min(lines_data[line_key]['left'], data['left'][i])
+                        lines_data[line_key]['top'] = min(lines_data[line_key]['top'], data['top'][i])
+                        lines_data[line_key]['right'] = max(lines_data[line_key]['right'], data['left'][i] + data['width'][i])
+                        lines_data[line_key]['bottom'] = max(lines_data[line_key]['bottom'], data['top'][i] + data['height'][i])
+                
+                # 4. On crée les blocs dans la région (en ajustant les coordonnées par rapport à l'image pleine)
+                reading_order_counter = 0
+                sorted_lines = sorted(lines_data.values(), key=lambda x: x['top'])
+                
+                for line in sorted_lines:
+                    line_text = " ".join(line['words'])
+                    block = Block(
+                        bbox=BoundingBox(
+                            x=float(x + line['left']),       # Coordonnée absolue sur la page
+                            y=float(y + line['top']),       # Coordonnée absolue sur la page
+                            width=float(line['right'] - line['left']),
+                            height=float(line['bottom'] - line['top'])
+                        ),
+                        block_type=BlockType.TEXT,
+                        text=line_text,
+                        reading_order=reading_order_counter
+                    )
+                    region.blocks.append(block)
+                    reading_order_counter += 1
+                    
+        return document

src/plugins/reading_order/reading_order_engine.py

@@ -0,0 +1,99 @@
+from src.core.interfaces import IDocumentPlugin
+from src.core.dom.models import Document, Region
+
+class ReadingOrderPlugin(IDocumentPlugin):
+    """
+    Moteur d'ordre de lecture utilisant l'algorithme XY-Cut.
+    Coupe récursivement la page en colonnes et blocs pour trouver l'ordre logique.
+    """
+    @property
+    def name(self) -> str:
+        return "ReadingOrderEngine (XY-Cut)"
+
+    def run(self, document: Document) -> Document:
+        for page in document.pages:
+            if not page.regions:
+                continue
+            
+            # On lance l'algorithme récursif sur les régions de la page
+            ordered_regions = self._xy_cut_recursive(page.regions, page.width, page.height)
+            
+            # On assigne l'ordre final
+            for i, region in enumerate(ordered_regions):
+                region.reading_order = i
+                
+            # On met à jour la liste des régions de la page dans le bon ordre
+            page.regions = ordered_regions
+            
+        return document
+
+    def _xy_cut_recursive(self, regions, page_width, page_height):
+        """Algorithme récursif de coupe XY."""
+        if len(regions) <= 1:
+            return regions
+
+        # 1. On tente une coupe Verticale (pour séparer les colonnes)
+        v_cut = self._find_largest_gap(regions, axis='x', page_size=page_width)
+        if v_cut is not None:
+            left = [r for r in regions if (r.bbox.x + r.bbox.width / 2) < v_cut]
+            right = [r for r in regions if (r.bbox.x + r.bbox.width / 2) >= v_cut]
+            
+            if left and right:
+                # On lit la gauche, puis la droite
+                return self._xy_cut_recursive(left, page_width, page_height) + \
+                       self._xy_cut_recursive(right, page_width, page_height)
+
+        # 2. Si pas de coupe verticale, on tente une coupe Horizontale (paragraphes)
+        h_cut = self._find_largest_gap(regions, axis='y', page_size=page_height)
+        if h_cut is not None:
+            top = [r for r in regions if (r.bbox.y + r.bbox.height / 2) < h_cut]
+            bottom = [r for r in regions if (r.bbox.y + r.bbox.height / 2) >= h_cut]
+            
+            if top and bottom:
+                # On lit le haut, puis le bas
+                return self._xy_cut_recursive(top, page_width, page_height) + \
+                       self._xy_cut_recursive(bottom, page_width, page_height)
+
+        # 3. Fallback : si aucune coupe trouvée, on trie par Y puis X
+        return sorted(regions, key=lambda r: (r.bbox.y, r.bbox.x))
+
+    def _find_largest_gap(self, regions, axis, page_size):
+        """Trouve le plus grand espace blanc sur un axe (x ou y)."""
+        intervals = []
+        for r in regions:
+            if axis == 'x':
+                intervals.append((r.bbox.x, r.bbox.x + r.bbox.width))
+            else:
+                intervals.append((r.bbox.y, r.bbox.y + r.bbox.height))
+
+        # Trier par coordonnée de début
+        intervals.sort(key=lambda x: x[0])
+
+        # Fusionner les intervalles qui se chevauchent
+        merged = []
+        for start, end in intervals:
+            if not merged or start > merged[-1][1]:
+                merged.append([start, end])
+            else:
+                merged[-1][1] = max(merged[-1][1], end)
+
+        if len(merged) < 2:
+            return None # Pas d'espace possible
+
+        # Trouver le plus grand espace entre deux blocs fusionnés
+        max_gap = 0
+        best_cut = None
+        for i in range(len(merged) - 1):
+            gap_start = merged[i][1]
+            gap_end = merged[i+1][0]
+            gap = gap_end - gap_start
+            
+            if gap > max_gap:
+                max_gap = gap
+                best_cut = (gap_start + gap_end) / 2.0
+
+        # On ne coupe que si l'espace blanc est significatif (ex: > 5% de la page)
+        if max_gap > (page_size * 0.05):
+            return best_cut
+            
+        return None