rostaing-ocr 0.1.0__py3-none-any.whl

rostaing_ocr/__init__.py

@@ -0,0 +1,6 @@
+# Fichier : src/rostaing_ocr/__init__.py
+
+from .rostaing_ocr import RostaingOCR
+
+# Optionnel: définir ce qui est exporté quand on fait 'from rostaing_ocr import *'
+__all__ = ['RostaingOCR']

rostaing_ocr/rostaing_ocr.py

@@ -0,0 +1,223 @@
+import os
+import fitz  # PyMuPDF
+import pytesseract
+from markitdown import MarkItDown
+import io
+from PIL import Image
+# N.B. : 'ImageOps' n'était pas utilisé, je l'ai retiré pour plus de propreté.
+from typing import List, Union, Optional, Dict, Tuple # Tuple n'est plus nécessaire mais bonne pratique à connaître
+
+class RostaingOCR:
+    """
+    Une classe pour convertir, extraire et sauvegarder le texte de fichiers
+    (images, PDF scannés) aux formats .txt et .md. La reconnaissance est
+    optimisée par un prétraitement des images.
+    
+    Utilisation :
+        # Comportement par défaut (sauvegarde uniquement)
+        extractor = RostaingOCR("fichier.pdf", output_basename="resultat")
+        
+        # Sauvegarde ET affichage dans la console
+        extractor = RostaingOCR("fichier.pdf", output_basename="resultat", print_to_console=True)
+    """
+
+    def __init__(self,
+                 input_path_or_paths: Union[str, List[str]],
+                 output_basename: str = "output",
+                 print_to_console: bool = False,
+                 languages: List[str] = ['fra', 'eng'],
+                 tesseract_cmd: Optional[str] = None):
+        """
+        Initialise ET lance le processus d'extraction complet.
+
+        Args:
+            input_path_or_paths (Union[str, List[str]]):
+                Chemin vers un fichier source unique ou une liste de chemins.
+            output_basename (str):
+                Nom de base pour les fichiers de sortie (sans extension).
+                Générera '{output_basename}.txt' et '{output_basename}.md'.
+            print_to_console (bool):
+                Si True, le contenu Markdown extrait sera affiché dans la console.
+            languages (List[str]): 
+                Liste des langues à utiliser pour l'OCR.
+            tesseract_cmd (Optional[str]): 
+                Chemin vers l'exécutable Tesseract.
+        """
+        # --- 1. Configuration ---
+        if isinstance(input_path_or_paths, str):
+            self.input_paths = [input_path_or_paths]
+        else:
+            self.input_paths = input_path_or_paths
+
+        self.output_basename = output_basename
+        self.output_txt_path = f"{output_basename}.txt"
+        self.output_md_path = f"{output_basename}.md"
+
+        self.print_to_console = print_to_console
+        self.tesseract_lang_string = '+'.join(languages)
+        self.md_converter = MarkItDown()
+        self.results: Dict[str, Optional[str]] = {}
+
+        for path in self.input_paths:
+            if not os.path.exists(path):
+                raise FileNotFoundError(f"The specified input file does not exist: {path}")
+
+        if tesseract_cmd:
+            pytesseract.pytesseract.tesseract_cmd = tesseract_cmd
+
+        print(f"RostaingOCR initialized. Starting processing...")
+        print(f"Output files: '{self.output_txt_path}' and '{self.output_md_path}'")
+        if self.print_to_console:
+            print("Console display: Enabled")
+
+        # --- 2. Exécution immédiate du traitement ---
+        self._run_extraction_workflow()
+        
+        print("\nProcessing complete.")
+
+    def _run_extraction_workflow(self):
+        """(Privé) Gère le flux de travail pour tous les fichiers."""
+        all_final_content = []
+        
+        for i, file_path in enumerate(self.input_paths):
+            print(f"\n--- Processing {os.path.basename(file_path)} ({i+1}/{len(self.input_paths)}) ---")
+            
+            # CORRIGÉ: La méthode retourne maintenant une seule chaîne (le contenu Markdown)
+            extracted_content = self._extract_text_from_single_file(file_path)
+            
+            self.results[file_path] = extracted_content
+            
+            if extracted_content:
+                # Ajoute un titre pour la consolidation si plusieurs fichiers sont traités
+                content_with_header = f"# Content from : {os.path.basename(file_path)}\n\n{extracted_content}"
+                all_final_content.append(content_with_header)
+                print(f"--- SUCCESS for '{os.path.basename(file_path)}' ---")
+
+                # Affichage console immédiat pour ce fichier
+                if self.print_to_console:
+                    print("\n" + "="*20 + f" CONTENT OF {os.path.basename(file_path)} " + "="*20)
+                    print(extracted_content)
+                    print("="* (42 + len(os.path.basename(file_path))) + "\n")
+            else:
+                print(f"--- FAILED for '{os.path.basename(file_path)}' ---")
+
+        if all_final_content:
+            # Consolide le contenu de tous les fichiers traités
+            final_output_string = "\n\n---\n\n".join(all_final_content)
+            self._save_outputs(final_output_string)
+
+    # CORRIGÉ: La signature de la fonction retourne maintenant un simple Optional[str]
+    def _extract_text_from_single_file(self, input_path: str) -> Optional[str]:
+        """(Privé) Orchestre le processus pour un seul fichier et retourne le contenu Markdown."""
+        searchable_pdf_path = self._convert_to_searchable_pdf(input_path)
+        
+        if not searchable_pdf_path:
+            return None
+
+        extracted_content = None
+        try:
+            print(f"\n[Step 2/3] Extracting text and converting to Markdown...")
+            result = self.md_converter.convert(searchable_pdf_path)
+            
+            # CORRIGÉ: Utilisation de .text_content qui contient bien le Markdown
+            extracted_content = result.text_content
+            
+            print("  - Extraction and conversion successful.")
+            
+        except Exception as e:
+            # Erreur plus spécifique et utile pour le débogage
+            print(f"  - ERROR during extraction with MarkItDown : {e}")
+        finally:
+            print("[Cleanup] Deleting temporary file...")
+            if searchable_pdf_path and os.path.exists(searchable_pdf_path):
+                os.remove(searchable_pdf_path)
+                print(f"  - '{searchable_pdf_path}' supprimé.")
+        
+        return extracted_content
+
+    def _preprocess_image(self, image: Image.Image) -> Image.Image:
+        """(Privé) Prétraite une image pour optimiser l'OCR."""
+        # Conversion en niveaux de gris pour améliorer le contraste
+        return image.convert('L')
+
+    def _convert_to_searchable_pdf(self, input_path: str) -> Optional[str]:
+        """(Privé) Convertit un fichier en PDF cherchable temporaire avec prétraitement d'image."""
+        print(f"[Step 1/3] Converting to searchable PDF...")
+        base_name = os.path.splitext(os.path.basename(input_path))[0]
+        temp_output_path = f"{base_name}_temp_searchable.pdf"
+        output_pdf = fitz.open()
+        
+        # Utilisation de 'with' pour garantir la fermeture des ressources
+        try:
+            with fitz.open(input_path) as input_doc:
+                for i, page in enumerate(input_doc):
+                    print(f"  - Processing page {i+1}/{len(input_doc)}...")
+                    pix = page.get_pixmap(dpi=300)
+                    img_bytes = pix.tobytes("png")
+                    
+                    img = Image.open(io.BytesIO(img_bytes))
+                    preprocessed_img = self._preprocess_image(img)
+                    
+                    result = pytesseract.image_to_pdf_or_hocr(preprocessed_img, lang=self.tesseract_lang_string, extension='pdf')
+                    
+                    with fitz.open("pdf", result) as ocr_pdf:
+                        new_page = output_pdf.new_page(width=page.rect.width, height=page.rect.height)
+                        new_page.insert_image(page.rect, stream=img_bytes) 
+                        new_page.show_pdf_page(new_page.rect, ocr_pdf, 0)
+
+        except Exception:
+            print(f"  - Warning: fitz could not open '{input_path}' directly. Attempting with Pillow...")
+            try:
+                with Image.open(input_path) as img:
+                    preprocessed_img = self._preprocess_image(img.convert("RGB")) # Convertir en RGB avant pour la compatibilité
+                    
+                    pdf_bytes = pytesseract.image_to_pdf_or_hocr(preprocessed_img, lang=self.tesseract_lang_string, extension='pdf')
+                    
+                    with fitz.open("pdf", pdf_bytes) as ocr_pdf:
+                        # Reconstruire un PDF avec l'image visuelle
+                        img_as_bytes = io.BytesIO()
+                        img.save(img_as_bytes, format='PNG')
+                        img_as_bytes.seek(0)
+
+                        page = output_pdf.new_page(width=img.width, height=img.height)
+                        page.insert_image(page.rect, stream=img_as_bytes.read())
+                        page.show_pdf_page(page.rect, ocr_pdf, 0)
+
+            except Exception as e2:
+                print(f"  - FATAL ERROR: Could not process file '{input_path}'. EError : {e2}")
+                output_pdf.close()
+                return None
+        
+        if len(output_pdf) > 0:
+            output_pdf.save(temp_output_path, garbage=4, deflate=True, clean=True)
+            print(f"  - Temporary searchable PDF created : '{temp_output_path}'")
+        else:
+            print("  - ERROR: No pages were generated.")
+            temp_output_path = None
+        
+        output_pdf.close()
+        return temp_output_path
+
+    def _save_outputs(self, final_content: str):
+        """(Privé) Sauvegarde le contenu Markdown consolidé dans les fichiers .txt et .md."""
+        print(f"\n[Step 3/3] Saving consolidated content...")
+        
+        for path in [self.output_md_path, self.output_txt_path]:
+            try:
+                with open(path, 'w', encoding='utf-8') as f:
+                    f.write(final_content)
+                print(f"  - Successfully saved to '{path}'.")
+            except IOError as e:
+                print(f"  - ERROR: Could not write to file '{path}'. Error : {e}")
+
+    def __str__(self) -> str:
+        """Représentation textuelle de l'objet pour afficher un résumé des résultats."""
+        summary_lines = [f"--- RostaingOCR Extraction Summary ---"]
+        summary_lines.append(f"Generated output files: '{self.output_txt_path}' et '{self.output_md_path}'")
+        
+        for file_path, text_content in self.results.items():
+            status = "✅ Success" if text_content else "❌ Failure"
+            line = f"\n  - Processed file : {os.path.basename(file_path)}\n"
+            line += f"    Status         : {status}"
+            summary_lines.append(line)
+        return "\n".join(summary_lines)

