Extract Part Numbers from Engineering Drawings with PaddleOCR and spaCy

"""
Production implementation for extracting part numbers from engineering drawings.
Utilizes PaddleOCR for optical character recognition and spaCy for text processing.
"""

from typing import Dict, Any, List, Tuple
import os
import logging
import paddleocr
import spacy
from sqlalchemy import create_engine, text
from sqlalchemy.orm import sessionmaker
import time

# Configure logging
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)

# Configuration class
class Config:
    database_url: str = os.getenv('DATABASE_URL')
    ocr_model: str = os.getenv('OCR_MODEL', 'PaddleOCR')

# Initialize OCR model
ocr = paddleocr.OCR()  # Initialize PaddleOCR

# Database connection pooling
engine = create_engine(Config.database_url, pool_size=10, max_overflow=20)
Session = sessionmaker(bind=engine)

def validate_input(data: Dict[str, Any]) -> bool:
    """Validate request data.
    
    Args:
        data: Input to validate
    Returns:
        True if valid
    Raises:
        ValueError: If validation fails
    """
    if 'image_path' not in data:
        raise ValueError('Missing image_path')
    return True

def sanitize_fields(part_number: str) -> str:
    """Sanitize part number field.
    
    Args:
        part_number: Raw part number
    Returns:
        Cleaned part number
    """
    return part_number.strip().upper()  # Basic sanitization

def normalize_data(part_numbers: List[str]) -> List[str]:
    """Normalize list of part numbers.
    
    Args:
        part_numbers: List of raw part numbers
    Returns:
        Normalized part numbers
    """
    return [sanitize_fields(num) for num in part_numbers]  # Normalize data

def process_batch(image_path: str) -> List[str]:
    """Process a batch of images to extract part numbers.
    
    Args:
        image_path: Path to the image
    Returns:
        List of extracted part numbers
    """
    results = ocr.ocr(image_path)  # Perform OCR
    part_numbers = []
    for result in results:
        for item in result:
            part_numbers.append(item[1][0])  # Extract part numbers
    return normalize_data(part_numbers)  # Return normalized data

def fetch_data(image_path: str) -> None:
    """Fetch data from source image.
    
    Args:
        image_path: Path to the image
    """
    validate_input({'image_path': image_path})  # Validate input
    return process_batch(image_path)  # Process image

def save_to_db(part_numbers: List[str]) -> None:
    """Save extracted part numbers to the database.
    
    Args:
        part_numbers: List of part numbers to save
    """
    with Session() as session:
        for number in part_numbers:
            session.execute(text('INSERT INTO part_numbers (number) VALUES (:number)'), {'number': number})  # Insert part number
        session.commit()  # Commit changes

def call_api(data: Dict[str, Any]) -> None:
    """Call external API with the processed data.
    
    Args:
        data: Data to send to API
    """
    # Placeholder for API call
    logger.info('Calling external API with data: %s', data)

def handle_errors(error: Exception) -> None:
    """Handle errors gracefully.
    
    Args:
        error: Exception to handle
    """
    logger.error('An error occurred: %s', str(error))  # Log error

# Main orchestrator class
class PartNumberExtractor:
    def __init__(self, image_path: str):
        self.image_path = image_path  # Store image path
        self.part_numbers: List[str] = []  # Initialize part numbers list

    def extract(self) -> None:
        """Extract part numbers from image.
        """
        try:
            self.part_numbers = fetch_data(self.image_path)  # Fetch data
            save_to_db(self.part_numbers)  # Save to DB
            call_api({'part_numbers': self.part_numbers})  # Call API
        except ValueError as ve:
            handle_errors(ve)  # Handle value errors
        except Exception as e:
            handle_errors(e)  # Handle general errors

if __name__ == '__main__':
    # Example usage
    extractor = PartNumberExtractor(image_path='path/to/engineering_drawing.png')
    extractor.extract()  # Start extraction