nv-ingest-api 2025.7.16.dev20250716__tar.gz → 2025.7.18.dev20250718__tar.gz

{nv_ingest_api-2025.7.16.dev20250716/src/nv_ingest_api.egg-info → nv_ingest_api-2025.7.18.dev20250718}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nv-ingest-api
-Version: 2025.7.16.dev20250716
+Version: 2025.7.18.dev20250718
 Summary: Python module with core document ingestion functions.
 Author-email: Jeremy Dyer <jdyer@nvidia.com>
 License:                                  Apache License

{nv_ingest_api-2025.7.16.dev20250716 → nv_ingest_api-2025.7.18.dev20250718}/src/nv_ingest_api/interface/extract.py

@@ -781,9 +781,9 @@ def extract_chart_data_from_image(
     *,
     df_ledger: pd.DataFrame,
     yolox_endpoints: Tuple[str, str],
-    paddle_endpoints: Tuple[str, str],
+    ocr_endpoints: Tuple[str, str],
     yolox_protocol: str = "grpc",
-    paddle_protocol: str = "grpc",
+    ocr_protocol: str = "grpc",
     auth_token: str = "",
 ) -> DataFrame:
     """
@@ -795,11 +795,11 @@ def extract_chart_data_from_image(
         DataFrame containing metadata required for chart extraction.
     yolox_endpoints : Tuple[str, str]
         YOLOX inference server endpoints.
-    paddle_endpoints : Tuple[str, str]
+    ocr_endpoints : Tuple[str, str]
         PaddleOCR inference server endpoints.
     yolox_protocol : str, optional
         Protocol for YOLOX inference (default "grpc").
-    paddle_protocol : str, optional
+    ocr_protocol : str, optional
         Protocol for PaddleOCR inference (default "grpc").
     auth_token : str, optional
         Authentication token for inference services.
@@ -821,9 +821,9 @@ def extract_chart_data_from_image(
         **{
             "endpoint_config": {
                 "yolox_endpoints": yolox_endpoints,
-                "paddle_endpoints": paddle_endpoints,
+                "ocr_endpoints": ocr_endpoints,
                 "yolox_infer_protocol": yolox_protocol,
-                "paddle_infer_protocol": paddle_protocol,
+                "ocr_infer_protocol": ocr_protocol,
                 "auth_token": auth_token,
             }
         }
@@ -844,9 +844,9 @@ def extract_table_data_from_image(
     *,
     df_ledger: pd.DataFrame,
     yolox_endpoints: Optional[Tuple[str, str]] = None,
-    paddle_endpoints: Optional[Tuple[str, str]] = None,
+    ocr_endpoints: Optional[Tuple[str, str]] = None,
     yolox_protocol: Optional[str] = None,
-    paddle_protocol: Optional[str] = None,
+    ocr_protocol: Optional[str] = None,
     auth_token: Optional[str] = None,
 ) -> pd.DataFrame:
     """
