mistral-ocr-cli 1.0.0__tar.gz

mistral_ocr_cli-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Rubén Fernández-Fuertes
+
+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.

mistral_ocr_cli-1.0.0/PKG-INFO

@@ -0,0 +1,294 @@
+Metadata-Version: 2.3
+Name: mistral-ocr-cli
+Version: 1.0.0
+Summary: A clean command-line tool for OCR processing using Mistral AI's API
+License: MIT
+Keywords: ocr,mistral,pdf,cli,command-line,document-processing,text-extraction,image-processing
+Author: Ruben Fernandez-Fuertes
+Author-email: fernandezfuertesruben@gmail.com
+Requires-Python: >=3.9,<4.0
+Classifier: Development Status :: 5 - Production/Stable
+Classifier: Environment :: Console
+Classifier: Intended Audience :: Developers
+Classifier: Intended Audience :: Science/Research
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Operating System :: OS Independent
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Scientific/Engineering :: Artificial Intelligence
+Classifier: Topic :: Software Development :: Libraries :: Python Modules
+Classifier: Topic :: Text Processing
+Classifier: Topic :: Utilities
+Requires-Dist: Pillow (>=10.2.0,<11.0.0)
+Requires-Dist: click (>=8.1.7,<9.0.0)
+Requires-Dist: mistralai (>=1.0.0,<2.0.0)
+Requires-Dist: pypdf (>=4.0.0,<5.0.0)
+Requires-Dist: python-dotenv (>=1.0.0,<2.0.0)
+Requires-Dist: rich (>=13.7.0,<14.0.0)
+Project-URL: Homepage, https://github.com/rubenfernandez/mistral-ocr-cli
+Project-URL: Repository, https://github.com/rubenfernandez/mistral-ocr-cli
+Description-Content-Type: text/markdown
+
+# Mistral OCR CLI
+
+A powerful command-line tool for OCR processing using Mistral AI's state-of-the-art OCR API. Process PDFs and images to extract text, tables, equations, and images with unprecedented accuracy.
+
+## ⚠️ Disclaimer
+
+**This is an unofficial, community-created tool** that uses Mistral AI's OCR API. This project is not affiliated with, officially maintained, or endorsed by Mistral AI.
+
+- **Official Mistral OCR**: https://mistral.ai/news/mistral-ocr
+- **Official Documentation**: https://docs.mistral.ai/capabilities/OCR/
+- **Mistral AI Platform**: https://console.mistral.ai/
+
+For official tools and support, please visit [Mistral AI's website](https://mistral.ai).
+
+## Features
+
+- 📄 **Multi-format Support**: Process PDFs and images (JPG, PNG, WEBP, GIF, BMP, TIFF)
+- 📊 **Advanced Extraction**: Extract text, tables, equations, and images
+- 📁 **Batch Processing**: Process single files or entire directories
+- 🎯 **Smart Output**: Preserves document structure in markdown format
+- 🖼️ **Image Extraction**: Optionally extract and save embedded images
+- 📈 **Progress Tracking**: Real-time progress bars for batch operations
+- 🔧 **Flexible Configuration**: Environment variables or command-line options
+
+## Installation
+
+### Prerequisites
+
+- Python 3.9 or higher
+- Mistral API key from [Mistral Console](https://console.mistral.ai/)
+
+### Install with Poetry (Recommended)
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/mistral-ocr.git
+cd mistral-ocr
+
+# Install Poetry if you haven't already
+curl -sSL https://install.python-poetry.org | python3 -
+
+# Install dependencies and the package
+poetry install
+
+# Make the command available globally
+poetry build
+pip install dist/mistral_ocr-*.whl
+```
+
+### Install with pip
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/mistral-ocr.git
+cd mistral-ocr
+
+# Install in editable mode for global usage
+pip install -e .
+```
+
+## Configuration
+
+### 1. Set up your Mistral API key
+
+Create a `.env` file in your project root (or copy from `.env.example`):
+
+```bash
+cp .env.example .env
+```
+
+Edit `.env` and add your API key:
+
+```env
+MISTRAL_API_KEY=your_actual_api_key_here
+```
+
+### 2. Alternative: Export as environment variable
+
+```bash
+export MISTRAL_API_KEY="your_actual_api_key_here"
+```
+
+## Usage
+
+### Basic Usage
+
+Process a single PDF file (output saved to `mistral_ocr_output/` in the same directory):
+
+```bash
+mistral-ocr document.pdf
+```
+
+### Specify Output Directory
+
+```bash
+mistral-ocr document.pdf --output-path ./results
+```
+
+### Process Entire Directory
+
+```bash
+mistral-ocr ./documents --output-path ./extracted
+```
+
+### Command-Line Options
+
+```
+Usage: mistral-ocr INPUT_PATH [OPTIONS]
+
+Arguments:
+  INPUT_PATH                  Path to input file or directory (required)
+
+Options:
+  -o, --output-path PATH      Output directory (default: <input_dir>/mistral_ocr_output/)
+  --api-key TEXT             Mistral API key (or set MISTRAL_API_KEY env var)
+  --model TEXT               OCR model (default: mistral-ocr-latest)
+  --env-file PATH            Path to .env file
+  --include-images/--no-images  Extract images (default: True)
+  -v, --verbose              Enable verbose output
+  --version                  Show version
+  --help                     Show this message
+```
+
+## Examples
+
+### Process a single image
+
+```bash
+mistral-ocr photo.jpg
+```
+
+### Process multiple PDFs with custom output
+
+```bash
+mistral-ocr ./reports --output-path ./extracted_text --verbose
+```
+
+### Use a different .env file
+
+```bash
+mistral-ocr document.pdf --env-file .env.production
+```
+
+### Process without extracting images
+
+```bash
+mistral-ocr document.pdf --no-images
+```
+
+### Pass API key directly (not recommended for production)
+
+```bash
+mistral-ocr doc.pdf --api-key "your_api_key_here"
+```
+
+## Output Structure
+
+The tool creates the following output structure:
+
+```
+mistral_ocr_output/
+├── document1.md           # Extracted text in markdown format
+├── document1_images/      # Extracted images (if enabled)
+│   ├── page1_img1.png
+│   └── page1_img2.png
+├── document2.md
+├── document2_images/
+│   └── ...
+└── metadata.json         # Processing statistics and errors
+```
+
+### Markdown Output
+
+Each processed document generates a markdown file containing:
+- Document metadata (source, processing time)
+- Extracted text with preserved formatting
+- Tables rendered in markdown format
+- Mathematical equations
+- Image references (if image extraction is enabled)
+
+### Metadata File
+
+The `metadata.json` file contains:
+- List of processed files
+- Processing time
+- File sizes
+- Output paths
+- Any errors encountered
+
+## Limitations
+
+- Maximum file size: 50 MB
+- Maximum pages per document: 1,000
+- Supported formats: PDF, JPG, JPEG, PNG, WEBP, GIF, BMP, TIFF
+
+## Pricing
+
+Mistral OCR API pricing: $1 per 1,000 pages ($0.001 per page)
+
+## Development
+
+### Run tests
+
+```bash
+poetry run pytest
+```
+
+### Format code
+
+```bash
+poetry run black mistral_ocr/
+poetry run ruff check mistral_ocr/
+```
+
+### Type checking
+
+```bash
+poetry run mypy mistral_ocr/
+```
+
+## Troubleshooting
+
+### API Key Not Found
+
+If you get an error about missing API key:
+1. Ensure `.env` file exists and contains `MISTRAL_API_KEY=your_key`
+2. Or export it: `export MISTRAL_API_KEY="your_key"`
+3. Or pass it directly: `mistral-ocr --api-key "your_key" ...`
+
+### File Size Error
+
+If a file exceeds 50 MB:
+- Consider splitting large PDFs into smaller parts
+- Compress images before processing
+
+### Installation Issues
+
+If the command is not found after installation:
+1. Ensure the package is installed: `pip show mistral-ocr`
+2. Check your PATH includes pip's script directory
+3. Try reinstalling with: `pip install -e .`
+
+## License
+
+MIT License - see LICENSE file for details
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Support
+
+For issues or questions about this CLI tool, please open an issue on [GitHub](https://github.com/r-uben/mistral-ocr-cli/issues)
+
+For questions about Mistral AI's OCR API, please refer to [Mistral's official documentation](https://docs.mistral.ai) or contact their support.
+
+## Legal
+
+"Mistral AI" and "Mistral" are trademarks of Mistral AI. This project is not affiliated with or endorsed by Mistral AI. The use of Mistral AI's OCR API is subject to Mistral AI's [Terms of Service](https://mistral.ai/terms/).

mistral_ocr_cli-1.0.0/README.md

@@ -0,0 +1,259 @@
+# Mistral OCR CLI
+
+A powerful command-line tool for OCR processing using Mistral AI's state-of-the-art OCR API. Process PDFs and images to extract text, tables, equations, and images with unprecedented accuracy.
+
+## ⚠️ Disclaimer
+
+**This is an unofficial, community-created tool** that uses Mistral AI's OCR API. This project is not affiliated with, officially maintained, or endorsed by Mistral AI.
+
+- **Official Mistral OCR**: https://mistral.ai/news/mistral-ocr
+- **Official Documentation**: https://docs.mistral.ai/capabilities/OCR/
+- **Mistral AI Platform**: https://console.mistral.ai/
+
+For official tools and support, please visit [Mistral AI's website](https://mistral.ai).
+
+## Features
+
+- 📄 **Multi-format Support**: Process PDFs and images (JPG, PNG, WEBP, GIF, BMP, TIFF)
+- 📊 **Advanced Extraction**: Extract text, tables, equations, and images
+- 📁 **Batch Processing**: Process single files or entire directories
+- 🎯 **Smart Output**: Preserves document structure in markdown format
+- 🖼️ **Image Extraction**: Optionally extract and save embedded images
+- 📈 **Progress Tracking**: Real-time progress bars for batch operations
+- 🔧 **Flexible Configuration**: Environment variables or command-line options
+
+## Installation
+
+### Prerequisites
+
+- Python 3.9 or higher
+- Mistral API key from [Mistral Console](https://console.mistral.ai/)
+
+### Install with Poetry (Recommended)
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/mistral-ocr.git
+cd mistral-ocr
+
+# Install Poetry if you haven't already
+curl -sSL https://install.python-poetry.org | python3 -
+
+# Install dependencies and the package
+poetry install
+
+# Make the command available globally
+poetry build
+pip install dist/mistral_ocr-*.whl
+```
+
+### Install with pip
+
+```bash
+# Clone the repository
+git clone https://github.com/yourusername/mistral-ocr.git
+cd mistral-ocr
+
+# Install in editable mode for global usage
+pip install -e .
+```
+
+## Configuration
+
+### 1. Set up your Mistral API key
+
+Create a `.env` file in your project root (or copy from `.env.example`):
+
+```bash
+cp .env.example .env
+```
+
+Edit `.env` and add your API key:
+
+```env
+MISTRAL_API_KEY=your_actual_api_key_here
+```
+
+### 2. Alternative: Export as environment variable
+
+```bash
+export MISTRAL_API_KEY="your_actual_api_key_here"
+```
+
+## Usage
+
+### Basic Usage
+
+Process a single PDF file (output saved to `mistral_ocr_output/` in the same directory):
+
+```bash
+mistral-ocr document.pdf
+```
+
+### Specify Output Directory
+
+```bash
+mistral-ocr document.pdf --output-path ./results
+```
+
+### Process Entire Directory
+
+```bash
+mistral-ocr ./documents --output-path ./extracted
+```
+
+### Command-Line Options
+
+```
+Usage: mistral-ocr INPUT_PATH [OPTIONS]
+
+Arguments:
+  INPUT_PATH                  Path to input file or directory (required)
+
+Options:
+  -o, --output-path PATH      Output directory (default: <input_dir>/mistral_ocr_output/)
+  --api-key TEXT             Mistral API key (or set MISTRAL_API_KEY env var)
+  --model TEXT               OCR model (default: mistral-ocr-latest)
+  --env-file PATH            Path to .env file
+  --include-images/--no-images  Extract images (default: True)
+  -v, --verbose              Enable verbose output
+  --version                  Show version
+  --help                     Show this message
+```
+
+## Examples
+
+### Process a single image
+
+```bash
+mistral-ocr photo.jpg
+```
+
+### Process multiple PDFs with custom output
+
+```bash
+mistral-ocr ./reports --output-path ./extracted_text --verbose
+```
+
+### Use a different .env file
+
+```bash
+mistral-ocr document.pdf --env-file .env.production
+```
+
+### Process without extracting images
+
+```bash
+mistral-ocr document.pdf --no-images
+```
+
+### Pass API key directly (not recommended for production)
+
+```bash
+mistral-ocr doc.pdf --api-key "your_api_key_here"
+```
+
+## Output Structure
+
+The tool creates the following output structure:
+
+```
+mistral_ocr_output/
+├── document1.md           # Extracted text in markdown format
+├── document1_images/      # Extracted images (if enabled)
+│   ├── page1_img1.png
+│   └── page1_img2.png
+├── document2.md
+├── document2_images/
+│   └── ...
+└── metadata.json         # Processing statistics and errors
+```
+
+### Markdown Output
+
+Each processed document generates a markdown file containing:
+- Document metadata (source, processing time)
+- Extracted text with preserved formatting
+- Tables rendered in markdown format
+- Mathematical equations
+- Image references (if image extraction is enabled)
+
+### Metadata File
+
+The `metadata.json` file contains:
+- List of processed files
+- Processing time
+- File sizes
+- Output paths
+- Any errors encountered
+
+## Limitations
+
+- Maximum file size: 50 MB
+- Maximum pages per document: 1,000
+- Supported formats: PDF, JPG, JPEG, PNG, WEBP, GIF, BMP, TIFF
+
+## Pricing
+
+Mistral OCR API pricing: $1 per 1,000 pages ($0.001 per page)
+
+## Development
+
+### Run tests
+
+```bash
+poetry run pytest
+```
+
+### Format code
+
+```bash
+poetry run black mistral_ocr/
+poetry run ruff check mistral_ocr/
+```
+
+### Type checking
+
+```bash
+poetry run mypy mistral_ocr/
+```
+
+## Troubleshooting
+
+### API Key Not Found
+
+If you get an error about missing API key:
+1. Ensure `.env` file exists and contains `MISTRAL_API_KEY=your_key`
+2. Or export it: `export MISTRAL_API_KEY="your_key"`
+3. Or pass it directly: `mistral-ocr --api-key "your_key" ...`
+
+### File Size Error
+
+If a file exceeds 50 MB:
+- Consider splitting large PDFs into smaller parts
+- Compress images before processing
+
+### Installation Issues
+
+If the command is not found after installation:
+1. Ensure the package is installed: `pip show mistral-ocr`
+2. Check your PATH includes pip's script directory
+3. Try reinstalling with: `pip install -e .`
+
+## License
+
+MIT License - see LICENSE file for details
+
+## Contributing
+
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## Support
+
+For issues or questions about this CLI tool, please open an issue on [GitHub](https://github.com/r-uben/mistral-ocr-cli/issues)
+
+For questions about Mistral AI's OCR API, please refer to [Mistral's official documentation](https://docs.mistral.ai) or contact their support.
+
+## Legal
+
+"Mistral AI" and "Mistral" are trademarks of Mistral AI. This project is not affiliated with or endorsed by Mistral AI. The use of Mistral AI's OCR API is subject to Mistral AI's [Terms of Service](https://mistral.ai/terms/).

mistral_ocr_cli-1.0.0/mistral_ocr/__init__.py

@@ -0,0 +1,9 @@
+"""Mistral OCR CLI - A clean command-line tool for OCR processing using Mistral AI."""
+
+__version__ = "1.0.0"
+__author__ = "Ruben Fernandez-Fuertes"
+
+from .processor import OCRProcessor
+from .config import Config
+
+__all__ = ["OCRProcessor", "Config"]

mistral_ocr_cli-1.0.0/mistral_ocr/__main__.py

@@ -0,0 +1,6 @@
+"""Entry point for running mistral_ocr as a module."""
+
+from .cli import main
+
+if __name__ == "__main__":
+    main()

mistral_ocr_cli-1.0.0/mistral_ocr/cli.py

@@ -0,0 +1,159 @@
+"""Command-line interface for Mistral OCR."""
+
+import os
+import sys
+from pathlib import Path
+from typing import Optional
+
+import click
+from rich.console import Console
+
+from .config import Config
+from .processor import OCRProcessor
+
+
+console = Console()
+
+# Get the original working directory if set
+ORIGINAL_CWD = os.environ.get('MISTRAL_OCR_CWD', os.getcwd())
+
+
+@click.command()
+@click.argument(
+    "input_path",
+    type=click.Path(path_type=Path),
+    required=True
+)
+@click.option(
+    "--output-path", "-o",
+    type=click.Path(path_type=Path),
+    required=False,
+    help="Path to output directory (default: <input_dir>/mistral_ocr_output/)"
+)
+@click.option(
+    "--api-key",
+    type=str,
+    envvar="MISTRAL_API_KEY",
+    help="Mistral API key (can also be set via MISTRAL_API_KEY env var)"
+)
+@click.option(
+    "--model",
+    type=str,
+    default="mistral-ocr-latest",
+    help="Mistral OCR model to use (default: mistral-ocr-latest)"
+)
+@click.option(
+    "--env-file",
+    type=click.Path(exists=True, path_type=Path),
+    help="Path to .env file containing configuration"
+)
+@click.option(
+    "--include-images/--no-images",
+    default=True,
+    help="Include extracted images in output (default: True)"
+)
+@click.option(
+    "--add-timestamp/--no-timestamp",
+    default=False,
+    help="Add timestamp to output folder name (default: False)"
+)
+@click.option(
+    "--verbose", "-v",
+    is_flag=True,
+    help="Enable verbose output"
+)
+@click.version_option(version="1.0.0", prog_name="mistral-ocr")
+def main(
+    input_path: Path,
+    output_path: Optional[Path],
+    api_key: Optional[str],
+    model: str,
+    env_file: Optional[Path],
+    include_images: bool,
+    add_timestamp: bool,
+    verbose: bool
+) -> None:
+    """
+    Mistral OCR - Process documents using Mistral AI's OCR API.
+    
+    This tool processes PDF and image files using Mistral's powerful OCR capabilities,
+    extracting text, tables, equations, and images with high accuracy.
+    
+    Examples:
+    
+        # Process a single PDF file
+        mistral-ocr document.pdf
+        
+        # Process all files in a directory
+        mistral-ocr ./documents --output-path ./results
+        
+        # Use a specific .env file
+        mistral-ocr doc.pdf --env-file .env.production
+    """
+    try:
+        # Resolve input path relative to original working directory
+        if not input_path.is_absolute():
+            input_path = Path(ORIGINAL_CWD) / input_path
+        
+        # Check if input path exists
+        if not input_path.exists():
+            raise ValueError(f"Input path does not exist: {input_path}")
+        
+        # Resolve output path if provided
+        if output_path and not output_path.is_absolute():
+            output_path = Path(ORIGINAL_CWD) / output_path
+        
+        # Print header
+        console.print("\n[bold blue]🔍 Mistral OCR[/bold blue]")
+        console.print("[dim]Powered by Mistral AI's OCR API[/dim]\n")
+        
+        # Load configuration
+        if verbose:
+            console.print("[dim]Loading configuration...[/dim]")
+        
+        # Create config from environment
+        if env_file:
+            config = Config.from_env(env_file)
+        else:
+            # If API key is provided via CLI, set it as env var
+            if api_key:
+                import os
+                os.environ["MISTRAL_API_KEY"] = api_key
+            
+            config = Config.from_env()
+        
+        # Override config with CLI options
+        config.model = model
+        config.include_images = include_images
+        config.verbose = verbose
+        
+        # Create processor
+        processor = OCRProcessor(config)
+        
+        # Process input
+        processor.process(input_path, output_path, add_timestamp=add_timestamp)
+        
+        # Print summary
+        if processor.errors and verbose:
+            console.print("\n[yellow]⚠ Errors encountered:[/yellow]")
+            for error in processor.errors:
+                console.print(f"  [red]• {error['file']}: {error['error']}[/red]")
+        
+        console.print("\n[bold green]✨ Processing complete![/bold green]\n")
+        
+    except ValueError as e:
+        console.print(f"\n[red]Error: {e}[/red]\n")
+        sys.exit(1)
+    except KeyboardInterrupt:
+        console.print("\n[yellow]Processing interrupted by user.[/yellow]\n")
+        sys.exit(130)
+    except Exception as e:
+        console.print(f"\n[red]Unexpected error: {e}[/red]\n")
+        if verbose:
+            import traceback
+            traceback.print_exc()
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

mistral_ocr_cli-1.0.0/mistral_ocr/config.py

@@ -0,0 +1,55 @@
+"""Configuration module for Mistral OCR."""
+
+import os
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Optional
+
+from dotenv import load_dotenv
+
+
+@dataclass
+class Config:
+    """Configuration for Mistral OCR."""
+    
+    api_key: str
+    model: str = "mistral-ocr-latest"
+    max_file_size_mb: int = 50
+    max_pages: int = 1000
+    output_format: str = "markdown"
+    include_images: bool = True
+    verbose: bool = False
+    
+    @classmethod
+    def from_env(cls, env_file: Optional[Path] = None) -> "Config":
+        """Load configuration from environment variables."""
+        if env_file and env_file.exists():
+            load_dotenv(env_file)
+        else:
+            load_dotenv()
+        
+        api_key = os.getenv("MISTRAL_API_KEY")
+        if not api_key:
+            raise ValueError(
+                "MISTRAL_API_KEY not found in environment variables. "
+                "Please set it or create a .env file."
+            )
+        
+        return cls(
+            api_key=api_key,
+            model=os.getenv("MISTRAL_MODEL", "mistral-ocr-latest"),
+            max_file_size_mb=int(os.getenv("MAX_FILE_SIZE_MB", "50")),
+            max_pages=int(os.getenv("MAX_PAGES", "1000")),
+            output_format=os.getenv("OUTPUT_FORMAT", "markdown"),
+            include_images=os.getenv("INCLUDE_IMAGES", "true").lower() == "true",
+            verbose=os.getenv("VERBOSE", "false").lower() == "true",
+        )
+    
+    def validate_file_size(self, file_path: Path) -> None:
+        """Validate that file size is within limits."""
+        file_size_mb = file_path.stat().st_size / (1024 * 1024)
+        if file_size_mb > self.max_file_size_mb:
+            raise ValueError(
+                f"File size ({file_size_mb:.2f} MB) exceeds maximum allowed size "
+                f"({self.max_file_size_mb} MB)"
+            )

mistral_ocr_cli-1.0.0/mistral_ocr/processor.py

@@ -0,0 +1,260 @@
+"""Core OCR processing module using Mistral AI."""
+
+import time
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+from mistralai import Mistral
+from rich.console import Console
+from rich.progress import Progress, SpinnerColumn, TextColumn, BarColumn, TimeRemainingColumn
+
+from .config import Config
+from .utils import (
+    create_data_uri,
+    determine_output_path,
+    format_file_size,
+    get_supported_files,
+    sanitize_filename,
+    save_base64_image,
+    save_metadata,
+)
+
+
+console = Console()
+
+
+class OCRProcessor:
+    """OCR processor using Mistral AI API."""
+    
+    def __init__(self, config: Config):
+        """Initialize the OCR processor."""
+        self.config = config
+        try:
+            self.client = Mistral(api_key=config.api_key)
+        except Exception as e:
+            console.print(f"[red]Failed to initialize Mistral client: {e}[/red]")
+            raise
+        self.errors: List[Dict] = []
+        self.processed_files: List[Dict] = []
+    
+    def process_file(self, file_path: Path) -> Optional[Dict]:
+        """Process a single file with OCR."""
+        try:
+            # Validate file size
+            file_size_mb = file_path.stat().st_size / (1024 * 1024)
+            if self.config.verbose:
+                console.print(f"[dim]File size: {file_size_mb:.2f} MB[/dim]")
+            self.config.validate_file_size(file_path)
+            
+            # Create data URI for the file
+            if self.config.verbose:
+                console.print(f"[dim]Creating data URI for {file_path.suffix} file...[/dim]")
+            data_uri = create_data_uri(file_path)
+            
+            # Determine document type based on file extension
+            if file_path.suffix.lower() == ".pdf":
+                document = {
+                    "type": "document_url",
+                    "document_url": data_uri
+                }
+            else:
+                document = {
+                    "type": "image_url",
+                    "image_url": data_uri
+                }
+            
+            # Process with Mistral OCR
+            if not hasattr(self.client, 'ocr'):
+                raise AttributeError(
+                    "OCR endpoint not available in Mistral client. "
+                    "Please ensure you have the latest mistralai package "
+                    "and OCR access enabled for your API key."
+                )
+            
+            if self.config.verbose:
+                console.print(f"[dim]Sending to Mistral OCR API...[/dim]")
+                console.print(f"[dim]Model: {self.config.model}[/dim]")
+            
+            response = self.client.ocr.process(
+                model=self.config.model,
+                document=document,
+                include_image_base64=self.config.include_images
+            )
+            
+            return {
+                "file_path": file_path,
+                "response": response,
+                "success": True
+            }
+            
+        except Exception as e:
+            error_msg = f"Error processing {file_path.name}: {str(e)}"
+            # Always show errors, not just in verbose mode
+            console.print(f"[red]{error_msg}[/red]")
+            if self.config.verbose:
+                import traceback
+                console.print(f"[dim]{traceback.format_exc()}[/dim]")
+            self.errors.append({
+                "file": str(file_path),
+                "error": str(e)
+            })
+            return None
+    
+    def save_results(
+        self, 
+        result: Dict, 
+        output_dir: Path,
+        is_single_file: bool = False
+    ) -> None:
+        """Save OCR results to files."""
+        file_path = result["file_path"]
+        response = result["response"]
+        
+        # For single files, use simpler naming
+        if is_single_file:
+            base_name = "output"
+            markdown_path = output_dir / "output.md"
+        else:
+            # For multiple files, use sanitized filename
+            base_name = sanitize_filename(file_path.stem, max_length=40)
+            markdown_path = output_dir / f"{base_name}.md"
+        
+        markdown_content = []
+        
+        # Add file header
+        markdown_content.append(f"# OCR Results\n\n")
+        markdown_content.append(f"**Original File:** {file_path.name}\n")
+        markdown_content.append(f"**Full Path:** `{file_path}`\n")
+        markdown_content.append(f"**Processed:** {time.strftime('%Y-%m-%d %H:%M:%S')}\n\n")
+        markdown_content.append("---\n\n")
+        
+        # Process each page
+        if hasattr(response, 'pages'):
+            for page in response.pages:
+                markdown_content.append(f"## Page {page.index + 1}\n\n")
+                
+                # Add extracted text
+                if hasattr(page, 'markdown'):
+                    markdown_content.append(page.markdown)
+                    markdown_content.append("\n\n")
+                
+                # Save images if included
+                if self.config.include_images and hasattr(page, 'images') and page.images:
+                    images_dir = output_dir / "images"
+                    images_dir.mkdir(parents=True, exist_ok=True)
+                    
+                    for idx, image in enumerate(page.images):
+                        if hasattr(image, 'base64'):
+                            image_filename = f"page{page.index + 1}_img{idx + 1}.png"
+                            image_path = images_dir / image_filename
+                            save_base64_image(image.base64, image_path)
+                            
+                            # Add image reference to markdown
+                            markdown_content.append(f"![Image {idx + 1}](./images/{image_filename})\n\n")
+        
+        # Write markdown file
+        with open(markdown_path, "w", encoding="utf-8") as f:
+            f.write("".join(markdown_content))
+        
+        if self.config.verbose:
+            console.print(f"[green]✓[/green] Saved results to {markdown_path}")
+    
+    def process_directory(
+        self, 
+        input_dir: Path, 
+        output_dir: Optional[Path] = None,
+        add_timestamp: bool = False
+    ) -> Tuple[int, int]:
+        """Process all supported files in a directory."""
+        files = get_supported_files(input_dir)
+        
+        if not files:
+            console.print("[yellow]No supported files found in the directory.[/yellow]")
+            return 0, 0
+        
+        output_path = determine_output_path(input_dir, output_dir, add_timestamp=add_timestamp)
+        console.print(f"[blue]Processing {len(files)} file(s)...[/blue]")
+        console.print(f"[blue]Output directory: {output_path}[/blue]\n")
+        
+        start_time = time.time()
+        success_count = 0
+        
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+            TimeRemainingColumn(),
+            console=console
+        ) as progress:
+            task = progress.add_task("Processing files...", total=len(files))
+            
+            for file_path in files:
+                file_size = format_file_size(file_path.stat().st_size)
+                progress.update(
+                    task, 
+                    description=f"Processing {file_path.name} ({file_size})..."
+                )
+                
+                result = self.process_file(file_path)
+                if result:
+                    self.save_results(result, output_path, is_single_file=False)
+                    success_count += 1
+                    base_name = sanitize_filename(file_path.stem, max_length=40)
+                    self.processed_files.append({
+                        "file": str(file_path),
+                        "size": file_path.stat().st_size,
+                        "output": str(output_path / f"{base_name}.md")
+                    })
+                
+                progress.update(task, advance=1)
+        
+        # Save metadata
+        processing_time = time.time() - start_time
+        save_metadata(output_path, self.processed_files, processing_time, self.errors)
+        
+        return success_count, len(files)
+    
+    def process(
+        self, 
+        input_path: Path, 
+        output_path: Optional[Path] = None,
+        add_timestamp: bool = False
+    ) -> None:
+        """Process input path (file or directory)."""
+        if input_path.is_file():
+            # Process single file
+            output_dir = determine_output_path(input_path, output_path, add_timestamp=add_timestamp)
+            console.print(f"[blue]Processing file: {input_path}[/blue]")
+            console.print(f"[blue]Output directory: {output_dir}[/blue]\n")
+            
+            start_time = time.time()
+            result = self.process_file(input_path)
+            
+            if result:
+                self.save_results(result, output_dir, is_single_file=True)
+                self.processed_files.append({
+                    "file": str(input_path),
+                    "size": input_path.stat().st_size,
+                    "output": str(output_dir / "output.md")
+                })
+                
+                # Save metadata
+                processing_time = time.time() - start_time
+                save_metadata(output_dir, self.processed_files, processing_time, self.errors)
+                
+                console.print(f"\n[green]✓ Successfully processed 1 file[/green]")
+                console.print(f"[dim]Processing time: {processing_time:.2f} seconds[/dim]")
+            else:
+                console.print(f"\n[red]✗ Failed to process file[/red]")
+        
+        elif input_path.is_dir():
+            # Process directory
+            success_count, total_count = self.process_directory(input_path, output_path, add_timestamp)
+            
+            console.print(f"\n[green]✓ Successfully processed {success_count}/{total_count} files[/green]")
+            if self.errors:
+                console.print(f"[red]✗ {len(self.errors)} file(s) failed[/red]")
+        
+        else:
+            raise ValueError(f"Input path does not exist: {input_path}")

mistral_ocr_cli-1.0.0/mistral_ocr/utils.py

@@ -0,0 +1,132 @@
+"""Utility functions for Mistral OCR."""
+
+import base64
+import json
+import mimetypes
+from pathlib import Path
+from typing import Dict, List, Optional, Tuple
+
+
+def encode_file_to_base64(file_path: Path) -> str:
+    """Encode a file to base64 string."""
+    with open(file_path, "rb") as file:
+        return base64.b64encode(file.read()).decode("utf-8")
+
+
+def get_mime_type(file_path: Path) -> str:
+    """Get MIME type of a file."""
+    mime_type, _ = mimetypes.guess_type(str(file_path))
+    if not mime_type:
+        if file_path.suffix.lower() == ".pdf":
+            return "application/pdf"
+        elif file_path.suffix.lower() in [".jpg", ".jpeg"]:
+            return "image/jpeg"
+        elif file_path.suffix.lower() == ".png":
+            return "image/png"
+        elif file_path.suffix.lower() == ".webp":
+            return "image/webp"
+        else:
+            raise ValueError(f"Unsupported file type: {file_path.suffix}")
+    return mime_type
+
+
+def create_data_uri(file_path: Path) -> str:
+    """Create a data URI from a file."""
+    mime_type = get_mime_type(file_path)
+    base64_data = encode_file_to_base64(file_path)
+    return f"data:{mime_type};base64,{base64_data}"
+
+
+def save_base64_image(base64_string: str, output_path: Path) -> None:
+    """Save a base64 encoded image to file."""
+    image_data = base64.b64decode(base64_string)
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+    with open(output_path, "wb") as f:
+        f.write(image_data)
+
+
+def get_supported_files(directory: Path) -> List[Path]:
+    """Get all supported files from a directory."""
+    supported_extensions = {".pdf", ".jpg", ".jpeg", ".png", ".webp", ".gif", ".bmp", ".tiff"}
+    files = []
+    
+    for file_path in directory.rglob("*"):
+        if file_path.is_file() and file_path.suffix.lower() in supported_extensions:
+            files.append(file_path)
+    
+    return sorted(files)
+
+
+def determine_output_path(
+    input_path: Path, 
+    output_path: Optional[Path] = None,
+    default_folder_name: str = "mistral_ocr_output",
+    add_timestamp: bool = False
+) -> Path:
+    """Determine the output path for OCR results."""
+    if output_path:
+        return output_path
+    
+    if input_path.is_file():
+        parent_dir = input_path.parent
+    else:
+        parent_dir = input_path
+    
+    # Add timestamp if requested
+    if add_timestamp:
+        import time
+        timestamp = time.strftime("%Y%m%d_%H%M%S")
+        folder_name = f"{default_folder_name}_{timestamp}"
+    else:
+        folder_name = default_folder_name
+    
+    output_dir = parent_dir / folder_name
+    output_dir.mkdir(parents=True, exist_ok=True)
+    return output_dir
+
+
+def save_metadata(
+    output_dir: Path,
+    files_processed: List[Dict],
+    processing_time: float,
+    errors: List[Dict]
+) -> None:
+    """Save processing metadata to JSON file."""
+    metadata = {
+        "files_processed": files_processed,
+        "total_files": len(files_processed),
+        "processing_time_seconds": processing_time,
+        "errors": errors,
+        "error_count": len(errors)
+    }
+    
+    metadata_path = output_dir / "metadata.json"
+    with open(metadata_path, "w") as f:
+        json.dump(metadata, f, indent=2, default=str)
+
+
+def format_file_size(size_bytes: int) -> str:
+    """Format file size in human-readable format."""
+    for unit in ["B", "KB", "MB", "GB"]:
+        if size_bytes < 1024.0:
+            return f"{size_bytes:.2f} {unit}"
+        size_bytes /= 1024.0
+    return f"{size_bytes:.2f} TB"
+
+
+def sanitize_filename(filename: str, max_length: int = 50) -> str:
+    """Sanitize filename by removing or replacing invalid characters."""
+    invalid_chars = '<>:"/\\|?*'
+    for char in invalid_chars:
+        filename = filename.replace(char, "_")
+    
+    # Truncate long filenames but keep extension
+    if len(filename) > max_length and '.' in filename:
+        name, ext = filename.rsplit('.', 1)
+        if len(name) > max_length - len(ext) - 1:
+            name = name[:max_length - len(ext) - 4] + "..."
+        filename = f"{name}.{ext}"
+    elif len(filename) > max_length:
+        filename = filename[:max_length - 3] + "..."
+    
+    return filename

mistral_ocr_cli-1.0.0/pyproject.toml

@@ -0,0 +1,66 @@
+[tool.poetry]
+name = "mistral-ocr-cli"
+version = "1.0.0"
+description = "A clean command-line tool for OCR processing using Mistral AI's API"
+authors = ["Ruben Fernandez-Fuertes <fernandezfuertesruben@gmail.com>"]
+readme = "README.md"
+packages = [{include = "mistral_ocr"}]
+license = "MIT"
+homepage = "https://github.com/rubenfernandez/mistral-ocr-cli"
+repository = "https://github.com/rubenfernandez/mistral-ocr-cli"
+keywords = ["ocr", "mistral", "pdf", "cli", "command-line", "document-processing", "text-extraction", "image-processing"]
+classifiers = [
+    "Development Status :: 5 - Production/Stable",
+    "Environment :: Console",
+    "Intended Audience :: Developers",
+    "Intended Audience :: Science/Research",
+    "License :: OSI Approved :: MIT License",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.9",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Topic :: Software Development :: Libraries :: Python Modules",
+    "Topic :: Text Processing",
+    "Topic :: Utilities",
+    "Topic :: Scientific/Engineering :: Artificial Intelligence",
+]
+
+[tool.poetry.dependencies]
+python = "^3.9"
+mistralai = "^1.0.0"
+python-dotenv = "^1.0.0"
+click = "^8.1.7"
+rich = "^13.7.0"
+Pillow = "^10.2.0"
+pypdf = "^4.0.0"
+
+[tool.poetry.group.dev.dependencies]
+pytest = "^8.0.0"
+black = "^24.0.0"
+ruff = "^0.3.0"
+mypy = "^1.8.0"
+pytest-cov = "^4.1.0"
+
+[tool.poetry.scripts]
+mistral-ocr = "mistral_ocr.cli:main"
+
+[build-system]
+requires = ["poetry-core"]
+build-backend = "poetry.core.masonry.api"
+
+[tool.black]
+line-length = 100
+target-version = ['py39']
+
+[tool.ruff]
+line-length = 100
+select = ["E", "F", "I", "N", "UP", "B", "C4", "SIM"]
+ignore = ["E501"]
+
+[tool.mypy]
+python_version = "3.9"
+warn_return_any = true
+warn_unused_configs = true
+disallow_untyped_defs = true