Implement Markit_GOT files into Markit_v2

.gitignore

@@ -0,0 +1,87 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+
+# Environment variables
+.env
+.env.local
+.env.development.local
+.env.test.local
+.env.production.local
+
+# Tesseract
+tessdata/
+
+# Temporary files
+*.tmp
+*.temp
+temp/
+tmp/
+
+# Logs
+logs/
+*.log
+npm-debug.log*
+yarn-debug.log*
+yarn-error.log*
+
+# Editor directories and files
+.idea/
+.vscode/
+*.swp
+*.swo
+*~
+
+# OS specific
+.DS_Store
+Thumbs.db
+
+# Virtual environment
+.venv/
+venv/
+ENV/
+
+# Distribution / packaging
+*.egg-info/
+
+# Local Gradio files
+.gradio/
+
+# IDE specific files
+*.swp
+*.swo
+
+# Backup folder
+/backup
+
+# Specific files to ignore
+README_HF.md
+requirement.txt
+.env_example
+test_gemini_parser.py
+
+# Ignore documents folder
+/documents/
+/documents/*
+
+# Ignore tessdata folder
+/tessdata/
+/tessdata/*

README.md

@@ -1,12 +1,220 @@
 ---
-title: Markit V2
-emoji: 📈
-colorFrom: yellow
-colorTo: pink
+title: Markit
+emoji: 📄
+colorFrom: blue
+colorTo: indigo
 sdk: gradio
-sdk_version: 5.21.0
+sdk_version: 5.14.0
 app_file: app.py
+build_script: build.sh
+startup_script: setup.sh
 pinned: false
 ---
 
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference
+# Markit: Document to Markdown Converter
+
+[![Hugging Face Space](https://img.shields.io/badge/🤗%20Hugging%20Face-Space-blue)](https://huggingface.co/spaces/Ansemin101/Markit)
+
+**Author: Anse Min** | [GitHub](https://github.com/ansemin) | [LinkedIn](https://www.linkedin.com/in/ansemin/)
+
+## Project Links
+- **GitHub Repository**: [github.com/ansemin/Markit_HF](https://github.com/ansemin/Markit_HF)
+- **Hugging Face Space**: [huggingface.co/spaces/Ansemin101/Markit](https://huggingface.co/spaces/Ansemin101/Markit)
+
+## Overview
+Markit is a powerful tool that converts various document formats (PDF, DOCX, images, etc.) to Markdown format. It uses different parsing engines and OCR methods to extract text from documents and convert them to clean, readable Markdown formats.
+
+## Key Features
+- **Multiple Document Formats**: Convert PDFs, Word documents, images, and other document formats
+- **Versatile Output Formats**: Export to Markdown, JSON, plain text, or document tags format
+- **Advanced Parsing Engines**:
+  - **PyPdfium**: Fast PDF parsing using the PDFium engine
+  - **Docling**: Advanced document structure analysis
+  - **Marker**: Specialized for markup and formatting
+  - **Gemini Flash**: AI-powered conversion using Google's Gemini API
+  - **GOT-OCR**: State-of-the-art OCR model for images (JPG/PNG only)
+- **OCR Integration**: Extract text from images and scanned documents using Tesseract OCR
+- **Interactive UI**: User-friendly Gradio interface with page navigation for large documents
+- **AI-Powered Chat**: Interact with your documents using AI to ask questions about content
+
+## System Architecture
+The application is built with a modular architecture:
+- **Core Engine**: Handles document conversion and processing workflows
+- **Parser Registry**: Central registry for all document parsers
+- **UI Layer**: Gradio-based web interface
+- **Service Layer**: Handles AI chat functionality and external services integration
+
+## Installation
+
+### For Local Development
+1. Clone the repository
+2. Install dependencies:
+   ```bash
+   pip install -r requirements.txt
+   ```
+3. Install Tesseract OCR (required for OCR functionality):
+   - Windows: Download and install from [GitHub](https://github.com/UB-Mannheim/tesseract/wiki)
+   - Linux: `sudo apt-get install tesseract-ocr libtesseract-dev`
+   - macOS: `brew install tesseract`
+
+4. Run the application:
+   ```bash
+   python app.py
+   ```
+
+### API Keys Setup
+
+#### Gemini Flash Parser
+To use the Gemini Flash parser, you need to:
+1. Install the Google Generative AI client: `pip install google-genai`
+2. Set the API key environment variable:
+   ```bash
+   # On Windows
+   set GOOGLE_API_KEY=your_api_key_here
+   
+   # On Linux/Mac
+   export GOOGLE_API_KEY=your_api_key_here
+   ```
+3. Alternatively, create a `.env` file in the project root with:
+   ```
+   GOOGLE_API_KEY=your_api_key_here
+   ```
+4. Get your Gemini API key from [Google AI Studio](https://aistudio.google.com/app/apikey)
+
+#### GOT-OCR Parser
+The GOT-OCR parser requires:
+1. CUDA-capable GPU with sufficient memory
+2. The following dependencies will be installed automatically:
+   ```bash
+   torch>=2.0.1
+   torchvision>=0.15.2
+   transformers>=4.37.2,<4.48.0  # Specific version range required
+   tiktoken>=0.6.0
+   verovio>=4.3.1
+   accelerate>=0.28.0
+   ```
+3. Note that GOT-OCR only supports JPG and PNG image formats
+
+## Deploying to Hugging Face Spaces
+
+### Environment Configuration
+1. Go to your Space settings: `https://huggingface.co/spaces/YOUR_USERNAME/YOUR_SPACE_NAME/settings`
+2. Add the following repository secrets:
+   - Name: `GOOGLE_API_KEY`
+   - Value: Your Gemini API key
+
+### Space Configuration
+Ensure your Hugging Face Space configuration includes:
+```yaml
+build:
+  dockerfile: Dockerfile
+  python_version: "3.10" 
+  system_packages:
+    - "tesseract-ocr"
+    - "libtesseract-dev"
+```
+
+## How to Use
+
+### Document Conversion
+1. Upload your document using the file uploader
+2. Select a parser provider:
+   - **PyPdfium**: Best for standard PDFs with selectable text
+   - **Docling**: Best for complex document layouts
+   - **Marker**: Best for preserving document formatting
+   - **Gemini Flash**: Best for AI-powered conversions (requires API key)
+   - **GOT-OCR**: Best for high-quality OCR on images (JPG/PNG only)
+3. Choose an OCR option based on your selected parser:
+   - **None**: No OCR processing (for documents with selectable text)
+   - **Tesseract**: Basic OCR using Tesseract
+   - **Advanced**: Enhanced OCR with layout preservation (available with specific parsers)
+4. Select your desired output format:
+   - **Markdown**: Clean, readable markdown format
+   - **JSON**: Structured data representation
+   - **Text**: Plain text extraction
+   - **Document Tags**: XML-like structure tags
+5. Click "Convert" to process your document
+6. Navigate through pages using the navigation buttons for multi-page documents
+7. Download the converted content in your selected format
+
+### Document Chat
+1. After converting a document, switch to the "Chat with Document" tab
+2. Type your questions about the document content
+3. The AI will analyze the document and provide context-aware responses
+4. Use the conversation history to track your Q&A session
+5. Click "Clear" to start a new conversation
+
+## Troubleshooting
+
+### OCR Issues
+- Ensure Tesseract is properly installed and in your system PATH
+- Check the TESSDATA_PREFIX environment variable is set correctly
+- Verify language files are available in the tessdata directory
+
+### Gemini Flash Parser Issues
+- Confirm your API key is set correctly as an environment variable
+- Check for API usage limits or restrictions
+- Verify the document format is supported by the Gemini API
+
+### GOT-OCR Parser Issues
+- Ensure you have a CUDA-capable GPU with sufficient memory
+- Verify that all required dependencies are installed correctly
+- Remember that GOT-OCR only supports JPG and PNG image formats
+- If you encounter CUDA out-of-memory errors, try using a smaller image
+- GOT-OCR requires transformers version <4.48.0 due to API changes in newer versions
+- If you see errors about 'get_max_length', downgrade transformers to version 4.47.0
+
+### General Issues
+- Check the console logs for error messages
+- Ensure all dependencies are installed correctly
+- For large documents, try processing fewer pages at a time
+
+## Development Guide
+
+### Project Structure
+
+```
+markit/
+├── app.py                  # Main application entry point
+├── setup.sh                # Setup script
+├── build.sh                # Build script
+├── requirements.txt        # Python dependencies
+├── README.md               # Project documentation
+├── .env                    # Environment variables
+├── .gitignore              # Git ignore file
+├── .gitattributes          # Git attributes file
+├── src/                    # Source code
+│   ├── __init__.py         # Package initialization
+│   ├── main.py             # Main module
+│   ├── core/               # Core functionality
+│   │   ├── __init__.py     # Package initialization
+│   │   ├── converter.py    # Document conversion logic
+│   │   └── parser_factory.py # Parser factory
+│   ├── parsers/            # Parser implementations
+│   │   ├── __init__.py     # Package initialization
+│   │   ├── parser_interface.py # Parser interface
+│   │   ├── parser_registry.py # Parser registry
+│   │   ├── docling_parser.py # Docling parser
+│   │   ├── marker_parser.py # Marker parser
+│   │   └── pypdfium_parser.py # PyPDFium parser
+│   ├── ui/                 # User interface
+│   │   ├── __init__.py     # Package initialization
+│   │   └── ui.py           # Gradio UI implementation
+│   └── services/           # External services
+│       ├── __init__.py     # Package initialization
+│       └── docling_chat.py # Chat service
+└── tests/                  # Tests
+    └── __init__.py         # Package initialization
+```
+
+### Adding a New Parser
+1. Create a new parser class implementing the `DocumentParser` interface
+2. Register the parser with the `ParserRegistry`
+3. Implement the required methods: `get_name()`, `get_supported_ocr_methods()`, and `parse()`
+4. Add your parser to the imports in `src/parsers/__init__.py`
+
+## Contributing
+Contributions are welcome! Please feel free to submit a Pull Request.
+
+## License
+This project is open source and available under the MIT License.

app.py

@@ -0,0 +1,138 @@
+import sys
+import os
+import subprocess
+import shutil
+from pathlib import Path
+import urllib.request
+
+# Get the current directory
+current_dir = os.path.dirname(os.path.abspath(__file__))
+
+# Run setup.sh at startup
+try:
+    setup_script = os.path.join(current_dir, "setup.sh")
+    if os.path.exists(setup_script):
+        print("Running setup.sh...")
+        subprocess.run(["bash", setup_script], check=False)
+        print("setup.sh completed")
+except Exception as e:
+    print(f"Error running setup.sh: {e}")
+
+# Try to load environment variables from .env file
+try:
+    from dotenv import load_dotenv
+    load_dotenv()
+    print("Loaded environment variables from .env file")
+except ImportError:
+    print("python-dotenv not installed, skipping .env file loading")
+
+# Function to setup Tesseract
+def setup_tesseract():
+    """Setup Tesseract OCR environment."""
+    print("Setting up Tesseract OCR environment...")
+    
+    # Create tessdata directory if it doesn't exist
+    tessdata_dir = os.path.join(current_dir, "tessdata")
+    os.makedirs(tessdata_dir, exist_ok=True)
+    
+    # Set TESSDATA_PREFIX environment variable if not already set
+    if not os.environ.get('TESSDATA_PREFIX'):
+        # Check multiple possible locations
+        possible_tessdata_dirs = [
+            tessdata_dir,  # Our local tessdata directory
+            "/usr/share/tesseract-ocr/4.00/tessdata",  # Common location in Hugging Face
+            "/usr/share/tesseract-ocr/tessdata",  # Another common location
+            "/usr/local/share/tessdata",  # Standard installation location
+        ]
+        
+        # Use the first directory that exists
+        for dir_path in possible_tessdata_dirs:
+            if os.path.exists(dir_path):
+                os.environ['TESSDATA_PREFIX'] = dir_path
+                print(f"Set TESSDATA_PREFIX to {dir_path}")
+                break
+        else:
+            # If none exist, use our local directory
+            os.environ['TESSDATA_PREFIX'] = tessdata_dir
+            print(f"No existing tessdata directory found, set TESSDATA_PREFIX to {tessdata_dir}")
+    
+    # Download eng.traineddata if it doesn't exist in our local tessdata
+    eng_traineddata = os.path.join(tessdata_dir, "eng.traineddata")
+    if not os.path.exists(eng_traineddata):
+        try:
+            print("Downloading eng.traineddata...")
+            url = "https://github.com/tesseract-ocr/tessdata/raw/main/eng.traineddata"
+            urllib.request.urlretrieve(url, eng_traineddata)
+            print("Downloaded eng.traineddata")
+        except Exception as e:
+            print(f"Error downloading eng.traineddata: {e}")
+    
+    # Configure pytesseract
+    try:
+        import pytesseract
+        # Check if tesseract is in PATH
+        tesseract_cmd = shutil.which("tesseract")
+        if tesseract_cmd:
+            pytesseract.pytesseract.tesseract_cmd = tesseract_cmd
+            print(f"Set pytesseract.tesseract_cmd to {tesseract_cmd}")
+        else:
+            # Try common locations
+            common_locations = [
+                "/usr/bin/tesseract",
+                "/usr/local/bin/tesseract",
+                "/app/tesseract/tesseract"
+            ]
+            for location in common_locations:
+                if os.path.isfile(location) and os.access(location, os.X_OK):
+                    pytesseract.pytesseract.tesseract_cmd = location
+                    print(f"Set pytesseract.tesseract_cmd to {location}")
+                    break
+            else:
+                print("Warning: Could not find tesseract executable")
+    except ImportError:
+        print("pytesseract not installed")
+    
+    # Try to import tesserocr to verify it's working
+    try:
+        import tesserocr
+        print(f"tesserocr imported successfully, version: {tesserocr.tesseract_version()}")
+    except ImportError:
+        print("tesserocr not installed or not working")
+    except Exception as e:
+        print(f"Error importing tesserocr: {e}")
+
+# Load Gemini API key from environment variable
+gemini_api_key = os.getenv("GOOGLE_API_KEY")
+
+# Check if API key is available and print a message if not
+if not gemini_api_key:
+    print("Warning: GOOGLE_API_KEY environment variable not found. Gemini Flash parser may not work.")
+else:
+    print(f"Found Gemini API key: {gemini_api_key[:5]}...{gemini_api_key[-5:] if len(gemini_api_key) > 10 else ''}")
+
+# Add the current directory to the Python path
+sys.path.append(current_dir)
+
+# Try different import approaches
+try:
+    # First attempt - standard import
+    from src.main import main
+except ModuleNotFoundError:
+    try:
+        # Second attempt - adjust path and try again
+        sys.path.append(os.path.join(current_dir, "src"))
+        from src.main import main
+    except ModuleNotFoundError:
+        # Third attempt - create __init__.py if it doesn't exist
+        init_path = os.path.join(current_dir, "src", "__init__.py")
+        if not os.path.exists(init_path):
+            with open(init_path, "w") as f:
+                pass  # Create empty __init__.py file
+        # Try import again
+        from src.main import main
+
+# Call setup function at import time
+setup_tesseract()
+
+if __name__ == "__main__":
+    main()

build.sh

@@ -0,0 +1,96 @@
+#!/bin/bash
+
+# Exit on error
+set -e
+
+echo "Starting build process..."
+
+# Install system dependencies for tesseract
+echo "Installing Tesseract and dependencies..."
+apt-get update && apt-get install -y \
+    tesseract-ocr \
+    tesseract-ocr-eng \
+    libtesseract-dev \
+    libleptonica-dev \
+    pkg-config \
+    wget
+
+# Create tessdata directory
+TESSDATA_DIR="/usr/share/tesseract-ocr/4.00/tessdata"
+mkdir -p "$TESSDATA_DIR"
+
+# Download traineddata files directly from the official repository
+echo "Downloading Tesseract traineddata files..."
+wget -O "$TESSDATA_DIR/eng.traineddata" "https://github.com/tesseract-ocr/tessdata/raw/main/eng.traineddata"
+wget -O "$TESSDATA_DIR/osd.traineddata" "https://github.com/tesseract-ocr/tessdata/raw/main/osd.traineddata"
+
+# Set and verify TESSDATA_PREFIX
+export TESSDATA_PREFIX="$TESSDATA_DIR"
+echo "TESSDATA_PREFIX=${TESSDATA_PREFIX}" >> /etc/environment
+
+# Verify tesseract installation and data files
+echo "Verifying Tesseract installation..."
+if ! command -v tesseract &> /dev/null; then
+    echo "Tesseract installation failed!"
+    exit 1
+fi
+echo "Tesseract version: $(tesseract --version)"
+
+# Verify traineddata files
+echo "Verifying traineddata files..."
+if [ ! -f "$TESSDATA_DIR/eng.traineddata" ]; then
+    echo "eng.traineddata is missing!"
+    exit 1
+fi
+if [ ! -f "$TESSDATA_DIR/osd.traineddata" ]; then
+    echo "osd.traineddata is missing!"
+    exit 1
+fi
+
+echo "Traineddata files in $TESSDATA_DIR:"
+ls -l "$TESSDATA_DIR"
+
+# Test Tesseract functionality
+echo "Testing Tesseract functionality..."
+echo "Hello World" > test.png
+if ! tesseract test.png stdout; then
+    echo "Tesseract test failed!"
+    exit 1
+fi
+rm test.png
+
+# Clean and install tesserocr from source
+echo "Installing tesserocr from source..."
+pip uninstall -y tesserocr || true
+CPPFLAGS="-I/usr/include/tesseract" LDFLAGS="-L/usr/lib/x86_64-linux-gnu/" pip install --no-binary :all: tesserocr
+
+# Verify tesserocr installation
+echo "Verifying tesserocr installation..."
+python3 -c "
+import tesserocr
+print(f'tesserocr version: {tesserocr.__version__}')
+print(f'Available languages: {tesserocr.get_languages()}')
+print(f'TESSDATA_PREFIX: {tesserocr.get_languages()[1]}')
+"
+
+# Install Google Gemini API client
+echo "Installing Google Gemini API client..."
+pip install -q -U google-genai
+echo "Google Gemini API client installed successfully"
+
+# Install GOT-OCR dependencies
+echo "Installing GOT-OCR dependencies..."
+pip install -q -U torch==2.0.1 torchvision==0.15.2 transformers==4.47.0 tiktoken==0.6.0 verovio==4.3.1 accelerate==0.28.0 safetensors==0.4.0
+echo "GOT-OCR dependencies installed successfully"
+
+# Install Python dependencies
+echo "Installing Python dependencies..."
+pip install -e .
+
+# Create .env file if it doesn't exist
+if [ ! -f .env ]; then
+    echo "Creating .env file..."
+    cp .env.example .env || echo "Warning: .env.example not found"
+fi
+
+echo "Build process completed successfully!"

packages.txt

@@ -0,0 +1,6 @@
+tesseract-ocr
+tesseract-ocr-eng
+libtesseract-dev
+libleptonica-dev
+imagemagick
+poppler-utils 

requirements.txt

@@ -0,0 +1,35 @@
+docling==2.25.0
+gradio==5.14.0
+grpcio-status==1.70.0
+markdown==3.7
+marker-pdf==1.3.5
+multiprocess==0.70.16
+openai==1.61.1
+pipdeptree==2.25.0
+pytesseract==0.3.13
+semchunk==2.2.2
+Pillow>=9.0.0
+numpy>=1.21.0
+# Tesseract dependencies
+tesseract==0.1.3
+tesserocr>=2.5.0; platform_system != "Windows"  # Only install on non-Windows systems
+# Additional dependencies for image processing
+opencv-python-headless>=4.5.0  # Headless version for server environments
+pdf2image>=1.16.0  # For PDF processing
+dill==0.3.8  # Downgraded to be compatible with datasets
+# Gemini API client
+google-genai>=0.1.0
+# Environment variables
+python-dotenv>=1.0.0
+# Pin pydantic to resolve compatibility issues with gradio
+pydantic==2.7.1
+
+# GOT-OCR dependencies
+torch>=2.0.1
+torchvision>=0.15.2
+transformers>=4.37.2,<4.48.0  # Pin to a compatible version for GOT-OCR
+tiktoken>=0.6.0
+verovio>=4.3.1
+accelerate>=0.28.0
+safetensors>=0.4.0
+packaging>=21.0  # For version comparison

setup.sh

@@ -0,0 +1,76 @@
+#!/bin/bash
+
+# Exit on error
+set -e
+
+echo "Setting up Tesseract OCR environment..."
+
+# Install required packages if not already installed
+if ! command -v tesseract &> /dev/null; then
+    echo "Tesseract not found, attempting to install..."
+    apt-get update -y || echo "Failed to update apt, continuing anyway"
+    apt-get install -y tesseract-ocr tesseract-ocr-eng libtesseract-dev libleptonica-dev || echo "Failed to install tesseract via apt, continuing anyway"
+fi
+
+# Install Python dependencies
+echo "Installing Python dependencies..."
+pip install -q -U pytesseract pillow opencv-python-headless pdf2image
+pip install -q -U google-genai
+echo "Python dependencies installed successfully"
+
+# Install GOT-OCR dependencies
+echo "Installing GOT-OCR dependencies..."
+pip install -q -U torch==2.0.1 torchvision==0.15.2 transformers==4.47.0 tiktoken==0.6.0 verovio==4.3.1 accelerate==0.28.0 safetensors==0.4.0
+echo "GOT-OCR dependencies installed successfully"
+
+# Install tesserocr with pip
+echo "Installing tesserocr..."
+pip install -q -U tesserocr || echo "Failed to install tesserocr with pip, trying with specific compiler flags..."
+
+# If tesserocr installation failed, try with specific compiler flags
+if ! python -c "import tesserocr" &> /dev/null; then
+    echo "Trying alternative tesserocr installation..."
+    CPPFLAGS="-I/usr/local/include -I/usr/include" LDFLAGS="-L/usr/local/lib -L/usr/lib" pip install -q -U tesserocr || echo "Failed to install tesserocr with compiler flags, continuing anyway"
+fi
+
+# Create tessdata directory if it doesn't exist
+mkdir -p tessdata
+
+# Set TESSDATA_PREFIX environment variable
+export TESSDATA_PREFIX="$(pwd)/tessdata"
+echo "TESSDATA_PREFIX set to: $TESSDATA_PREFIX"
+
+# Download eng.traineddata if it doesn't exist
+if [ ! -f "tessdata/eng.traineddata" ]; then
+  echo "Downloading eng.traineddata..."
+  wget -O tessdata/eng.traineddata https://github.com/tesseract-ocr/tessdata/raw/main/eng.traineddata || \
+  curl -o tessdata/eng.traineddata https://github.com/tesseract-ocr/tessdata/raw/main/eng.traineddata
+  echo "Downloaded eng.traineddata"
+else
+  echo "eng.traineddata already exists"
+fi
+
+# Try to copy to system locations (may fail in restricted environments)
+for tessdata_dir in "/usr/share/tesseract-ocr/4.00/tessdata" "/usr/share/tesseract-ocr/tessdata" "/usr/local/share/tessdata"; do
+  if [ -d "$tessdata_dir" ]; then
+    echo "Copying eng.traineddata to $tessdata_dir..."
+    cp -f tessdata/eng.traineddata "$tessdata_dir/" 2>/dev/null || echo "Failed to copy to $tessdata_dir, continuing anyway"
+  fi
+done
+
+# Verify Tesseract installation
+echo "Verifying Tesseract installation..."
+tesseract --version || echo "Tesseract not found in PATH, but may still be available to Python"
+
+# Test tesserocr if installed
+echo "Testing tesserocr..."
+python -c "import tesserocr; print(f'tesserocr version: {tesserocr.tesseract_version()}')" || echo "tesserocr not working, but may still be able to use pytesseract"
+
+# Test pytesseract
+echo "Testing pytesseract..."
+python -c "import pytesseract; print(f'pytesseract path: {pytesseract.tesseract_cmd}')" || echo "pytesseract not working"
+
+echo "Setup completed"
+
+# Add TESSDATA_PREFIX to .env file for persistence
+echo "TESSDATA_PREFIX=$(pwd)/tessdata" >> .env 

src/__init__.py

@@ -0,0 +1 @@
+# This file makes the src directory a Python package 

src/core/__init__.py

@@ -0,0 +1 @@
+"""Core functionality module for document conversion.""" 

src/core/converter.py

@@ -0,0 +1,190 @@
+import tempfile
+import logging
+import time
+import os
+from pathlib import Path
+
+# Use relative imports instead of absolute imports
+from src.core.parser_factory import ParserFactory
+
+# Import all parsers to ensure they're registered
+import parsers
+
+# Reference to the cancellation flag from ui.py
+# This will be set by the UI when the cancel button is clicked
+conversion_cancelled = None  # Will be a threading.Event object
+# Flag to track if conversion is currently in progress
+_conversion_in_progress = False
+
+def set_cancellation_flag(flag):
+    """Set the reference to the cancellation flag from ui.py"""
+    global conversion_cancelled
+    conversion_cancelled = flag
+
+def is_conversion_in_progress():
+    """Check if conversion is currently in progress"""
+    global _conversion_in_progress
+    return _conversion_in_progress
+
+def check_cancellation():
+    """Check if cancellation has been requested"""
+    if conversion_cancelled and conversion_cancelled.is_set():
+        logging.info("Cancellation detected in check_cancellation")
+        return True
+    return False
+
+def safe_delete_file(file_path):
+    """Safely delete a file with error handling"""
+    if file_path and os.path.exists(file_path):
+        try:
+            os.unlink(file_path)
+        except Exception as e:
+            logging.error(f"Error cleaning up temp file {file_path}: {e}")
+
+def convert_file(file_path, parser_name, ocr_method_name, output_format):
+    """
+    Convert a file using the specified parser and OCR method.
+    
+    Args:
+        file_path: Path to the file
+        parser_name: Name of the parser to use
+        ocr_method_name: Name of the OCR method to use
+        output_format: Output format (Markdown, JSON, Text, Document Tags)
+        
+    Returns:
+        tuple: (content, download_file_path)
+    """
+    global conversion_cancelled, _conversion_in_progress
+    
+    # Set the conversion in progress flag
+    _conversion_in_progress = True
+    
+    # Temporary file paths to clean up
+    temp_input = None
+    tmp_path = None
+    
+    # Ensure we clean up the flag when we're done
+    try:
+        if not file_path:
+            return "Please upload a file.", None
+
+        # Check for cancellation
+        if check_cancellation():
+            logging.info("Cancellation detected at start of convert_file")
+            return "Conversion cancelled.", None
+
+        # Create a temporary file with English filename
+        try:
+            original_ext = Path(file_path).suffix
+            with tempfile.NamedTemporaryFile(suffix=original_ext, delete=False) as temp_file:
+                temp_input = temp_file.name
+                # Copy the content of original file to temp file
+                with open(file_path, 'rb') as original:
+                    # Read in smaller chunks and check for cancellation between chunks
+                    chunk_size = 1024 * 1024  # 1MB chunks
+                    while True:
+                        # Check for cancellation frequently
+                        if check_cancellation():
+                            logging.info("Cancellation detected during file copy")
+                            safe_delete_file(temp_input)
+                            return "Conversion cancelled.", None
+                        
+                        chunk = original.read(chunk_size)
+                        if not chunk:
+                            break
+                        temp_file.write(chunk)
+            file_path = temp_input
+        except Exception as e:
+            safe_delete_file(temp_input)
+            return f"Error creating temporary file: {e}", None
+
+        # Check for cancellation again
+        if check_cancellation():
+            logging.info("Cancellation detected after file preparation")
+            safe_delete_file(temp_input)
+            return "Conversion cancelled.", None
+
+        content = None
+        try:
+            # Use the parser factory to parse the document
+            start = time.time()
+            
+            # Pass the cancellation flag to the parser factory
+            content = ParserFactory.parse_document(
+                file_path=file_path,
+                parser_name=parser_name,
+                ocr_method_name=ocr_method_name,
+                output_format=output_format.lower(),
+                cancellation_flag=conversion_cancelled  # Pass the flag to parsers
+            )
+            
+            # If content indicates cancellation, return early
+            if content == "Conversion cancelled.":
+                logging.info("Parser reported cancellation")
+                safe_delete_file(temp_input)
+                return content, None
+            
+            duration = time.time() - start
+            logging.info(f"Processed in {duration:.2f} seconds.")
+            
+            # Check for cancellation after processing
+            if check_cancellation():
+                logging.info("Cancellation detected after processing")
+                safe_delete_file(temp_input)
+                return "Conversion cancelled.", None
+                
+        except Exception as e:
+            safe_delete_file(temp_input)
+            return f"Error: {e}", None
+
+        # Determine the file extension based on the output format
+        if output_format == "Markdown":
+            ext = ".md"
+        elif output_format == "JSON":
+            ext = ".json"
+        elif output_format == "Text":
+            ext = ".txt"
+        elif output_format == "Document Tags":
+            ext = ".doctags"
+        else:
+            ext = ".txt"
+
+        # Check for cancellation again
+        if check_cancellation():
+            logging.info("Cancellation detected before output file creation")
+            safe_delete_file(temp_input)
+            return "Conversion cancelled.", None
+
+        try:
+            # Create a temporary file for download
+            with tempfile.NamedTemporaryFile(mode="w", suffix=ext, delete=False, encoding="utf-8") as tmp:
+                tmp_path = tmp.name
+                # Write in chunks and check for cancellation
+                chunk_size = 10000  # characters
+                for i in range(0, len(content), chunk_size):
+                    # Check for cancellation
+                    if check_cancellation():
+                        logging.info("Cancellation detected during output file writing")
+                        safe_delete_file(tmp_path)
+                        safe_delete_file(temp_input)
+                        return "Conversion cancelled.", None
+                    
+                    tmp.write(content[i:i+chunk_size])
+            
+            # Clean up the temporary input file
+            safe_delete_file(temp_input)
+            temp_input = None  # Mark as cleaned up
+                
+            return content, tmp_path
+        except Exception as e:
+            safe_delete_file(tmp_path)
+            safe_delete_file(temp_input)
+            return f"Error: {e}", None
+    finally:
+        # Always clean up any remaining temp files
+        safe_delete_file(temp_input)
+        if check_cancellation() and tmp_path:
+            safe_delete_file(tmp_path)
+            
+        # Always clear the conversion in progress flag when done
+        _conversion_in_progress = False

src/core/parser_factory.py

@@ -0,0 +1,95 @@
+from typing import Optional, Dict, Any, Union
+from pathlib import Path
+import threading
+import logging
+import time
+
+from src.parsers.parser_interface import DocumentParser
+from src.parsers.parser_registry import ParserRegistry
+
+
+class ParserFactory:
+    """Factory for creating parser instances."""
+    
+    @classmethod
+    def create_parser(cls, parser_name: str) -> Optional[DocumentParser]:
+        """
+        Create a parser instance.
+        
+        Args:
+            parser_name: Name of the parser to create
+            
+        Returns:
+            An instance of the requested parser or None if not found
+        """
+        parser_class = ParserRegistry.get_parser_class(parser_name)
+        if not parser_class:
+            return None
+        return parser_class()
+    
+    @classmethod
+    def parse_document(cls, 
+                      file_path: Union[str, Path], 
+                      parser_name: str, 
+                      ocr_method_name: str,
+                      output_format: str = "markdown",
+                      cancellation_flag: Optional[threading.Event] = None,
+                      **kwargs) -> str:
+        """
+        Parse a document using the specified parser and OCR method.
+        
+        Args:
+            file_path: Path to the document
+            parser_name: Name of the parser to use
+            ocr_method_name: Display name of the OCR method to use
+            output_format: Output format (markdown, json, text, document_tags)
+            cancellation_flag: Optional flag to check for cancellation
+            **kwargs: Additional parser-specific options
+            
+        Returns:
+            str: The parsed content
+        """
+        # Helper function to check cancellation
+        def check_cancellation():
+            if cancellation_flag and cancellation_flag.is_set():
+                logging.info("Cancellation detected in parser_factory")
+                return True
+            return False
+            
+        # Check for cancellation immediately
+        if check_cancellation():
+            return "Conversion cancelled."
+            
+        parser = cls.create_parser(parser_name)
+        if not parser:
+            raise ValueError(f"Unknown parser: {parser_name}")
+        
+        # Get the internal OCR method ID
+        ocr_method_id = ParserRegistry.get_ocr_method_id(parser_name, ocr_method_name)
+        if not ocr_method_id:
+            raise ValueError(f"Unknown OCR method: {ocr_method_name} for parser {parser_name}")
+        
+        # Check for cancellation again before starting the parsing
+        if check_cancellation():
+            return "Conversion cancelled."
+        
+        # Add a function to check cancellation that parsers can call
+        def should_check_cancellation():
+            """Function that parsers can call to check if they should check cancellation"""
+            # No need to sleep here - this just returns whether cancellation should be checked
+            return True
+            
+        # Parse the document, passing the cancellation flag and helper functions
+        kwargs['cancellation_flag'] = cancellation_flag
+        kwargs['check_cancellation'] = check_cancellation
+        kwargs['should_check_cancellation'] = should_check_cancellation
+        kwargs['output_format'] = output_format
+        
+        # Parse the document
+        result = parser.parse(file_path, ocr_method=ocr_method_id, **kwargs)
+        
+        # Check one more time after parsing completes
+        if check_cancellation():
+            return "Conversion cancelled."
+            
+        return result 

src/main.py

@@ -0,0 +1,15 @@
+import parsers  # Import all parsers to ensure they're registered
+
+from src.ui.ui import launch_ui
+
+
+def main():
+    launch_ui(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False  # Explicitly disable sharing on Hugging Face
+    )
+
+
+if __name__ == "__main__":
+    main()

src/parsers/__init__.py

@@ -0,0 +1,12 @@
+"""Parser implementations for document conversion."""
+
+# Import all parsers to ensure they're registered
+from src.parsers.docling_parser import DoclingParser
+from src.parsers.marker_parser import MarkerParser
+from src.parsers.pypdfium_parser import PyPdfiumParser
+from src.parsers.gemini_flash_parser import GeminiFlashParser
+from src.parsers.got_ocr_parser import GotOcrParser
+
+# You can add new parsers here in the future 
+
+# This file makes the parsers directory a Python package 

src/parsers/docling_parser.py

@@ -0,0 +1,170 @@
+from pathlib import Path
+from typing import Dict, List, Optional, Any, Union
+import json
+import os
+import shutil
+
+from src.parsers.parser_interface import DocumentParser
+from src.parsers.parser_registry import ParserRegistry
+from docling.document_converter import DocumentConverter, PdfFormatOption
+from docling.datamodel.base_models import InputFormat
+from docling.datamodel.pipeline_options import (
+    AcceleratorDevice,
+    AcceleratorOptions,
+    PdfPipelineOptions,
+)
+from docling.models.tesseract_ocr_model import TesseractOcrOptions
+from docling.models.tesseract_ocr_cli_model import TesseractCliOcrOptions
+from docling.models.ocr_mac_model import OcrMacOptions
+
+
+class DoclingParser(DocumentParser):
+    """Parser implementation using Docling."""
+    
+    @classmethod
+    def get_name(cls) -> str:
+        return "Docling"
+    
+    @classmethod
+    def get_supported_ocr_methods(cls) -> List[Dict[str, Any]]:
+        return [
+            {
+                "id": "no_ocr",
+                "name": "No OCR",
+                "default_params": {}
+            },
+            {
+                "id": "easyocr",
+                "name": "EasyOCR",
+                "default_params": {"languages": ["en"]}
+            },
+            {
+                "id": "easyocr_cpu",
+                "name": "EasyOCR (CPU only)",
+                "default_params": {"languages": ["en"], "use_gpu": False}
+            },
+            {
+                "id": "tesseract",
+                "name": "Tesseract",
+                "default_params": {}
+            },
+            {
+                "id": "tesseract_cli",
+                "name": "Tesseract CLI",
+                "default_params": {}
+            },
+            {
+                "id": "ocrmac",
+                "name": "ocrmac",
+                "default_params": {}
+            },
+            {
+                "id": "full_force_ocr",
+                "name": "Full Force OCR",
+                "default_params": {}
+            }
+        ]
+    
+    def parse(self, file_path: Union[str, Path], ocr_method: Optional[str] = None, **kwargs) -> str:
+        """Parse a document using Docling."""
+        # Special case for full force OCR
+        if ocr_method == "full_force_ocr":
+            return self._apply_full_force_ocr(file_path)
+        
+        # Regular Docling parsing
+        pipeline_options = PdfPipelineOptions()
+        pipeline_options.do_table_structure = True
+        pipeline_options.table_structure_options.do_cell_matching = True
+        
+        # Configure OCR based on the method
+        if ocr_method == "no_ocr":
+            pipeline_options.do_ocr = False
+        elif ocr_method == "easyocr":
+            pipeline_options.do_ocr = True
+            pipeline_options.ocr_options.lang = kwargs.get("languages", ["en"])
+            pipeline_options.accelerator_options = AcceleratorOptions(
+                num_threads=4, device=AcceleratorDevice.AUTO
+            )
+        elif ocr_method == "easyocr_cpu":
+            pipeline_options.do_ocr = True
+            pipeline_options.ocr_options.lang = kwargs.get("languages", ["en"])
+            pipeline_options.ocr_options.use_gpu = False
+        elif ocr_method == "tesseract":
+            pipeline_options.do_ocr = True
+            pipeline_options.ocr_options = TesseractOcrOptions()
+        elif ocr_method == "tesseract_cli":
+            pipeline_options.do_ocr = True
+            pipeline_options.ocr_options = TesseractCliOcrOptions()
+        elif ocr_method == "ocrmac":
+            pipeline_options.do_ocr = True
+            pipeline_options.ocr_options = OcrMacOptions()
+        
+        # Create the converter
+        converter = DocumentConverter(
+            format_options={
+                InputFormat.PDF: PdfFormatOption(
+                    pipeline_options=pipeline_options
+                )
+            }
+        )
+        
+        # Convert the document
+        result = converter.convert(Path(file_path))
+        doc = result.document
+        
+        # Return the content in the requested format
+        output_format = kwargs.get("output_format", "markdown")
+        if output_format.lower() == "json":
+            return json.dumps(doc.export_to_dict(), ensure_ascii=False, indent=2)
+        elif output_format.lower() == "text":
+            return doc.export_to_text()
+        elif output_format.lower() == "document_tags":
+            return doc.export_to_document_tokens()
+        else:
+            return doc.export_to_markdown()
+    
+    def _apply_full_force_ocr(self, file_path: Union[str, Path]) -> str:
+        """Apply full force OCR to a document."""
+        input_doc = Path(file_path)
+        file_extension = input_doc.suffix.lower()
+        
+        # Debug information
+        print(f"Applying full force OCR to file: {input_doc} (type: {file_extension})")
+        
+        # Basic pipeline setup
+        pipeline_options = PdfPipelineOptions()
+        pipeline_options.do_ocr = True
+        pipeline_options.do_table_structure = True
+        pipeline_options.table_structure_options.do_cell_matching = True
+        
+        # Find tesseract executable
+        tesseract_path = shutil.which("tesseract") or "/usr/bin/tesseract"
+        print(f"Using tesseract at: {tesseract_path}")
+        
+        # Configure OCR options
+        ocr_options = TesseractCliOcrOptions(force_full_page_ocr=True)  # Using standard options instead of CLI
+        pipeline_options.ocr_options = ocr_options
+        
+        # Set up format options based on file type
+        format_options = {
+            InputFormat.PDF: PdfFormatOption(pipeline_options=pipeline_options)
+        }
+        
+        # Handle image files
+        if file_extension in ['.jpg', '.jpeg', '.png', '.tiff', '.tif', '.bmp']:
+            print(f"Processing as image file: {file_extension}")
+            format_options[InputFormat.IMAGE] = PdfFormatOption(pipeline_options=pipeline_options)
+        
+        # Try full force OCR with standard options
+        try:
+            converter = DocumentConverter(format_options=format_options)
+            result = converter.convert(input_doc)
+            return result.document.export_to_markdown()
+        except Exception as e:
+            print(f"Error with standard OCR: {e}")
+            print(f"Attempting fallback to tesseract_cli OCR...")
+            return self.parse(file_path, ocr_method="tesseract_cli")
+
+
+# Register the parser with the registry
+ParserRegistry.register(DoclingParser) 

src/parsers/gemini_flash_parser.py

@@ -0,0 +1,144 @@
+from pathlib import Path
+from typing import Dict, List, Optional, Any, Union
+import os
+import json
+import tempfile
+import base64
+from PIL import Image
+import io
+
+from src.parsers.parser_interface import DocumentParser
+from src.parsers.parser_registry import ParserRegistry
+
+# Import the Google Gemini API client
+try:
+    import google.generativeai as genai
+    GEMINI_AVAILABLE = True
+except ImportError:
+    GEMINI_AVAILABLE = False
+
+# Load API key from environment variable
+api_key = os.getenv("GOOGLE_API_KEY")
+
+# Check if API key is available and print a message if not
+if not api_key:
+    print("Warning: GOOGLE_API_KEY environment variable not found. Gemini Flash parser may not work.")
+
+class GeminiFlashParser(DocumentParser):
+    """Parser that uses Google's Gemini Flash 2.0 to convert documents to markdown."""
+
+    @classmethod
+    def get_name(cls) -> str:
+        return "Gemini Flash"
+
+    @classmethod
+    def get_supported_ocr_methods(cls) -> List[Dict[str, Any]]:
+        return [
+            {
+                "id": "none",
+                "name": "None",
+                "default_params": {}
+            }
+        ]
+    
+    @classmethod
+    def get_description(cls) -> str:
+        return "Gemini Flash 2.0 parser for converting documents and images to markdown"
+    
+    def parse(self, file_path: Union[str, Path], ocr_method: Optional[str] = None, **kwargs) -> str:
+        """Parse a document using Gemini Flash 2.0."""
+        if not GEMINI_AVAILABLE:
+            raise ImportError(
+                "The Google Gemini API client is not installed. "
+                "Please install it with 'pip install google-genai'."
+            )
+        
+        # Use the globally loaded API key
+        if not api_key:
+            raise ValueError(
+                "GOOGLE_API_KEY environment variable is not set. "
+                "Please set it to your Gemini API key."
+            )
+        
+        try:
+            # Configure the Gemini API with the API key
+            genai.configure(api_key=api_key)
+            
+            # Determine file type based on extension
+            file_path = Path(file_path)
+            file_extension = file_path.suffix.lower()
+            
+            # Read the file content
+            file_content = file_path.read_bytes()
+            
+            # Determine MIME type based on file extension
+            mime_type = self._get_mime_type(file_extension)
+            
+            # Create a multipart content with the file
+            model = genai.GenerativeModel('gemini-2.0-flash')
+            
+            # Set up the prompt
+            prompt = """
+            Convert this document to markdown format. 
+            Preserve the structure, headings, lists, tables, and formatting as much as possible.
+            For images, include a brief description in markdown image syntax.
+            """
+            
+            # Generate the response
+            response = model.generate_content(
+                contents=[
+                    prompt,
+                    {
+                        "mime_type": mime_type,
+                        "data": file_content
+                    }
+                ],
+                generation_config={
+                    "temperature": 0.2,
+                    "top_p": 0.95,
+                    "top_k": 40,
+                    "max_output_tokens": 8192,
+                }
+            )
+            
+            # Extract the markdown text from the response
+            markdown_text = response.text
+            
+            return markdown_text
+            
+        except Exception as e:
+            error_message = f"Error parsing document with Gemini Flash: {str(e)}"
+            print(error_message)
+            return f"# Error\n\n{error_message}\n\nPlease check your API key and try again."
+    
+    def _get_mime_type(self, file_extension: str) -> str:
+        """Get the MIME type for a file extension."""
+        mime_types = {
+            ".pdf": "application/pdf",
+            ".docx": "application/vnd.openxmlformats-officedocument.wordprocessingml.document",
+            ".doc": "application/msword",
+            ".pptx": "application/vnd.openxmlformats-officedocument.presentationml.presentation",
+            ".ppt": "application/vnd.ms-powerpoint",
+            ".xlsx": "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet",
+            ".xls": "application/vnd.ms-excel",
+            ".txt": "text/plain",
+            ".md": "text/markdown",
+            ".html": "text/html",
+            ".htm": "text/html",
+            ".jpg": "image/jpeg",
+            ".jpeg": "image/jpeg",
+            ".png": "image/png",
+            ".gif": "image/gif",
+            ".bmp": "image/bmp",
+            ".tiff": "image/tiff",
+            ".tif": "image/tiff",
+        }
+        
+        return mime_types.get(file_extension, "application/octet-stream")
+
+
+# Register the parser with the registry
+if GEMINI_AVAILABLE:
+    ParserRegistry.register(GeminiFlashParser)
+else:
+    print("Gemini Flash parser not registered: google-genai package not installed") 

src/parsers/got_ocr_parser.py

@@ -0,0 +1,172 @@
+from pathlib import Path
+from typing import Dict, List, Optional, Any, Union
+import json
+import os
+import tempfile
+import logging
+
+from src.parsers.parser_interface import DocumentParser
+from src.parsers.parser_registry import ParserRegistry
+
+# Configure logging
+logger = logging.getLogger(__name__)
+
+# Check if required packages are installed
+try:
+    import torch
+    import transformers
+    from transformers import AutoModel, AutoTokenizer
+    
+    # Check if transformers version is compatible
+    from packaging import version
+    if version.parse(transformers.__version__) >= version.parse("4.48.0"):
+        logger.warning(
+            f"Transformers version {transformers.__version__} may not be compatible with GOT-OCR. "
+            "Consider downgrading to version <4.48.0"
+        )
+    
+    GOT_AVAILABLE = True
+except ImportError:
+    GOT_AVAILABLE = False
+    logger.warning("GOT-OCR dependencies not installed. The parser will not be available.")
+
+class GotOcrParser(DocumentParser):
+    """Parser implementation using GOT-OCR 2.0."""
+    
+    _model = None
+    _tokenizer = None
+    
+    @classmethod
+    def get_name(cls) -> str:
+        return "GOT-OCR (jpg,png only)"
+    
+    @classmethod
+    def get_supported_ocr_methods(cls) -> List[Dict[str, Any]]:
+        return [
+            {
+                "id": "plain",
+                "name": "Plain Text",
+                "default_params": {}
+            },
+            {
+                "id": "format",
+                "name": "Formatted Text",
+                "default_params": {}
+            }
+        ]
+    
+    @classmethod
+    def _load_model(cls):
+        """Load the GOT-OCR model and tokenizer if not already loaded."""
+        if cls._model is None or cls._tokenizer is None:
+            try:
+                logger.info("Loading GOT-OCR model and tokenizer...")
+                cls._tokenizer = AutoTokenizer.from_pretrained(
+                    'stepfun-ai/GOT-OCR2_0', 
+                    trust_remote_code=True
+                )
+                cls._model = AutoModel.from_pretrained(
+                    'stepfun-ai/GOT-OCR2_0', 
+                    trust_remote_code=True, 
+                    low_cpu_mem_usage=True, 
+                    device_map='cuda', 
+                    use_safetensors=True,
+                    pad_token_id=cls._tokenizer.eos_token_id
+                )
+                cls._model = cls._model.eval().cuda()
+                logger.info("GOT-OCR model loaded successfully")
+            except Exception as e:
+                cls._model = None
+                cls._tokenizer = None
+                logger.error(f"Failed to load GOT-OCR model: {str(e)}")
+                raise RuntimeError(f"Failed to load GOT-OCR model: {str(e)}")
+    
+    @classmethod
+    def release_model(cls):
+        """Release the model from memory."""
+        if cls._model is not None:
+            del cls._model
+            cls._model = None
+        if cls._tokenizer is not None:
+            del cls._tokenizer
+            cls._tokenizer = None
+        if torch.cuda.is_available():
+            torch.cuda.empty_cache()
+        logger.info("GOT-OCR model released from memory")
+    
+    def parse(self, file_path: Union[str, Path], ocr_method: Optional[str] = None, **kwargs) -> str:
+        """Parse a document using GOT-OCR 2.0."""
+        if not GOT_AVAILABLE:
+            raise ImportError(
+                "GOT-OCR dependencies not installed. Please install required packages: "
+                "torch, transformers, tiktoken, verovio, accelerate"
+            )
+        
+        # Check if CUDA is available
+        if not torch.cuda.is_available():
+            raise RuntimeError("GOT-OCR requires CUDA. CPU-only mode is not supported.")
+        
+        # Check file extension
+        file_path = Path(file_path)
+        if file_path.suffix.lower() not in ['.jpg', '.jpeg', '.png']:
+            raise ValueError(
+                "GOT-OCR only supports JPG and PNG formats. "
+                f"Received file with extension: {file_path.suffix}"
+            )
+        
+        # Determine OCR type based on method
+        ocr_type = "format" if ocr_method == "format" else "ocr"
+        
+        try:
+            # Load the model
+            self._load_model()
+            
+            # Use the model's chat method as shown in the documentation
+            logger.info(f"Processing image with GOT-OCR: {file_path}")
+            result = self._model.chat(
+                self._tokenizer, 
+                str(file_path), 
+                ocr_type=ocr_type
+            )
+            
+            # Format the output based on the requested format
+            output_format = kwargs.get("output_format", "markdown").lower()
+            if output_format == "json":
+                return json.dumps({"content": result}, ensure_ascii=False, indent=2)
+            elif output_format == "text":
+                # Simple markdown to text conversion
+                return result.replace("#", "").replace("*", "").replace("_", "")
+            elif output_format == "document_tags":
+                return f"<doc>\n{result}\n</doc>"
+            else:
+                return result
+                
+        except torch.cuda.OutOfMemoryError:
+            self.release_model()  # Release memory
+            logger.error("GPU out of memory while processing with GOT-OCR")
+            raise RuntimeError(
+                "GPU out of memory while processing with GOT-OCR. "
+                "Try using a smaller image or a different parser."
+            )
+        except AttributeError as e:
+            if "get_max_length" in str(e):
+                logger.error(f"Transformers version compatibility error: {str(e)}")
+                self.release_model()  # Release memory
+                raise RuntimeError(
+                    "Transformers version compatibility error with GOT-OCR. "
+                    "Please downgrade transformers to version <4.48.0. "
+                    f"Error: {str(e)}"
+                )
+            else:
+                logger.error(f"Error processing document with GOT-OCR: {str(e)}")
+                raise RuntimeError(f"Error processing document with GOT-OCR: {str(e)}")
+        except Exception as e:
+            logger.error(f"Error processing document with GOT-OCR: {str(e)}")
+            raise RuntimeError(f"Error processing document with GOT-OCR: {str(e)}")
+
+# Register the parser with the registry if GOT is available
+if GOT_AVAILABLE:
+    ParserRegistry.register(GotOcrParser)
+    logger.info("GOT-OCR parser registered successfully")
+else:
+    logger.warning("GOT-OCR parser not registered: required dependencies not installed") 

src/parsers/marker_parser.py

@@ -0,0 +1,61 @@
+from pathlib import Path
+from typing import Dict, List, Optional, Any, Union
+import subprocess
+import tempfile
+import os
+import json
+
+from src.parsers.parser_interface import DocumentParser
+from src.parsers.parser_registry import ParserRegistry
+from marker.converters.pdf import PdfConverter
+from marker.models import create_model_dict
+from marker.output import text_from_rendered
+
+
+class MarkerParser(DocumentParser):
+    """Parser implementation using Marker."""
+    
+    @classmethod
+    def get_name(cls) -> str:
+        return "Marker"
+    
+    @classmethod
+    def get_supported_ocr_methods(cls) -> List[Dict[str, Any]]:
+        return [
+            {
+                "id": "no_ocr",
+                "name": "No OCR",
+                "default_params": {}
+            },
+            {
+                "id": "force_ocr",
+                "name": "Force OCR",
+                "default_params": {}
+            }
+        ]
+    
+    def parse(self, file_path: Union[str, Path], ocr_method: Optional[str] = None, **kwargs) -> str:
+        """Parse a document using Marker."""
+        force_ocr = ocr_method == "force_ocr"
+        
+        converter = PdfConverter(
+            artifact_dict=create_model_dict(),
+            config={"force_ocr": force_ocr}
+        )
+        rendered = converter(str(file_path))
+        content, _, _ = text_from_rendered(rendered)
+        
+        # Format the content based on the requested output format
+        output_format = kwargs.get("output_format", "markdown")
+        if output_format.lower() == "json":
+            return json.dumps({"content": content}, ensure_ascii=False, indent=2)
+        elif output_format.lower() == "text":
+            return content.replace("#", "").replace("*", "").replace("_", "")
+        elif output_format.lower() == "document_tags":
+            return f"<doc>\n{content}\n</doc>"
+        else:
+            return content
+
+
+# Register the parser with the registry
+ParserRegistry.register(MarkerParser) 

src/parsers/parser_interface.py

@@ -0,0 +1,47 @@
+from abc import ABC, abstractmethod
+from pathlib import Path
+from typing import Dict, List, Optional, Any, Union
+
+
+class DocumentParser(ABC):
+    """Base interface for all document parsers in the system."""
+    
+    @abstractmethod
+    def parse(self, file_path: Union[str, Path], ocr_method: Optional[str] = None, **kwargs) -> str:
+        """
+        Parse a document and return its content.
+        
+        Args:
+            file_path: Path to the document
+            ocr_method: OCR method to use (if applicable)
+            **kwargs: Additional parser-specific options
+            
+        Returns:
+            str: The parsed content
+        """
+        pass
+    
+    @classmethod
+    @abstractmethod
+    def get_name(cls) -> str:
+        """Return the display name of this parser"""
+        pass
+    
+    @classmethod
+    @abstractmethod
+    def get_supported_ocr_methods(cls) -> List[Dict[str, Any]]:
+        """
+        Return a list of supported OCR methods.
+        
+        Returns:
+            List of dictionaries with keys:
+                - id: Unique identifier for the OCR method
+                - name: Display name for the OCR method
+                - default_params: Default parameters for this OCR method
+        """
+        pass
+    
+    @classmethod
+    def get_description(cls) -> str:
+        """Return a description of this parser"""
+        return f"{cls.get_name()} document parser" 

src/parsers/parser_registry.py

@@ -0,0 +1,74 @@
+from typing import Dict, List, Type, Any, Optional
+from src.parsers.parser_interface import DocumentParser
+
+
+class ParserRegistry:
+    """Central registry for all document parsers in the system."""
+    
+    _parsers: Dict[str, Type[DocumentParser]] = {}
+    
+    @classmethod
+    def register(cls, parser_class: Type[DocumentParser]) -> None:
+        """
+        Register a parser with the system.
+        
+        Args:
+            parser_class: The parser class to register
+        """
+        parser_name = parser_class.get_name()
+        cls._parsers[parser_name] = parser_class
+        print(f"Registered parser: {parser_name}")
+    
+    @classmethod
+    def get_available_parsers(cls) -> Dict[str, Type[DocumentParser]]:
+        """Return all registered parsers"""
+        return cls._parsers
+    
+    @classmethod
+    def get_parser_class(cls, name: str) -> Optional[Type[DocumentParser]]:
+        """Get a specific parser class by name"""
+        return cls._parsers.get(name)
+    
+    @classmethod
+    def get_parser_names(cls) -> List[str]:
+        """Get a list of all registered parser names"""
+        return list(cls._parsers.keys())
+    
+    @classmethod
+    def get_ocr_options(cls, parser_name: str) -> List[str]:
+        """
+        Get OCR methods supported by a parser.
+        
+        Args:
+            parser_name: Name of the parser
+            
+        Returns:
+            List of OCR method display names
+        """
+        parser_class = cls.get_parser_class(parser_name)
+        if not parser_class:
+            return []
+        
+        return [method["name"] for method in parser_class.get_supported_ocr_methods()]
+    
+    @classmethod
+    def get_ocr_method_id(cls, parser_name: str, ocr_display_name: str) -> Optional[str]:
+        """
+        Get the internal ID for an OCR method based on its display name.
+        
+        Args:
+            parser_name: Name of the parser
+            ocr_display_name: Display name of the OCR method
+            
+        Returns:
+            Internal ID of the OCR method or None if not found
+        """
+        parser_class = cls.get_parser_class(parser_name)
+        if not parser_class:
+            return None
+        
+        for method in parser_class.get_supported_ocr_methods():
+            if method["name"] == ocr_display_name:
+                return method["id"]
+        
+        return None 

src/parsers/pypdfium_parser.py

@@ -0,0 +1,78 @@
+from pathlib import Path
+from typing import Dict, List, Optional, Any, Union
+import json
+import pypdfium2 as pdfium
+
+from src.parsers.parser_interface import DocumentParser
+from src.parsers.parser_registry import ParserRegistry
+from docling.document_converter import DocumentConverter, PdfFormatOption
+from docling.datamodel.base_models import InputFormat
+from docling.datamodel.pipeline_options import PdfPipelineOptions
+from docling.backend.pypdfium2_backend import PyPdfiumDocumentBackend
+
+
+class PyPdfiumParser(DocumentParser):
+    """Parser implementation using PyPdfium."""
+    
+    @classmethod
+    def get_name(cls) -> str:
+        return "PyPdfium"
+    
+    @classmethod
+    def get_supported_ocr_methods(cls) -> List[Dict[str, Any]]:
+        return [
+            {
+                "id": "no_ocr",
+                "name": "No OCR",
+                "default_params": {}
+            },
+            {
+                "id": "easyocr",
+                "name": "EasyOCR",
+                "default_params": {"languages": ["en"]}
+            }
+        ]
+    
+    def parse(self, file_path: Union[str, Path], ocr_method: Optional[str] = None, **kwargs) -> str:
+        """Parse a document using PyPdfium."""
+        pipeline_options = PdfPipelineOptions()
+        pipeline_options.do_table_structure = True
+        pipeline_options.table_structure_options.do_cell_matching = True
+        
+        # Configure OCR based on the method
+        if ocr_method == "easyocr":
+            pipeline_options.do_ocr = True
+            # Apply any custom parameters from kwargs
+            if "languages" in kwargs:
+                pipeline_options.ocr_options.lang = kwargs["languages"]
+        else:
+            pipeline_options.do_ocr = False
+        
+        # Create the converter
+        converter = DocumentConverter(
+            format_options={
+                InputFormat.PDF: PdfFormatOption(
+                    pipeline_options=pipeline_options,
+                    backend=PyPdfiumDocumentBackend
+                )
+            }
+        )
+        
+        # Convert the document
+        result = converter.convert(Path(file_path))
+        doc = result.document
+        
+        # Return the content in the requested format
+        output_format = kwargs.get("output_format", "markdown")
+        if output_format.lower() == "json":
+            return json.dumps(doc.export_to_dict(), ensure_ascii=False, indent=2)
+        elif output_format.lower() == "text":
+            return doc.export_to_text()
+        elif output_format.lower() == "document_tags":
+            return doc.export_to_document_tokens()
+        else:
+            return doc.export_to_markdown()
+
+
+# Register the parser with the registry
+ParserRegistry.register(PyPdfiumParser) 

src/services/__init__.py

@@ -0,0 +1 @@
+"""External services module for the application.""" 

src/services/docling_chat.py

@@ -0,0 +1,29 @@
+import openai
+import os
+
+# Load API key from environment variable
+openai.api_key = os.getenv("OPENAI_API_KEY")
+
+# Check if API key is available and print a message if not
+if not openai.api_key:
+    print("Warning: OPENAI_API_KEY environment variable not found. Chat functionality may not work.")
+
+def chat_with_document(message, history, document_text_state):
+    history = history or []
+    history.append({"role": "user", "content": message})
+
+    context = f"Document: {document_text_state}\n\nUser: {message}"
+
+    # Add error handling for API calls
+    try:
+        response = openai.chat.completions.create(
+            model="gpt-4o-2024-08-06",
+            messages=[{"role": "system", "content": context}] + history
+        )
+        reply = response.choices[0].message.content
+    except Exception as e:
+        reply = f"Error: Could not generate response. Please check your OpenAI API key. Details: {str(e)}"
+        print(f"OpenAI API error: {str(e)}")
+    
+    history.append({"role": "assistant", "content": reply})
+    return history, history

src/ui/__init__.py

@@ -0,0 +1 @@
+"""User interface module for the application.""" 

src/ui/ui.py

@@ -0,0 +1,301 @@
+import gradio as gr
+import markdown
+import threading
+import time
+import logging
+from pathlib import Path
+from src.core.converter import convert_file, set_cancellation_flag, is_conversion_in_progress
+from src.services.docling_chat import chat_with_document
+from src.parsers.parser_registry import ParserRegistry
+
+# Configure logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(name)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+# Add a global variable to track cancellation state
+conversion_cancelled = threading.Event()
+
+# Pass the cancellation flag to the converter module
+set_cancellation_flag(conversion_cancelled)
+
+# Add a background thread to monitor cancellation
+def monitor_cancellation():
+    """Background thread to monitor cancellation and update UI if needed"""
+    logger.info("Starting cancellation monitor thread")
+    while is_conversion_in_progress():
+        if conversion_cancelled.is_set():
+            logger.info("Cancellation detected by monitor thread")
+        time.sleep(0.1)  # Check every 100ms
+    logger.info("Cancellation monitor thread ending")
+
+def validate_file_for_parser(file_path, parser_name):
+    """Validate if the file type is supported by the selected parser."""
+    if not file_path:
+        return True, ""  # No file selected yet
+        
+    if "GOT-OCR" in parser_name:
+        file_ext = Path(file_path).suffix.lower()
+        if file_ext not in ['.jpg', '.jpeg', '.png']:
+            return False, "GOT-OCR only supports JPG and PNG formats."
+    return True, ""
+
+def format_markdown_content(content):
+    if not content:
+        return content
+    
+    # Convert the content to HTML using markdown library
+    html_content = markdown.markdown(str(content), extensions=['tables'])
+    return html_content
+
+# Function to run conversion in a separate thread
+def run_conversion_thread(file_path, parser_name, ocr_method_name, output_format):
+    """Run the conversion in a separate thread and return the thread object"""
+    global conversion_cancelled
+    
+    # Reset the cancellation flag
+    conversion_cancelled.clear()
+    
+    # Create a container for the results
+    results = {"content": None, "download_file": None, "error": None}
+    
+    def conversion_worker():
+        try:
+            content, download_file = convert_file(file_path, parser_name, ocr_method_name, output_format)
+            results["content"] = content
+            results["download_file"] = download_file
+        except Exception as e:
+            logger.error(f"Error during conversion: {str(e)}")
+            results["error"] = str(e)
+    
+    # Create and start the thread
+    thread = threading.Thread(target=conversion_worker)
+    thread.daemon = True
+    thread.start()
+    
+    return thread, results
+
+def handle_convert(file_path, parser_name, ocr_method_name, output_format, is_cancelled):
+    """Handle file conversion."""
+    global conversion_cancelled
+    
+    # Check if we should cancel before starting
+    if is_cancelled:
+        logger.info("Conversion cancelled before starting")
+        return "Conversion cancelled.", None, gr.update(visible=False), gr.update(visible=True), gr.update(visible=False), None
+    
+    # Validate file type for the selected parser
+    is_valid, error_msg = validate_file_for_parser(file_path, parser_name)
+    if not is_valid:
+        logger.error(f"File validation error: {error_msg}")
+        return f"Error: {error_msg}", None, gr.update(visible=False), gr.update(visible=True), gr.update(visible=False), None
+    
+    logger.info("Starting conversion with cancellation flag cleared")
+    
+    # Start the conversion in a separate thread
+    thread, results = run_conversion_thread(file_path, parser_name, ocr_method_name, output_format)
+    
+    # Start the monitoring thread
+    monitor_thread = threading.Thread(target=monitor_cancellation)
+    monitor_thread.daemon = True
+    monitor_thread.start()
+    
+    # Wait for the thread to complete or be cancelled
+    while thread.is_alive():
+        # Check if cancellation was requested
+        if conversion_cancelled.is_set():
+            logger.info("Cancellation detected, waiting for thread to finish")
+            # Give the thread a chance to clean up
+            thread.join(timeout=0.5)
+            if thread.is_alive():
+                logger.warning("Thread did not finish within timeout")
+            return "Conversion cancelled.", None, gr.update(visible=False), gr.update(visible=True), gr.update(visible=False), None
+        
+        # Sleep briefly to avoid busy waiting
+        time.sleep(0.1)
+    
+    # Thread has completed, check results
+    if results["error"]:
+        return f"Error: {results['error']}", None, gr.update(visible=False), gr.update(visible=True), gr.update(visible=False), None
+    
+    content = results["content"]
+    download_file = results["download_file"]
+    
+    # If conversion returned a cancellation message
+    if content == "Conversion cancelled.":
+        logger.info("Converter returned cancellation message")
+        return content, None, gr.update(visible=False), gr.update(visible=True), gr.update(visible=False), None
+    
+    # Format the content and wrap it in the scrollable container
+    formatted_content = format_markdown_content(str(content))
+    html_output = f"<div class='output-container'>{formatted_content}</div>"
+    
+    logger.info("Conversion completed successfully")
+    return html_output, download_file, gr.update(visible=False), gr.update(visible=True), gr.update(visible=False), None
+
+def create_ui():
+    with gr.Blocks(css="""
+        /* Simple output container with only one scrollbar */
+        .output-container {
+            max-height: 420px;  /* Changed from 600px to 70% of original height */
+            overflow-y: auto;
+            border: 1px solid #ddd;  /* Added border for better visual definition */
+            padding: 10px;  /* Added padding for better content spacing */
+        }
+        
+        /* Hide any scrollbars from parent containers */
+        .gradio-container .prose {
+            overflow: visible;
+        }
+        
+        .processing-controls { 
+            display: flex; 
+            justify-content: center; 
+            gap: 10px; 
+            margin-top: 10px; 
+        }
+        
+        /* Add margin above the provider/OCR options row */
+        .provider-options-row {
+            margin-top: 15px;
+            margin-bottom: 15px;
+        }
+    """) as demo:
+        gr.Markdown("Markit: Convert any documents to Markdown")
+        
+        # State to track if cancellation is requested
+        cancel_requested = gr.State(False)
+        # State to store the conversion thread
+        conversion_thread = gr.State(None)
+        # State to store the output format (fixed to Markdown)
+        output_format_state = gr.State("Markdown")
+
+        with gr.Tabs():
+            with gr.Tab("Upload and Convert"):
+                # File input first
+                file_input = gr.File(label="Upload PDF", type="filepath")
+                
+                # Provider and OCR options below the file input
+                with gr.Row(elem_classes=["provider-options-row"]):
+                    with gr.Column(scale=1):
+                        parser_names = ParserRegistry.get_parser_names()
+                        default_parser = parser_names[0] if parser_names else "PyPdfium"
+                        
+                        provider_dropdown = gr.Dropdown(
+                            label="Provider",
+                            choices=parser_names,
+                            value=default_parser,
+                            interactive=True
+                        )
+                    with gr.Column(scale=1):
+                        default_ocr_options = ParserRegistry.get_ocr_options(default_parser)
+                        default_ocr = default_ocr_options[0] if default_ocr_options else "No OCR"
+                        
+                        ocr_dropdown = gr.Dropdown(
+                            label="OCR Options",
+                            choices=default_ocr_options,
+                            value=default_ocr,
+                            interactive=True
+                        )
+                
+                # Simple output container with just one scrollbar
+                file_display = gr.HTML(
+                    value="<div class='output-container'></div>",
+                    label="Converted Content"
+                )
+                
+                file_download = gr.File(label="Download File")
+                
+                # Processing controls row
+                with gr.Row(elem_classes=["processing-controls"]):
+                    convert_button = gr.Button("Convert", variant="primary")
+                    cancel_button = gr.Button("Cancel", variant="stop", visible=False)
+
+            with gr.Tab("Chat with Document"):
+                document_text_state = gr.State("")
+                chatbot = gr.Chatbot(label="Chat", type="messages")
+                text_input = gr.Textbox(placeholder="Type here...")
+                clear_btn = gr.Button("Clear")
+
+        # Event handlers
+        provider_dropdown.change(
+            lambda p: gr.Dropdown(
+                choices=["Plain Text", "Formatted Text"] if "GOT-OCR" in p else ParserRegistry.get_ocr_options(p),
+                value="Plain Text" if "GOT-OCR" in p else (ParserRegistry.get_ocr_options(p)[0] if ParserRegistry.get_ocr_options(p) else None)
+            ),
+            inputs=[provider_dropdown],
+            outputs=[ocr_dropdown]
+        )
+
+        # Reset cancel flag when starting conversion
+        def start_conversion():
+            global conversion_cancelled
+            conversion_cancelled.clear()
+            logger.info("Starting conversion with cancellation flag cleared")
+            return gr.update(visible=False), gr.update(visible=True), False
+
+        # Set cancel flag and terminate thread when cancel button is clicked
+        def request_cancellation(thread):
+            global conversion_cancelled
+            conversion_cancelled.set()
+            logger.info("Cancel button clicked, cancellation flag set")
+            
+            # Try to join the thread with a timeout
+            if thread is not None:
+                logger.info(f"Attempting to join conversion thread: {thread}")
+                thread.join(timeout=0.5)
+                if thread.is_alive():
+                    logger.warning("Thread did not finish within timeout")
+            
+            # Add immediate feedback to the user
+            return gr.update(visible=True), gr.update(visible=False), True, None
+
+        # Start conversion sequence
+        convert_button.click(
+            fn=start_conversion,
+            inputs=[],
+            outputs=[convert_button, cancel_button, cancel_requested],
+            queue=False  # Execute immediately
+        ).then(
+            fn=handle_convert,
+            inputs=[file_input, provider_dropdown, ocr_dropdown, output_format_state, cancel_requested],
+            outputs=[file_display, file_download, convert_button, cancel_button, conversion_thread]
+        )
+        
+        # Handle cancel button click
+        cancel_button.click(
+            fn=request_cancellation,
+            inputs=[conversion_thread],
+            outputs=[convert_button, cancel_button, cancel_requested, conversion_thread],
+            queue=False  # Execute immediately
+        )
+
+        file_display.change(
+            lambda text: text,
+            inputs=[file_display],
+            outputs=[document_text_state]
+        )
+
+        text_input.submit(
+            fn=chat_with_document,
+            inputs=[text_input, chatbot, document_text_state],
+            outputs=[chatbot, chatbot]
+        )
+
+        clear_btn.click(
+            lambda: ([], []),
+            None,
+            [chatbot, chatbot]
+        )
+
+    return demo
+
+
+def launch_ui(server_name="0.0.0.0", server_port=7860, share=False):
+    demo = create_ui()
+    demo.launch(
+        server_name=server_name,
+        server_port=server_port,
+        root_path="",
+        show_error=True,
+        share=share
+    )