@@ -858,11 +858,11 @@ def extract_table_data_from_image(
         DataFrame containing metadata required for chart extraction.
     yolox_endpoints : Optional[Tuple[str, str]], default=None
         YOLOX inference server endpoints. If None, the default defined in ChartExtractorConfigSchema is used.
-    paddle_endpoints : Optional[Tuple[str, str]], default=None
+    ocr_endpoints : Optional[Tuple[str, str]], default=None
         PaddleOCR inference server endpoints. If None, the default defined in ChartExtractorConfigSchema is used.
     yolox_protocol : Optional[str], default=None
         Protocol for YOLOX inference. If None, the default defined in ChartExtractorConfigSchema is used.
-    paddle_protocol : Optional[str], default=None
+    ocr_protocol : Optional[str], default=None
         Protocol for PaddleOCR inference. If None, the default defined in ChartExtractorConfigSchema is used.
     auth_token : Optional[str], default=None
         Authentication token for inference services. If None, the default defined in ChartExtractorConfigSchema is used.
@@ -882,9 +882,9 @@ def extract_table_data_from_image(
     config_kwargs = {
         "endpoint_config": {
             "yolox_endpoints": yolox_endpoints,
-            "paddle_endpoints": paddle_endpoints,
+            "ocr_endpoints": ocr_endpoints,
             "yolox_infer_protocol": yolox_protocol,
-            "paddle_infer_protocol": paddle_protocol,
+            "ocr_infer_protocol": ocr_protocol,
             "auth_token": auth_token,
         }
     }
@@ -907,8 +907,8 @@ def extract_table_data_from_image(
 def extract_infographic_data_from_image(
     *,
     df_ledger: pd.DataFrame,
-    paddle_endpoints: Optional[Tuple[str, str]] = None,
-    paddle_protocol: Optional[str] = None,
+    ocr_endpoints: Optional[Tuple[str, str]] = None,
+    ocr_protocol: Optional[str] = None,
     auth_token: Optional[str] = None,
 ) -> pd.DataFrame:
     """
@@ -924,10 +924,10 @@ def extract_infographic_data_from_image(
     ----------
     df_extraction_ledger : pd.DataFrame
         DataFrame containing the images and associated metadata from which infographic data is to be extracted.
-    paddle_endpoints : Optional[Tuple[str, str]], default=None
+    ocr_endpoints : Optional[Tuple[str, str]], default=None
         A tuple of PaddleOCR endpoint addresses (e.g., (gRPC_endpoint, HTTP_endpoint)) used for inference.
         If None, the default endpoints from InfographicExtractorConfigSchema are used.
-    paddle_protocol : Optional[str], default=None
+    ocr_protocol : Optional[str], default=None
         The protocol (e.g., "grpc" or "http") for PaddleOCR inference.
         If None, the default protocol from InfographicExtractorConfigSchema is used.
     auth_token : Optional[str], default=None
@@ -951,8 +951,8 @@ def extract_infographic_data_from_image(
     extractor_config_kwargs = {
         "endpoint_config": InfographicExtractorConfigSchema(
             **{
-                "paddle_endpoints": paddle_endpoints,
-                "paddle_infer_protocol": paddle_protocol,
+                "ocr_endpoints": ocr_endpoints,
+                "ocr_infer_protocol": ocr_protocol,
                 "auth_token": auth_token,
             }
         )

{nv_ingest_api-2025.7.16.dev20250716 → nv_ingest_api-2025.7.18.dev20250718}/src/nv_ingest_api/internal/extract/image/chart_extractor.py

@@ -13,12 +13,12 @@ from typing import Tuple
 import numpy as np
 import pandas as pd
 
-from nv_ingest_api.internal.primitives.nim.model_interface.helpers import get_version
 from nv_ingest_api.internal.schemas.extract.extract_chart_schema import ChartExtractorSchema
 from nv_ingest_api.internal.schemas.meta.ingest_job_schema import IngestTaskChartExtraction
-from nv_ingest_api.util.image_processing.table_and_chart import join_yolox_graphic_elements_and_paddle_output
+from nv_ingest_api.util.image_processing.table_and_chart import join_yolox_graphic_elements_and_ocr_output
 from nv_ingest_api.util.image_processing.table_and_chart import process_yolox_graphic_elements
-from nv_ingest_api.internal.primitives.nim.model_interface.paddle import PaddleOCRModelInterface
+from nv_ingest_api.internal.primitives.nim.model_interface.ocr import OCRModelInterface
+from nv_ingest_api.internal.primitives.nim.model_interface.ocr import get_ocr_model_name
 from nv_ingest_api.internal.primitives.nim import NimClient
 from nv_ingest_api.internal.primitives.nim.model_interface.yolox import YoloxGraphicElementsModelInterface
 from nv_ingest_api.util.image_processing.transforms import base64_to_numpy
@@ -62,7 +62,8 @@ def _filter_valid_chart_images(
 
 def _run_chart_inference(
     yolox_client: Any,
-    paddle_client: Any,
+    ocr_client: Any,
+    ocr_model_name: str,
     valid_arrays: List[np.ndarray],
     valid_images: List[str],
     trace_info: Dict,
@@ -70,29 +71,43 @@ def _run_chart_inference(
     """
     Run concurrent inference for chart extraction using YOLOX and Paddle.
 
-    Returns a tuple of (yolox_results, paddle_results).
+    Returns a tuple of (yolox_results, ocr_results).
     """
     data_yolox = {"images": valid_arrays}
-    data_paddle = {"base64_images": valid_images}
-
-    with ThreadPoolExecutor(max_workers=2) as executor:
-        future_yolox = executor.submit(
-            yolox_client.infer,
-            data=data_yolox,
-            model_name="yolox",
-            stage_name="chart_extraction",
-            max_batch_size=8,
-            trace_info=trace_info,
-        )
-        future_paddle = executor.submit(
-            paddle_client.infer,
-            data=data_paddle,
+    data_ocr = {"base64_images": valid_images}
+
+    future_yolox_kwargs = dict(
+        data=data_yolox,
+        model_name="yolox_ensemble",
+        stage_name="chart_extraction",
+        input_names=["INPUT_IMAGES", "THRESHOLDS"],
+        dtypes=["BYTES", "FP32"],
+        output_names=["OUTPUT"],
+        trace_info=trace_info,
+        max_batch_size=8,
+    )
+    future_ocr_kwargs = dict(
+        data=data_ocr,
+        stage_name="chart_extraction",
+        max_batch_size=1 if ocr_client.protocol == "grpc" else 2,
+        trace_info=trace_info,
+    )
+    if ocr_model_name == "paddle":
+        future_ocr_kwargs.update(
             model_name="paddle",
-            stage_name="chart_extraction",
-            max_batch_size=1 if paddle_client.protocol == "grpc" else 2,
-            trace_info=trace_info,
+        )
+    else:
+        future_ocr_kwargs.update(
+            model_name="scene_text",
+            input_names=["input", "merge_levels"],
+            dtypes=["FP32", "BYTES"],
+            merge_level="paragraph",
         )
 
+    with ThreadPoolExecutor(max_workers=2) as executor:
+        future_yolox = executor.submit(yolox_client.infer, **future_yolox_kwargs)
+        future_ocr = executor.submit(ocr_client.infer, **future_ocr_kwargs)
+
         try:
             yolox_results = future_yolox.result()
         except Exception as e:
@@ -100,16 +115,16 @@ def _run_chart_inference(
             raise
 
         try:
-            paddle_results = future_paddle.result()
+            ocr_results = future_ocr.result()
         except Exception as e:
-            logger.error(f"Error calling paddle_client.infer: {e}", exc_info=True)
+            logger.error(f"Error calling ocr_client.infer: {e}", exc_info=True)
             raise
 
-    return yolox_results, paddle_results
+    return yolox_results, ocr_results
 
 
 def _validate_chart_inference_results(
-    yolox_results: Any, paddle_results: Any, valid_arrays: List[Any], valid_images: List[str]
+    yolox_results: Any, ocr_results: Any, valid_arrays: List[Any], valid_images: List[str]
 ) -> Tuple[List[Any], List[Any]]:
     """
     Ensure inference results are lists and have expected lengths.
@@ -117,21 +132,21 @@ def _validate_chart_inference_results(
     Raises:
       ValueError if results do not match expected types or lengths.
     """
-    if not (isinstance(yolox_results, list) and isinstance(paddle_results, list)):
-        raise ValueError("Expected list results from both yolox_client and paddle_client infer calls.")
+    if not (isinstance(yolox_results, list) and isinstance(ocr_results, list)):
+        raise ValueError("Expected list results from both yolox_client and ocr_client infer calls.")
 
     if len(yolox_results) != len(valid_arrays):
         raise ValueError(f"Expected {len(valid_arrays)} yolox results, got {len(yolox_results)}")
-    if len(paddle_results) != len(valid_images):
-        raise ValueError(f"Expected {len(valid_images)} paddle results, got {len(paddle_results)}")
-    return yolox_results, paddle_results
+    if len(ocr_results) != len(valid_images):
+        raise ValueError(f"Expected {len(valid_images)} ocr results, got {len(ocr_results)}")
+    return yolox_results, ocr_results
 
 
 def _merge_chart_results(
     base64_images: List[str],
     valid_indices: List[int],
     yolox_results: List[Any],
-    paddle_results: List[Any],
+    ocr_results: List[Any],
     initial_results: List[Tuple[str, Optional[Dict]]],
 ) -> List[Tuple[str, Optional[Dict]]]:
     """
@@ -140,10 +155,10 @@ def _merge_chart_results(
     For each valid image, processes the results from both inference calls and updates the
     corresponding entry in the results list.
     """
-    for idx, (yolox_res, paddle_res) in enumerate(zip(yolox_results, paddle_results)):
-        # Unpack paddle result into bounding boxes and text predictions.
-        bounding_boxes, text_predictions = paddle_res
-        yolox_elements = join_yolox_graphic_elements_and_paddle_output(yolox_res, bounding_boxes, text_predictions)
+    for idx, (yolox_res, ocr_res) in enumerate(zip(yolox_results, ocr_results)):
+        # Unpack ocr result into bounding boxes and text predictions.
+        bounding_boxes, text_predictions, _ = ocr_res
+        yolox_elements = join_yolox_graphic_elements_and_ocr_output(yolox_res, bounding_boxes, text_predictions)
         chart_content = process_yolox_graphic_elements(yolox_elements)
         original_index = valid_indices[idx]
         initial_results[original_index] = (base64_images[original_index], chart_content)
@@ -153,7 +168,8 @@ def _merge_chart_results(
 def _update_chart_metadata(
     base64_images: List[str],
     yolox_client: Any,
-    paddle_client: Any,
+    ocr_client: Any,
+    ocr_model_name: str,
     trace_info: Dict,
     worker_pool_size: int = 8,  # Not currently used.
 ) -> List[Tuple[str, Optional[Dict]]]:
@@ -172,51 +188,35 @@ def _update_chart_metadata(
     valid_images, valid_arrays, valid_indices, results = _filter_valid_chart_images(base64_images)
 
     # Run concurrent inference only for valid images.
-    yolox_results, paddle_results = _run_chart_inference(
+    yolox_results, ocr_results = _run_chart_inference(
         yolox_client=yolox_client,
-        paddle_client=paddle_client,
+        ocr_client=ocr_client,
+        ocr_model_name=ocr_model_name,
         valid_arrays=valid_arrays,
         valid_images=valid_images,
         trace_info=trace_info,
     )
 
     # Validate that the returned inference results are lists of the expected length.
-    yolox_results, paddle_results = _validate_chart_inference_results(
-        yolox_results, paddle_results, valid_arrays, valid_images
+    yolox_results, ocr_results = _validate_chart_inference_results(
+        yolox_results, ocr_results, valid_arrays, valid_images
     )
 
     # Merge the inference results into the results list.
-    return _merge_chart_results(base64_images, valid_indices, yolox_results, paddle_results, results)
+    return _merge_chart_results(base64_images, valid_indices, yolox_results, ocr_results, results)
 
 
 def _create_clients(
     yolox_endpoints: Tuple[str, str],
     yolox_protocol: str,
-    paddle_endpoints: Tuple[str, str],
-    paddle_protocol: str,
+    ocr_endpoints: Tuple[str, str],
+    ocr_protocol: str,
     auth_token: str,
 ) -> Tuple[NimClient, NimClient]:
-    # Obtain yolox_version
-    # Assuming that the grpc endpoint is at index 0
-    yolox_http_endpoint = yolox_endpoints[1]
-
-    try:
-        yolox_version = get_version(yolox_http_endpoint)
-        if not yolox_version:
-            logger.warning(
-                "Failed to obtain yolox-page-elements version from the endpoint. Falling back to the latest version."
-            )
-            yolox_version = None  # Default to the latest version
-    except Exception:
-        logger.warning(
-            "Failed to get yolox-page-elements version after 30 seconds. Falling back to the latest version."
-        )
-        yolox_version = None  # Default to the latest version
+    yolox_model_interface = YoloxGraphicElementsModelInterface()
+    ocr_model_interface = OCRModelInterface()
 
-    yolox_model_interface = YoloxGraphicElementsModelInterface(yolox_version=yolox_version)
-    paddle_model_interface = PaddleOCRModelInterface()
-
-    logger.debug(f"Inference protocols: yolox={yolox_protocol}, paddle={paddle_protocol}")
+    logger.debug(f"Inference protocols: yolox={yolox_protocol}, ocr={ocr_protocol}")
 
     yolox_client = create_inference_client(
         endpoints=yolox_endpoints,
@@ -225,14 +225,14 @@ def _create_clients(
         infer_protocol=yolox_protocol,
     )
 
-    paddle_client = create_inference_client(
-        endpoints=paddle_endpoints,
-        model_interface=paddle_model_interface,
+    ocr_client = create_inference_client(
+        endpoints=ocr_endpoints,
+        model_interface=ocr_model_interface,
         auth_token=auth_token,
-        infer_protocol=paddle_protocol,
+        infer_protocol=ocr_protocol,
     )
 
-    return yolox_client, paddle_client
+    return yolox_client, ocr_client
 
 
 def extract_chart_data_from_image_internal(
@@ -275,14 +275,18 @@ def extract_chart_data_from_image_internal(
         return df_extraction_ledger, execution_trace_log
 
     endpoint_config = extraction_config.endpoint_config
-    yolox_client, paddle_client = _create_clients(
+    yolox_client, ocr_client = _create_clients(
         endpoint_config.yolox_endpoints,
         endpoint_config.yolox_infer_protocol,
-        endpoint_config.paddle_endpoints,
-        endpoint_config.paddle_infer_protocol,
+        endpoint_config.ocr_endpoints,
+        endpoint_config.ocr_infer_protocol,
         endpoint_config.auth_token,
     )
 
+    # Get the grpc endpoint to determine the model if needed
+    ocr_grpc_endpoint = endpoint_config.ocr_endpoints[0]
+    ocr_model_name = get_ocr_model_name(ocr_grpc_endpoint)
+
     try:
         # 1) Identify rows that meet criteria in a single pass
         #    - metadata exists
@@ -323,7 +327,8 @@ def extract_chart_data_from_image_internal(
         bulk_results = _update_chart_metadata(
             base64_images=base64_images,
             yolox_client=yolox_client,
-            paddle_client=paddle_client,
+            ocr_client=ocr_client,
+            ocr_model_name=ocr_model_name,
             worker_pool_size=endpoint_config.workers_per_progress_engine,
             trace_info=execution_trace_log,
         )
@@ -344,8 +349,8 @@ def extract_chart_data_from_image_internal(
 
     finally:
         try:
-            if paddle_client is not None:
-                paddle_client.close()
+            if ocr_client is not None:
+                ocr_client.close()
             if yolox_client is not None:
                 yolox_client.close()
 

{nv_ingest_api-2025.7.16.dev20250716 → nv_ingest_api-2025.7.18.dev20250718}/src/nv_ingest_api/internal/extract/image/image_helpers/common.py

@@ -33,7 +33,6 @@ from PIL import Image
 from nv_ingest_api.internal.enums.common import AccessLevelEnum
 from nv_ingest_api.internal.primitives.nim.model_interface.yolox import (
     YoloxPageElementsModelInterface,
-    get_yolox_model_name,
 )
 from nv_ingest_api.internal.schemas.extract.extract_image_schema import ImageConfigSchema
 from nv_ingest_api.util.image_processing.transforms import crop_image, numpy_to_base64
@@ -202,11 +201,8 @@ def extract_page_elements_from_images(
 
     # Obtain yolox_version
     # Assuming that the http endpoint is at index 1
-    yolox_http_endpoint = config.yolox_endpoints[1]
-    yolox_model_name = get_yolox_model_name(yolox_http_endpoint)
-
     try:
-        model_interface = YoloxPageElementsModelInterface(yolox_model_name=yolox_model_name)
+        model_interface = YoloxPageElementsModelInterface()
         yolox_client = create_inference_client(
             config.yolox_endpoints,
             model_interface,
@@ -220,8 +216,11 @@ def extract_page_elements_from_images(
         # Perform inference in a single call. The NimClient handles batching internally.
         inference_results = yolox_client.infer(
             data,
-            model_name="yolox",
+            model_name="yolox_ensemble",
             max_batch_size=YOLOX_MAX_BATCH_SIZE,
+            input_names=["INPUT_IMAGES", "THRESHOLDS"],
+            dtypes=["BYTES", "FP32"],
+            output_names=["OUTPUT"],
             trace_info=trace_info,
             stage_name="pdf_extraction",
         )

{nv_ingest_api-2025.7.16.dev20250716 → nv_ingest_api-2025.7.18.dev20250718}/src/nv_ingest_api/internal/extract/image/infographic_extractor.py

@@ -12,12 +12,14 @@ from typing import Tuple
 import pandas as pd
 
 from nv_ingest_api.internal.primitives.nim import NimClient
-from nv_ingest_api.internal.primitives.nim.model_interface.paddle import PaddleOCRModelInterface
+from nv_ingest_api.internal.primitives.nim.model_interface.ocr import OCRModelInterface
+from nv_ingest_api.internal.primitives.nim.model_interface.ocr import get_ocr_model_name
 from nv_ingest_api.internal.schemas.extract.extract_infographic_schema import (
     InfographicExtractorSchema,
 )
 from nv_ingest_api.util.image_processing.transforms import base64_to_numpy
 from nv_ingest_api.util.nim import create_inference_client
+from nv_ingest_api.util.image_processing.table_and_chart import reorder_boxes
 
 logger = logging.getLogger(__name__)
 
@@ -61,22 +63,23 @@ def _filter_infographic_images(
 
 def _update_infographic_metadata(
     base64_images: List[str],
-    paddle_client: NimClient,
+    ocr_client: NimClient,
+    ocr_model_name: str,
     worker_pool_size: int = 8,  # Not currently used
     trace_info: Optional[Dict] = None,
 ) -> List[Tuple[str, Optional[Any], Optional[Any]]]:
     """
-    Filters base64-encoded images and uses PaddleOCR to extract infographic data.
+    Filters base64-encoded images and uses OCR to extract infographic data.
 
-    For each image that meets the minimum size, calls paddle_client.infer to obtain
+    For each image that meets the minimum size, calls ocr_client.infer to obtain
     (text_predictions, bounding_boxes). Invalid images are marked as skipped.
 
     Parameters
     ----------
     base64_images : List[str]
         List of base64-encoded images.
-    paddle_client : NimClient
-        Client instance for PaddleOCR inference.
+    ocr_client : NimClient
+        Client instance for OCR inference.
     worker_pool_size : int, optional
         Worker pool size (currently not used), by default 8.
     trace_info : Optional[Dict], optional
@@ -88,54 +91,70 @@ def _update_infographic_metadata(
         List of tuples in the same order as base64_images, where each tuple contains:
         (base64_image, text_predictions, bounding_boxes).
     """
-    logger.debug(f"Running infographic extraction using protocol {paddle_client.protocol}")
+    logger.debug(f"Running infographic extraction using protocol {ocr_client.protocol}")
 
     valid_images, valid_indices, results = _filter_infographic_images(base64_images)
-    data_paddle = {"base64_images": valid_images}
+    data_ocr = {"base64_images": valid_images}
 
     # worker_pool_size is not used in current implementation.
     _ = worker_pool_size
 
-    try:
-        paddle_results = paddle_client.infer(
-            data=data_paddle,
+    infer_kwargs = dict(
+        stage_name="infographic_extraction",
+        max_batch_size=1 if ocr_client.protocol == "grpc" else 2,
+        trace_info=trace_info,
+    )
+    if ocr_model_name == "paddle":
+        infer_kwargs.update(
             model_name="paddle",
-            stage_name="infographic_extraction",
-            max_batch_size=1 if paddle_client.protocol == "grpc" else 2,
-            trace_info=trace_info,
         )
+    else:
+        infer_kwargs.update(
+            model_name="scene_text",
+            input_names=["input", "merge_levels"],
+            dtypes=["FP32", "BYTES"],
+            merge_level="paragraph",
+        )
+    try:
+        ocr_results = ocr_client.infer(data_ocr, **infer_kwargs)
     except Exception as e:
-        logger.error(f"Error calling paddle_client.infer: {e}", exc_info=True)
+        logger.error(f"Error calling ocr_client.infer: {e}", exc_info=True)
         raise
 
-    if len(paddle_results) != len(valid_images):
-        raise ValueError(f"Expected {len(valid_images)} paddle results, got {len(paddle_results)}")
+    if len(ocr_results) != len(valid_images):
+        raise ValueError(f"Expected {len(valid_images)} ocr results, got {len(ocr_results)}")
 
-    for idx, paddle_res in enumerate(paddle_results):
+    for idx, ocr_res in enumerate(ocr_results):
         original_index = valid_indices[idx]
-        # Each paddle_res is expected to be a tuple (text_predictions, bounding_boxes)
-        results[original_index] = (base64_images[original_index], paddle_res[0], paddle_res[1])
+
+        if ocr_model_name == "paddle":
+            logger.debug(f"OCR results for image {base64_images[original_index]}: {ocr_res}")
+        else:
+            # Each ocr_res is expected to be a tuple (text_predictions, bounding_boxes, conf_scores).
+            ocr_res = reorder_boxes(*ocr_res)
+
+        results[original_index] = (base64_images[original_index], ocr_res[0], ocr_res[1])
 
     return results
 
 
 def _create_clients(
-    paddle_endpoints: Tuple[str, str],
-    paddle_protocol: str,
+    ocr_endpoints: Tuple[str, str],
+    ocr_protocol: str,
     auth_token: str,
 ) -> NimClient:
-    paddle_model_interface = PaddleOCRModelInterface()
+    ocr_model_interface = OCRModelInterface()
 
-    logger.debug(f"Inference protocols: paddle={paddle_protocol}")
+    logger.debug(f"Inference protocols: ocr={ocr_protocol}")
 
-    paddle_client = create_inference_client(
-        endpoints=paddle_endpoints,
-        model_interface=paddle_model_interface,
+    ocr_client = create_inference_client(
+        endpoints=ocr_endpoints,
+        model_interface=ocr_model_interface,
         auth_token=auth_token,
-        infer_protocol=paddle_protocol,
+        infer_protocol=ocr_protocol,
     )
 
-    return paddle_client
+    return ocr_client
 
 
 def _meets_infographic_criteria(row: pd.Series) -> bool:
@@ -209,12 +228,16 @@ def extract_infographic_data_from_image_internal(
         return df_extraction_ledger, execution_trace_log
 
     endpoint_config = extraction_config.endpoint_config
-    paddle_client = _create_clients(
-        endpoint_config.paddle_endpoints,
-        endpoint_config.paddle_infer_protocol,
+    ocr_client = _create_clients(
+        endpoint_config.ocr_endpoints,
+        endpoint_config.ocr_infer_protocol,
         endpoint_config.auth_token,
     )
 
+    # Get the grpc endpoint to determine the model if needed
+    ocr_grpc_endpoint = endpoint_config.ocr_endpoints[0]
+    ocr_model_name = get_ocr_model_name(ocr_grpc_endpoint)
+
     try:
         # Identify rows that meet the infographic criteria.
         mask = df_extraction_ledger.apply(_meets_infographic_criteria, axis=1)
@@ -230,14 +253,15 @@ def extract_infographic_data_from_image_internal(
         # Call bulk update to extract infographic data.
         bulk_results = _update_infographic_metadata(
             base64_images=base64_images,
-            paddle_client=paddle_client,
+            ocr_client=ocr_client,
+            ocr_model_name=ocr_model_name,
             worker_pool_size=endpoint_config.workers_per_progress_engine,
             trace_info=execution_trace_log,
         )
 
         # Write the extracted results back into the DataFrame.
         for result_idx, df_idx in enumerate(valid_indices):
-            # Unpack result: (base64_image, paddle_bounding_boxes, paddle_text_predictions)
+            # Unpack result: (base64_image, ocr_bounding_boxes, ocr_text_predictions)
             _, _, text_predictions = bulk_results[result_idx]
             table_content = " ".join(text_predictions) if text_predictions else None
             df_extraction_ledger.at[df_idx, "metadata"]["table_metadata"]["table_content"] = table_content
@@ -250,4 +274,4 @@ def extract_infographic_data_from_image_internal(
         raise
 
     finally:
-        paddle_client.close()
+        ocr_client.close()