rostaing_ocr-0.1.0.dist-info/METADATA

@@ -0,0 +1,143 @@
+Metadata-Version: 2.4
+Name: rostaing-ocr
+Version: 0.1.0
+Summary: Un outil OCR pour extraire du texte d'images et de PDF en utilisant Tesseract et PyMuPDF.
+Author-email: Davila Rostaing <davilarostaing@gmail.com>
+Project-URL: Homepage, https://github.com/Rostaing/rostaing-ocr
+Project-URL: Bug Tracker, https://github.com/Rostaing/rostaing-ocr/issues
+Classifier: Programming Language :: Python :: 3
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Topic :: Text Processing
+Classifier: Intended Audience :: Developers
+Classifier: Development Status :: 4 - Beta
+Requires-Python: >=3.7
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: PyMuPDF
+Requires-Dist: pytesseract
+Requires-Dist: markitdown
+Requires-Dist: Pillow
+Dynamic: license-file
+
+# Rostaing OCR, created by Davila Rostaing.
+
+A simple and powerful Python tool for extracting text from images and scanned PDFs. It leverages Tesseract, PyMuPDF, and MarkItDown to produce clean plain text (`.txt`) and Markdown (`.md`) files.
+
+## Features
+
+-   Converts images (PNG, JPG, etc.) and PDFs into text.
+-   Includes image preprocessing (grayscale conversion) to improve OCR accuracy.
+-   Processes multiple files in a single run, consolidating the output.
+-   Generates output in both plain text (`.txt`) and Markdown (`.md`) formats.
+-   Optional flag to print extracted content directly to the console for quick inspection.
+
+## System Prerequisites: Tesseract OCR
+
+**Important:** This package requires the **Tesseract OCR engine** to be installed on your system. `rostaing-ocr` is a Python wrapper that calls the `tesseract` command-line tool. You must install it and its language packs first.
+
+### Windows Installation Guide (Recommended)
+
+1.  **Download the Installer**: Go to the official [Tesseract at UB Mannheim](https://github.com/UB-Mannheim/tesseract/wiki) repository. They provide the most up-to-date and reliable installers for Windows.
+2.  **Run the Installer**: Start the installation process.
+3.  **Crucial Step - Add to PATH**: On the "Select Additional Tasks" screen, make sure to check the box for **"Add Tesseract to system PATH"**. This is essential for Python to be able to find and execute Tesseract.
+4.  **Select Languages**: On the "Select additional language data" screen, expand the list and select the languages you will need for OCR (e.g., check `French` for `fra`, `English` is usually included by default).
+5.  **Complete Installation**: Finish the installation and, to be safe, restart your command prompt, terminal, or IDE to ensure the system's PATH variable is updated.
+
+### macOS (via Homebrew)
+
+```bash
+brew install tesseract
+```
+You can add language packs by installing `tesseract-lang`.
+
+### Linux (Debian/Ubuntu)
+
+```bash
+sudo apt update
+sudo apt install tesseract-ocr
+
+# Also install the language packs you need. For French:
+sudo apt install tesseract-ocr-fra
+```
+
+## Installation
+
+### Best Practice: Use a Virtual Environment
+
+To keep project dependencies isolated and avoid conflicts with other Python projects on your system, it is highly recommended to use a virtual environment.
+
+With a standard Python installation, you can create and activate a new environment using the following commands:
+
+**On macOS/Linux:**
+```bash
+# Create an environment named '.venv' in your project directory
+python3 -m venv .venv
+
+# Activate the environment
+source .venv/bin/activate
+```
+
+**On Windows:**
+```bash
+# Create an environment named '.venv' in your project directory
+python -m venv .venv
+
+# Activate the environment
+.venv\Scripts\activate
+```
+
+### Install the Package
+
+Once Tesseract is set up and your virtual environment is activated, you can install the package from PyPI:
+
+```bash
+pip install rostaing-ocr
+```
+
+## Usage
+
+Here is a basic example of how to use the `RostaingOCR` class.
+
+```python
+from rostaing_ocr import RostaingOCR
+
+# --- Example 1: Process a single file ---
+# This will create 'my_result.txt' and 'my_result.md' in the current directory.
+extractor = RostaingOCR(
+    input_path_or_paths="path/to/my_document.pdf",
+    output_basename="my_result", # Optionel
+    print_to_console=True # Optionel
+)
+
+# --- Example 2: Process multiple files and print to console ---
+# This will process both files, save a consolidated output, and also print the results.
+multi_extractor = RostaingOCR(
+    input_path_or_paths=["document1.png", "scan_page_2.pdf"],
+    output_basename="combined_report", # Optionel
+    print_to_console=True, # Optionel
+    languages=['fra', 'eng'] # Specify languages for Tesseract # Optionel
+)
+
+# You can print the object to get a summary of the operation.
+print(multi_extractor)
+```
+
+## Application for LLM and RAG Pipelines
+
+Large Language Models (LLMs) like GPT-4 or Llama understand text, not images or scanned documents. A vast amount of valuable knowledge is locked away in unstructured formats such as PDFs of research papers, scanned invoices, or legal contracts.
+
+**`Rostaing OCR` serves as the crucial first step in any data ingestion pipeline for Retrieval-Augmented Generation (RAG) systems.** It bridges the gap by converting this inaccessible visual data into clean, structured text that LLMs can process.
+
+By using `Rostaing OCR`, you can automate the process of building a knowledge base from your documents:
+
+1.  **Input**: A directory of `Scanned PDFs` or `Images`.
+2.  **Extraction (Rostaing OCR)**: Convert all documents into clean `Markdown/Text`.
+3.  **Processing**: The text output can be fed into text splitters and then embedding models.
+4.  **Indexing**: The resulting vectors are stored in a vector database (e.g., Chroma, Pinecone, FAISS) for efficient retrieval.
+
+In short, `Rostaing OCR` unlocks your documents, making them ready for any modern AI stack.
+
+## License
+
+This project is licensed under the MIT License. See the `LICENSE` file for more details.

rostaing_ocr-0.1.0.dist-info/RECORD

@@ -0,0 +1,7 @@
+rostaing_ocr/__init__.py,sha256=HBwHqAcgfbxYvLsLkIiei-HEgXZrcHXM675VrLjO2fc,196
+rostaing_ocr/rostaing_ocr.py,sha256=xp7aP0MiL4vS0KzztPnDCnAsYsPzZ6ZBWZxRnNAEgIs,10746
+rostaing_ocr-0.1.0.dist-info/licenses/LICENSE,sha256=-mnJp92iFU5D7XvCVxTbqiHQBhIo_LKsH9yaMaPymoY,1087
+rostaing_ocr-0.1.0.dist-info/METADATA,sha256=YocIRat6BHwcZPAB_Qk92Gep6Kl_SLPVFRb34Oeb-m0,6036
+rostaing_ocr-0.1.0.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+rostaing_ocr-0.1.0.dist-info/top_level.txt,sha256=2MSL7KmO9dgjq622ZnYtXoYIxsa1VVm0ZAlrj3RKPCg,13
+rostaing_ocr-0.1.0.dist-info/RECORD,,

rostaing_ocr-0.1.0.dist-info/WHEEL

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

rostaing_ocr-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 RostaingOCR
+
+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.

rostaing_ocr-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+rostaing_ocr