natural-pdf 0.1.8__py3-none-any.whl → 0.1.10__py3-none-any.whl

natural_pdf/ocr/__init__.py

@@ -11,15 +11,15 @@ logger = logging.getLogger("natural_pdf.ocr")
 
 # Import the base classes that are always available
 from .engine import OCREngine
+from .ocr_factory import OCRFactory
+from .ocr_manager import OCRManager
 from .ocr_options import (
-    OCROptions,
     BaseOCROptions,
     EasyOCROptions,
+    OCROptions,
     PaddleOCROptions,
     SuryaOCROptions,
 )
-from .ocr_manager import OCRManager
-from .ocr_factory import OCRFactory
 
 # Add all public symbols that should be available when importing this module
 __all__ = [
@@ -41,7 +41,7 @@ def get_engine(engine_name=None, **kwargs):
     Get OCR engine by name with graceful handling of missing dependencies.
 
     Args:
-        engine_name: Name of the engine to use ('easyocr', 'paddle', 'surya')
+        engine_name: Name of the engine to use ('easyocr', 'paddle', 'surya', 'doctr')
                      If None, the best available engine is used
         **kwargs: Additional arguments to pass to the engine constructor
 
@@ -63,7 +63,7 @@ def get_engine(engine_name=None, **kwargs):
 
         # Use the factory to create a specific engine
         normalized_name = engine_name.lower()
-        if normalized_name in ["easyocr", "paddle", "surya"]:
+        if normalized_name in ["easyocr", "paddle", "surya", "doctr"]:
             return OCRFactory.create_engine(normalized_name, **kwargs)
         else:
             raise ValueError(f"Unknown OCR engine: {engine_name}")

natural_pdf/ocr/engine_doctr.py

@@ -0,0 +1,346 @@
+# natural_pdf/ocr/engine_doctr.py
+import importlib.util
+import logging
+from typing import Any, List, Optional
+
+import numpy as np
+from PIL import Image
+
+from .engine import OCREngine, TextRegion
+from .ocr_options import BaseOCROptions, DoctrOCROptions
+
+logger = logging.getLogger(__name__)
+
+
+class DoctrOCREngine(OCREngine):
+    """docTR engine implementation."""
+
+    def __init__(self):
+        super().__init__()
+        self._model = None  # Will hold the doctr ocr_predictor
+        self._detection_model = None  # Will hold detection_predictor if detect_only is used
+        self._orientation_model = None  # Will hold page_orientation_predictor if enabled
+
+    def is_available(self) -> bool:
+        """Check if doctr is installed."""
+        return importlib.util.find_spec("doctr") is not None
+
+    def _initialize_model(
+        self, languages: List[str], device: str, options: Optional[BaseOCROptions]
+    ):
+        """Initialize the doctr model."""
+        if not self.is_available():
+            raise ImportError(
+                "Doctr engine requires the 'python-doctr' package. "
+                "Install with: pip install python-doctr[torch] or python-doctr[tf]"
+            )
+
+        try:
+            import doctr.models
+
+            self.logger.info("doctr.models imported successfully.")
+        except ImportError as e:
+            self.logger.error(f"Failed to import doctr: {e}")
+            raise
+
+        # Cast to DoctrOCROptions or use default
+        doctr_opts = options if isinstance(options, DoctrOCROptions) else DoctrOCROptions()
+
+        # Check if CUDA is available in device string
+        use_cuda = device.lower().startswith("cuda") if device else False
+
+        # Prepare OCR predictor arguments
+        predictor_args = {
+            "det_arch": doctr_opts.det_arch,
+            "reco_arch": doctr_opts.reco_arch,
+            "pretrained": doctr_opts.pretrained,
+            "assume_straight_pages": doctr_opts.assume_straight_pages,
+            "export_as_straight_boxes": doctr_opts.export_as_straight_boxes,
+        }
+        # Filter out None values
+        predictor_args = {k: v for k, v in predictor_args.items() if v is not None}
+
+        self.logger.debug(f"doctr ocr_predictor constructor args: {predictor_args}")
+        try:
+            # Create the main OCR predictor (doesn't accept batch_size)
+            self._model = doctr.models.ocr_predictor(**predictor_args)
+
+            # Apply CUDA if available
+            if use_cuda:
+                self._model = self._model.cuda()
+
+            self.logger.info("doctr ocr_predictor created successfully")
+
+            # Now initialize the detection-only model
+            try:
+                detection_args = {
+                    "arch": doctr_opts.det_arch,
+                    "pretrained": doctr_opts.pretrained,
+                    "assume_straight_pages": doctr_opts.assume_straight_pages,
+                    "symmetric_pad": doctr_opts.symmetric_pad,
+                    "preserve_aspect_ratio": doctr_opts.preserve_aspect_ratio,
+                    "batch_size": doctr_opts.batch_size,
+                }
+                self._detection_model = doctr.models.detection_predictor(**detection_args)
+
+                # Apply CUDA if available
+                if use_cuda:
+                    self._detection_model = self._detection_model.cuda()
+
+                # Configure postprocessing parameters if provided
+                if doctr_opts.bin_thresh is not None:
+                    self._detection_model.model.postprocessor.bin_thresh = doctr_opts.bin_thresh
+                if doctr_opts.box_thresh is not None:
+                    self._detection_model.model.postprocessor.box_thresh = doctr_opts.box_thresh
+
+                self.logger.info("doctr detection_predictor created successfully")
+            except Exception as e:
+                self.logger.error(f"Failed to create detection_predictor: {e}")
+                self._detection_model = None
+
+            # Initialize orientation predictor if enabled
+            if doctr_opts.use_orientation_predictor:
+                try:
+                    self._orientation_model = doctr.models.page_orientation_predictor(
+                        pretrained=True, batch_size=doctr_opts.batch_size
+                    )
+                    if use_cuda:
+                        self._orientation_model = self._orientation_model.cuda()
+                    self.logger.info("doctr page_orientation_predictor created successfully")
+                except Exception as e:
+                    self.logger.error(f"Failed to create page_orientation_predictor: {e}")
+                    self._orientation_model = None
+
+        except Exception as e:
+            self.logger.error(f"Failed to create doctr models: {e}")
+            raise
+
+        # Doctr doesn't explicitly use language list in ocr_predictor initialization
+        if languages and languages != [self.DEFAULT_LANGUAGES[0]]:
+            logger.warning(
+                f"Doctr engine currently doesn't support language selection during initialization. Using its default language capabilities for model: {doctr_opts.reco_arch}"
+            )
+
+    def _preprocess_image(self, image: Image.Image) -> np.ndarray:
+        """Convert PIL Image to RGB numpy array for doctr."""
+        # Ensure the image is in RGB mode
+        if image.mode != "RGB":
+            image = image.convert("RGB")
+        # Convert to numpy array
+        return np.array(image)
+
+    def _process_single_image(
+        self, image: np.ndarray, detect_only: bool, options: Optional[DoctrOCROptions]
+    ) -> Any:
+        """Process a single image with doctr."""
+        if self._model is None:
+            raise RuntimeError("Doctr model not initialized")
+
+        # Capture image dimensions for denormalization
+        height, width = image.shape[:2]
+
+        # Cast options to DoctrOCROptions or use default
+        doctr_opts = options if isinstance(options, DoctrOCROptions) else DoctrOCROptions()
+
+        # Check if we need to detect orientation first
+        if self._orientation_model is not None and options and options.use_orientation_predictor:
+            try:
+                # Process with orientation predictor
+                # For orientation predictor, we need to pass a batch of images
+                orientations = self._orientation_model([image])
+                orientation = orientations[1][0]  # Get the orientation angle
+                logger.info(f"Detected page orientation: {orientation} degrees")
+                # Note: doctr handles rotation internally for detection/recognition
+            except Exception as e:
+                logger.error(f"Error detecting orientation: {e}")
+
+        # Process differently based on detect_only flag
+        if detect_only and self._detection_model is not None:
+            try:
+                # Apply threshold settings at runtime for this detection
+                if doctr_opts.bin_thresh is not None:
+                    original_bin_thresh = self._detection_model.model.postprocessor.bin_thresh
+                    self._detection_model.model.postprocessor.bin_thresh = doctr_opts.bin_thresh
+                    logger.debug(f"Temporarily set bin_thresh to {doctr_opts.bin_thresh}")
+
+                if doctr_opts.box_thresh is not None:
+                    original_box_thresh = self._detection_model.model.postprocessor.box_thresh
+                    self._detection_model.model.postprocessor.box_thresh = doctr_opts.box_thresh
+                    logger.debug(f"Temporarily set box_thresh to {doctr_opts.box_thresh}")
+
+                # Use the dedicated detection model with a list of numpy arrays
+                result = self._detection_model([image])
+
+                # Restore original thresholds
+                if doctr_opts.bin_thresh is not None:
+                    self._detection_model.model.postprocessor.bin_thresh = original_bin_thresh
+
+                if doctr_opts.box_thresh is not None:
+                    self._detection_model.model.postprocessor.box_thresh = original_box_thresh
+
+                # Return tuple of (result, dimensions)
+                return (result, (height, width))
+            except Exception as e:
+                logger.error(f"Error in detection_predictor: {e}")
+                # Fall back to OCR predictor if detection fails
+                logger.warning("Falling back to OCR predictor for detection")
+
+        # Process with full OCR model, passing a list of numpy arrays directly
+        try:
+            # For full OCR, we should also apply the thresholds
+            if (
+                detect_only
+                and doctr_opts.bin_thresh is not None
+                and hasattr(self._model.det_predictor.model.postprocessor, "bin_thresh")
+            ):
+                original_bin_thresh = self._model.det_predictor.model.postprocessor.bin_thresh
+                self._model.det_predictor.model.postprocessor.bin_thresh = doctr_opts.bin_thresh
+
+            if (
+                detect_only
+                and doctr_opts.box_thresh is not None
+                and hasattr(self._model.det_predictor.model.postprocessor, "box_thresh")
+            ):
+                original_box_thresh = self._model.det_predictor.model.postprocessor.box_thresh
+                self._model.det_predictor.model.postprocessor.box_thresh = doctr_opts.box_thresh
+
+            result = self._model([image])
+
+            # Restore original thresholds
+            if (
+                detect_only
+                and doctr_opts.bin_thresh is not None
+                and hasattr(self._model.det_predictor.model.postprocessor, "bin_thresh")
+            ):
+                self._model.det_predictor.model.postprocessor.bin_thresh = original_bin_thresh
+
+            if (
+                detect_only
+                and doctr_opts.box_thresh is not None
+                and hasattr(self._model.det_predictor.model.postprocessor, "box_thresh")
+            ):
+                self._model.det_predictor.model.postprocessor.box_thresh = original_box_thresh
+
+            # Return tuple of (result, dimensions)
+            return (result, (height, width))
+        except Exception as e:
+            logger.error(f"Error in OCR prediction: {e}")
+            raise
+
+    def _standardize_results(
+        self, raw_results: Any, min_confidence: float, detect_only: bool
+    ) -> List[TextRegion]:
+        """Convert doctr results to standardized TextRegion objects."""
+        standardized_regions = []
+
+        # Extract results and dimensions
+        if isinstance(raw_results, tuple) and len(raw_results) == 2:
+            results, dimensions = raw_results
+            image_height, image_width = dimensions
+        else:
+            # Fallback if dimensions aren't provided
+            results = raw_results
+            image_width = 1
+            image_height = 1
+            logger.warning("Image dimensions not provided, using normalized coordinates")
+
+        # Handle detection-only results differently
+        if detect_only and self._detection_model is not None and not hasattr(results, "pages"):
+            # Import doctr utils for detach_scores if needed
+            try:
+                from doctr.utils.geometry import detach_scores
+            except ImportError:
+                logger.error("Failed to import doctr.utils.geometry.detach_scores")
+                return standardized_regions
+
+            # Extract coordinates and scores from detection results
+            for result in results:
+                # Detection results structure is different from ocr_predictor
+                if "words" in result:
+                    try:
+                        # Detach the coordinates and scores
+                        detached_coords, prob_scores = detach_scores([result.get("words")])
+
+                        for i, coords in enumerate(detached_coords[0]):
+                            score = (
+                                prob_scores[0][i]
+                                if prob_scores and len(prob_scores[0]) > i
+                                else 0.0
+                            )
+
+                            if score >= min_confidence:
+                                try:
+                                    # Handle both straight and rotated boxes
+                                    if coords.shape == (
+                                        4,
+                                    ):  # Straight box as [xmin, ymin, xmax, ymax]
+                                        xmin, ymin, xmax, ymax = coords.tolist()
+                                        # Denormalize coordinates
+                                        bbox = (
+                                            float(xmin * image_width),
+                                            float(ymin * image_height),
+                                            float(xmax * image_width),
+                                            float(ymax * image_height),
+                                        )
+                                    else:  # Polygon points
+                                        # Get bounding box from polygon
+                                        coords_list = coords.tolist()
+                                        x_coords = [p[0] * image_width for p in coords_list]
+                                        y_coords = [p[1] * image_height for p in coords_list]
+                                        bbox = (
+                                            float(min(x_coords)),
+                                            float(min(y_coords)),
+                                            float(max(x_coords)),
+                                            float(max(y_coords)),
+                                        )
+
+                                    # In detection mode, we don't have text or confidence score
+                                    standardized_regions.append(TextRegion(bbox, None, score))
+                                except Exception as e:
+                                    logger.error(f"Error processing detection result: {e}")
+                    except Exception as e:
+                        logger.error(f"Error detaching scores: {e}")
+
+            return standardized_regions
+
+        # Process standard OCR results
+        if not hasattr(results, "pages") or not results.pages:
+            logger.warning("Doctr result object does not contain pages.")
+            return standardized_regions
+
+        # Process results page by page (we typically process one image at a time)
+        for page in results.pages:
+            # Extract information from blocks, lines, words
+            for block in page.blocks:
+                for line in block.lines:
+                    for word in line.words:
+                        if word.confidence >= min_confidence:
+                            try:
+                                # doctr geometry is ((x_min, y_min), (x_max, y_max)) as relative coordinates
+                                x_min, y_min = word.geometry[0]
+                                x_max, y_max = word.geometry[1]
+
+                                # Denormalize coordinates to absolute pixel values
+                                bbox = (
+                                    float(x_min * image_width),
+                                    float(y_min * image_height),
+                                    float(x_max * image_width),
+                                    float(y_max * image_height),
+                                )
+
+                                # Skip text content if detect_only is True
+                                text = None if detect_only else word.value
+                                confidence = None if detect_only else word.confidence
+
+                                standardized_regions.append(TextRegion(bbox, text, confidence))
+                            except (ValueError, TypeError, IndexError) as e:
+                                logger.error(
+                                    f"Could not standardize bounding box/word from doctr result: {word}"
+                                )
+                                logger.error(f"Error: {e}")
+
+        return standardized_regions
+
+    def get_default_options(self) -> DoctrOCROptions:
+        """Return the default options specific to this engine."""
+        return DoctrOCROptions()

natural_pdf/ocr/ocr_factory.py

@@ -1,6 +1,6 @@
-import logging
 import importlib.util
-from typing import Dict, Any, Optional, Type, Union, List
+import logging
+from typing import Any, Dict, List, Optional, Type, Union
 
 from .engine import OCREngine
 
@@ -15,7 +15,7 @@ class OCRFactory:
         """Create and return an OCR engine instance.
 
         Args:
-            engine_type: One of 'surya', 'easyocr', 'paddle'
+            engine_type: One of 'surya', 'easyocr', 'paddle', 'doctr'
             **kwargs: Arguments to pass to the engine constructor
 
         Returns:
@@ -54,6 +54,16 @@ class OCRFactory:
                     "PaddleOCR engine requires 'paddleocr' and 'paddlepaddle'. "
                     "Install with: pip install paddleocr paddlepaddle"
                 )
+        elif engine_type == "doctr":
+            try:
+                from .engine_doctr import DoctrOCREngine
+
+                return DoctrOCREngine(**kwargs)
+            except ImportError:
+                raise ImportError(
+                    "Doctr engine requires the 'python-doctr' package. "
+                    "Install with: pip install python-doctr[torch] or python-doctr[tf]"
+                )
         else:
             raise ValueError(f"Unknown engine type: {engine_type}")
 
@@ -85,13 +95,19 @@ class OCRFactory:
         except ImportError:
             engines["paddle"] = False
 
+        # Check Doctr
+        try:
+            engines["doctr"] = importlib.util.find_spec("doctr") is not None
+        except ImportError:
+            engines["doctr"] = False
+
         return engines
 
     @staticmethod
     def get_recommended_engine(**kwargs) -> OCREngine:
         """Returns the best available OCR engine based on what's installed.
 
-        First tries engines in order of preference: EasyOCR, Paddle, Surya.
+        First tries engines in order of preference: EasyOCR, Doctr, Paddle, Surya.
         If none are available, raises ImportError with installation instructions.
 
         Args:
@@ -109,6 +125,9 @@ class OCRFactory:
         if available.get("easyocr", False):
             logger.info("Using EasyOCR engine (recommended)")
             return OCRFactory.create_engine("easyocr", **kwargs)
+        elif available.get("doctr", False):
+            logger.info("Using Doctr engine")
+            return OCRFactory.create_engine("doctr", **kwargs)
         elif available.get("paddle", False):
             logger.info("Using PaddleOCR engine")
             return OCRFactory.create_engine("paddle", **kwargs)
@@ -120,6 +139,7 @@ class OCRFactory:
         raise ImportError(
             "No OCR engines available. Please install at least one of: \n"
             "- EasyOCR (recommended): pip install easyocr\n"
+            "- Doctr: pip install python-doctr[torch] or python-doctr[tf]\n"
             "- PaddleOCR: pip install paddleocr paddlepaddle\n"
             "- Surya OCR: pip install surya"
         )

natural_pdf/ocr/ocr_manager.py

@@ -1,19 +1,26 @@
 # ocr_manager.py
 import copy  # For deep copying options
 import logging
+import threading  # Import threading for lock
+import time  # Import time for timing
 from typing import Any, Dict, List, Optional, Type, Union
-import threading # Import threading for lock
-import time # Import time for timing
 
 from PIL import Image
 
 # Import engine classes and options
 from .engine import OCREngine
+from .engine_doctr import DoctrOCREngine
 from .engine_easyocr import EasyOCREngine
 from .engine_paddle import PaddleOCREngine
 from .engine_surya import SuryaOCREngine
-from .ocr_options import OCROptions
-from .ocr_options import BaseOCROptions, EasyOCROptions, PaddleOCROptions, SuryaOCROptions
+from .ocr_options import (
+    BaseOCROptions,
+    DoctrOCROptions,
+    EasyOCROptions,
+    OCROptions,
+    PaddleOCROptions,
+    SuryaOCROptions,
+)
 
 logger = logging.getLogger(__name__)
 
@@ -25,15 +32,20 @@ class OCRManager:
     ENGINE_REGISTRY: Dict[str, Dict[str, Any]] = {
         "easyocr": {"class": EasyOCREngine, "options_class": EasyOCROptions},
         "paddle": {"class": PaddleOCREngine, "options_class": PaddleOCROptions},
-        "surya": {"class": SuryaOCREngine, "options_class": SuryaOCROptions},  # <-- Add Surya
+        "surya": {"class": SuryaOCREngine, "options_class": SuryaOCROptions},
+        "doctr": {"class": DoctrOCREngine, "options_class": DoctrOCROptions},
         # Add other engines here
     }
 
     def __init__(self):
         """Initializes the OCR Manager."""
         self._engine_instances: Dict[str, OCREngine] = {}  # Cache for engine instances
-        self._engine_locks: Dict[str, threading.Lock] = {} # Lock per engine type for initialization
-        self._engine_inference_locks: Dict[str, threading.Lock] = {} # Lock per engine type for inference
+        self._engine_locks: Dict[str, threading.Lock] = (
+            {}
+        )  # Lock per engine type for initialization
+        self._engine_inference_locks: Dict[str, threading.Lock] = (
+            {}
+        )  # Lock per engine type for inference
         logger.info("OCRManager initialized.")
 
     def _get_engine_instance(self, engine_name: str) -> OCREngine:
@@ -51,7 +63,7 @@ class OCRManager:
         # Get or create the lock for this engine type
         if engine_name not in self._engine_locks:
             self._engine_locks[engine_name] = threading.Lock()
-        
+
         engine_init_lock = self._engine_locks[engine_name]
 
         # Acquire lock to safely check and potentially initialize the engine
@@ -61,9 +73,11 @@ class OCRManager:
                 return self._engine_instances[engine_name]
 
             # If still not initialized, create it now under the lock
-            logger.info(f"[{threading.current_thread().name}] Creating shared instance of engine: {engine_name}")
+            logger.info(
+                f"[{threading.current_thread().name}] Creating shared instance of engine: {engine_name}"
+            )
             engine_class = self.ENGINE_REGISTRY[engine_name]["class"]
-            start_time = time.monotonic() # Optional: time initialization
+            start_time = time.monotonic()  # Optional: time initialization
             try:
                 engine_instance = engine_class()  # Instantiate first
                 if not engine_instance.is_available():
@@ -75,14 +89,20 @@ class OCRManager:
                 # Store the shared instance
                 self._engine_instances[engine_name] = engine_instance
                 end_time = time.monotonic()
-                logger.info(f"[{threading.current_thread().name}] Shared instance of {engine_name} created successfully (Duration: {end_time - start_time:.2f}s).")
+                logger.info(
+                    f"[{threading.current_thread().name}] Shared instance of {engine_name} created successfully (Duration: {end_time - start_time:.2f}s)."
+                )
                 return engine_instance
             except Exception as e:
-                 # Ensure we don't leave a partial state if init fails
-                 logger.error(f"[{threading.current_thread().name}] Failed to create shared instance of {engine_name}: {e}", exc_info=True)
-                 # Remove potentially partial entry if exists
-                 if engine_name in self._engine_instances: del self._engine_instances[engine_name]
-                 raise # Re-raise the exception after logging
+                # Ensure we don't leave a partial state if init fails
+                logger.error(
+                    f"[{threading.current_thread().name}] Failed to create shared instance of {engine_name}: {e}",
+                    exc_info=True,
+                )
+                # Remove potentially partial entry if exists
+                if engine_name in self._engine_instances:
+                    del self._engine_instances[engine_name]
+                raise  # Re-raise the exception after logging
 
     def _get_engine_inference_lock(self, engine_name: str) -> threading.Lock:
         """Gets or creates the inference lock for a given engine type."""
@@ -112,7 +132,7 @@ class OCRManager:
 
         Args:
             images: A single PIL Image or a list of PIL Images to process.
-            engine: Name of the engine (e.g., 'easyocr', 'paddle', 'surya').
+            engine: Name of the engine (e.g., 'easyocr', 'paddle', 'surya', 'doctr').
                     Defaults to 'easyocr' if not specified.
             languages: List of language codes (e.g., ['en', 'fr'], ['en', 'german']).
                        **Passed directly to the engine.** Must be codes understood
@@ -169,27 +189,41 @@ class OCRManager:
             processing_mode = "batch" if is_batch else "single image"
             # Log thread name for clarity during parallel calls
             thread_id = threading.current_thread().name
-            logger.info(f"[{thread_id}] Processing {processing_mode} using shared engine instance '{selected_engine_name}'...")
+            logger.info(
+                f"[{thread_id}] Processing {processing_mode} using shared engine instance '{selected_engine_name}'..."
+            )
             logger.debug(
                 f"  Engine Args: languages={languages}, min_confidence={min_confidence}, device={device}, options={final_options}"
             )
 
             # Log image dimensions before processing
             if is_batch:
-                image_dims = [f"{img.width}x{img.height}" for img in images if hasattr(img, 'width') and hasattr(img, 'height')]
-                logger.debug(f"[{thread_id}] Processing batch of {len(images)} images with dimensions: {image_dims}")
-            elif hasattr(images, 'width') and hasattr(images, 'height'):
-                logger.debug(f"[{thread_id}] Processing single image with dimensions: {images.width}x{images.height}")
+                image_dims = [
+                    f"{img.width}x{img.height}"
+                    for img in images
+                    if hasattr(img, "width") and hasattr(img, "height")
+                ]
+                logger.debug(
+                    f"[{thread_id}] Processing batch of {len(images)} images with dimensions: {image_dims}"
+                )
+            elif hasattr(images, "width") and hasattr(images, "height"):
+                logger.debug(
+                    f"[{thread_id}] Processing single image with dimensions: {images.width}x{images.height}"
+                )
             else:
                 logger.warning(f"[{thread_id}] Could not determine dimensions of input image(s).")
 
             # Acquire lock specifically for the inference call
             inference_lock = self._get_engine_inference_lock(selected_engine_name)
-            logger.debug(f"[{thread_id}] Attempting to acquire inference lock for {selected_engine_name}...")
+            logger.debug(
+                f"[{thread_id}] Attempting to acquire inference lock for {selected_engine_name}..."
+            )
             inference_wait_start = time.monotonic()
             with inference_lock:
                 inference_acquired_time = time.monotonic()
-                logger.debug(f"[{thread_id}] Acquired inference lock for {selected_engine_name} (waited {inference_acquired_time - inference_wait_start:.2f}s). Calling process_image...")
+                logger.debug(
+                    f"[{thread_id}] Acquired inference lock for {selected_engine_name} (waited {inference_acquired_time - inference_wait_start:.2f}s). Calling process_image..."
+                )
                 inference_start_time = time.monotonic()
 
                 results = engine_instance.process_image(
@@ -201,7 +235,9 @@ class OCRManager:
                     options=final_options,
                 )
                 inference_end_time = time.monotonic()
-                logger.debug(f"[{thread_id}] process_image call finished for {selected_engine_name} (Duration: {inference_end_time - inference_start_time:.2f}s). Releasing lock.")
+                logger.debug(
+                    f"[{thread_id}] process_image call finished for {selected_engine_name} (Duration: {inference_end_time - inference_start_time:.2f}s). Releasing lock."
+                )
 
             # Log result summary based on mode
             if is_batch: