nv-ingest-client 2025.10.7.dev20251007__py3-none-any.whl → 2025.10.9.dev20251009__py3-none-any.whl

nv_ingest_client/client/ingest_job_handler.py

@@ -0,0 +1,384 @@
+# SPDX-FileCopyrightText: Copyright (c) 2024-25, NVIDIA CORPORATION & AFFILIATES.
+# All rights reserved.
+# SPDX-License-Identifier: Apache-2.0
+
+from __future__ import annotations
+
+import json
+import logging
+import time
+import os
+import io
+import base64
+from collections import defaultdict
+from typing import Any, Dict, List, Tuple
+
+from tqdm import tqdm
+
+# Reuse existing CLI utilities to avoid duplicating behavior
+from concurrent.futures import as_completed
+from nv_ingest_client.util.util import check_ingest_result
+from PIL import Image
+
+logger = logging.getLogger(__name__)
+
+
+class IngestJobHandler:
+    """
+    A modular job handler that mirrors the CLI's create_and_process_jobs flow,
+    so the same proven scheduling/retry behavior can be reused by other entry points.
+
+    Usage:
+        handler = IngestJobHandler(client, files, tasks, output_dir, batch_size)
+        total_files, trace_times, total_pages, trace_ids = handler.run()
+    """
+
+    def __init__(
+        self,
+        client: Any,
+        files: List[str],
+        tasks: Dict[str, Any],
+        output_directory: str,
+        batch_size: int,
+        fail_on_error: bool = False,
+        save_images_separately: bool = False,
+        show_progress: bool = True,
+        show_telemetry: bool = False,
+        job_queue_id: str = "ingest_task_queue",
+    ) -> None:
+        self.client = client
+        self.files = files
+        self.tasks = tasks
+        self.output_directory = output_directory
+        self.batch_size = batch_size
+        self.fail_on_error = fail_on_error
+        self.save_images_separately = save_images_separately
+        self.show_progress = show_progress
+        self.show_telemetry = show_telemetry
+        self.job_queue_id = job_queue_id
+        self._pbar = None
+        # Internal state used across iterations
+        self._retry_job_ids: List[str] = []
+        self._processed: int = 0
+        self._job_ids_batch: List[str] = []
+        self._job_id_map: Dict[str, str] = {}
+        self._trace_times: Dict[str, List[float]] = defaultdict(list)
+        # Constants
+        self._IMAGE_TYPES: set = {"png", "bmp", "jpeg", "jpg", "tiff"}
+
+    # ---------------------------
+    # Progress bar helpers
+    # ---------------------------
+    def _init_progress_bar(self, total: int) -> None:
+        if self.show_progress:
+            self._pbar = tqdm(total=total, desc="Processing files", unit="file")
+        else:
+            self._pbar = None
+
+    def _update_progress(self, n: int = 1, pages_per_sec: float | None = None) -> None:
+        if not self._pbar:
+            return
+        if pages_per_sec is not None:
+            self._pbar.set_postfix(pages_per_sec=f"{pages_per_sec:.2f}")
+        self._pbar.update(n)
+
+    def _close_progress_bar(self) -> None:
+        if self._pbar:
+            self._pbar.close()
+            self._pbar = None
+
+    def _generate_job_batch_for_iteration(self) -> None:
+        """
+        Build the next batch of jobs for processing and submit newly created jobs.
+
+        This method mirrors the CLI batching semantics: it prioritizes retry jobs,
+        then creates new jobs up to the given ``batch_size``, submits those new jobs
+        asynchronously to the configured queue, and returns the combined list of
+        job indices for this iteration. It also updates the internal progress bar
+        when configured and advances the processed-file counter.
+
+        Side Effects
+        ------------
+        - Populates/overwrites ``self._job_ids_batch`` with the ordered job indices to
+          process this iteration (``retry`` first, then newly created jobs).
+        - Updates ``self._job_id_map`` with any new mappings from job index to source file path
+          for jobs created in this iteration.
+
+        Raises
+        ------
+        RuntimeError
+            If one or more job specs cannot be created (e.g., unreadable files)
+            and ``self.fail_on_error`` is True.
+
+        Notes
+        -----
+        - Side effects:
+          - Creates JobSpecs via ``self.client.create_jobs_for_batch(...)``.
+          - Submits newly created jobs via ``self.client.submit_job_async(..., self.job_queue_id)``.
+          - Updates the class-owned progress bar (``self._pbar``) to account for
+            missing jobs when some files fail to produce specs and
+            ``self.fail_on_error`` is False.
+        - This method does not perform fetching; it only prepares and submits
+          jobs for the current iteration.
+        - The ``processed`` counter advances by the number of files attempted in
+          this iteration, even if some job specs are missing (unless
+          ``self.fail_on_error`` is True).
+
+        Examples
+        --------
+        >>> handler = IngestJobHandler(client, files, tasks, "/tmp/out", batch_size=32)
+        >>> retry_ids = []
+        >>> handler._generate_job_batch_for_iteration()
+        >>> len(handler._job_ids_batch) <= 32
+        True
+        """
+        job_indices: List[str] = []
+        job_index_map_updates: Dict[str, str] = {}
+        cur_job_count: int = 0
+
+        if self._retry_job_ids:
+            job_indices.extend(self._retry_job_ids)
+            cur_job_count = len(job_indices)
+
+        if (cur_job_count < self.batch_size) and (self._processed < len(self.files)):
+            new_job_count: int = min(self.batch_size - cur_job_count, len(self.files) - self._processed)
+            batch_files: List[str] = self.files[self._processed : self._processed + new_job_count]
+
+            new_job_indices: List[str] = self.client.create_jobs_for_batch(batch_files, self.tasks)
+            if len(new_job_indices) != new_job_count:
+                missing_jobs: int = new_job_count - len(new_job_indices)
+                error_msg: str = (
+                    f"Missing {missing_jobs} job specs -- this is likely due to bad reads or file corruption"
+                )
+                logger.warning(error_msg)
+
+                if self.fail_on_error:
+                    raise RuntimeError(error_msg)
+
+                if self._pbar:
+                    self._pbar.update(missing_jobs)
+
+            job_index_map_updates = {job_index: file for job_index, file in zip(new_job_indices, batch_files)}
+            self._processed += new_job_count
+            # Submit newly created jobs asynchronously to the configured queue
+            _ = self.client.submit_job_async(new_job_indices, self.job_queue_id)
+            job_indices.extend(new_job_indices)
+
+        # Save into class state
+        self._job_ids_batch = job_indices
+        # Merge new mappings (do not drop existing entries for retry jobs)
+        self._job_id_map.update(job_index_map_updates)
+
+    def _handle_future_result(self, future, timeout: int = 10):
+        """
+        Handle the result of a completed future job and process annotations.
+
+        Parameters
+        ----------
+        future : concurrent.futures.Future
+            Future representing an asynchronous job.
+        timeout : int, optional
+            Maximum seconds to wait for the future result.
+
+        Returns
+        -------
+        Tuple[Dict[str, Any], str]
+            The decoded result dictionary and the trace_id for the job.
+
+        Raises
+        ------
+        RuntimeError
+            If the job result indicates failure per check_ingest_result.
+        """
+        result, _, trace_id = future.result(timeout=timeout)[0]
+        if ("annotations" in result) and result["annotations"]:
+            annotations = result["annotations"]
+            for key, value in annotations.items():
+                logger.debug(f"Annotation: {key} -> {json.dumps(value, indent=2)}")
+
+        failed, description = check_ingest_result(result)
+        if failed:
+            raise RuntimeError(f"Ingest job failed: {description}")
+
+        return result, trace_id
+
+    def _process_response(self, response: Dict[str, Any]) -> None:
+        """
+        Extract trace timing entries from a response and accumulate per-stage elapsed times
+        into ``self._trace_times``.
+
+        Parameters
+        ----------
+        response : Dict[str, Any]
+            Full response payload containing an optional ``trace`` dictionary with
+            entry/exit timestamps.
+        """
+        trace_data: Dict[str, Any] = response.get("trace", {})
+        for key, entry_time in trace_data.items():
+            if "entry" in key:
+                exit_key: str = key.replace("entry", "exit")
+                exit_time: Any = trace_data.get(exit_key)
+                if exit_time:
+                    stage_parts = key.split("::")
+                    if len(stage_parts) >= 3:
+                        stage_name: str = stage_parts[2]
+                        elapsed_time: int = exit_time - entry_time
+                        self._trace_times[stage_name].append(elapsed_time)
+
+    def _save_response_data(
+        self, response: Dict[str, Any], output_directory: str, images_to_disk: bool = False
+    ) -> None:
+        """
+        Save the response data into categorized metadata JSON files and optionally save images to disk.
+
+        Parameters
+        ----------
+        response : Dict[str, Any]
+            Full response payload with a "data" list of documents.
+        output_directory : str
+            Output directory where per-type metadata JSON files (and any media) are written.
+        images_to_disk : bool, optional
+            If True, decode and write image contents to disk and replace content with a file URL.
+        """
+        if ("data" not in response) or (not response["data"]):
+            logger.debug("Data is not in the response or response.data is empty")
+            return
+
+        response_data = response["data"]
+        if not isinstance(response_data, list) or len(response_data) == 0:
+            logger.debug("Response data is not a list or the list is empty.")
+            return
+
+        doc_meta_base = response_data[0]["metadata"]
+        source_meta = doc_meta_base["source_metadata"]
+        doc_name = source_meta["source_id"]
+        clean_doc_name = os.path.basename(doc_name)
+        output_name = f"{clean_doc_name}.metadata.json"
+
+        # Organize by document type
+        doc_map: Dict[str, List[Dict[str, Any]]] = {}
+        for document in response_data:
+            meta: Dict[str, Any] = document.get("metadata", {})
+            content_meta: Dict[str, Any] = meta.get("content_metadata", {})
+            doc_type: str = content_meta.get("type", "unknown")
+            doc_map.setdefault(doc_type, []).append(document)
+
+        for doc_type, documents in doc_map.items():
+            doc_type_path = os.path.join(output_directory, doc_type)
+            os.makedirs(doc_type_path, exist_ok=True)
+
+            if doc_type in ("image", "structured") and images_to_disk:
+                for i, doc in enumerate(documents):
+                    meta: Dict[str, Any] = doc.get("metadata", {})
+                    image_content = meta.get("content")
+                    image_type = (
+                        meta.get("image_metadata", {}).get("image_type", "png").lower()
+                        if doc_type == "image"
+                        else "png"
+                    )
+
+                    if image_content and image_type in self._IMAGE_TYPES:
+                        try:
+                            image_data = base64.b64decode(image_content)
+                            image = Image.open(io.BytesIO(image_data))
+
+                            image_ext = "jpg" if image_type == "jpeg" else image_type
+                            image_filename = f"{clean_doc_name}_{i}.{image_ext}"
+                            image_output_path = os.path.join(doc_type_path, "media", image_filename)
+                            os.makedirs(os.path.dirname(image_output_path), exist_ok=True)
+                            image.save(image_output_path, format=image_ext.upper())
+
+                            meta["content"] = ""
+                            meta["content_url"] = os.path.realpath(image_output_path)
+                            logger.debug(f"Saved image to {image_output_path}")
+                        except Exception as e:
+                            logger.error(f"Failed to save image {i} for {clean_doc_name}: {e}")
+
+            # Write the metadata JSON file for this type
+            with open(os.path.join(doc_type_path, output_name), "w") as f:
+                f.write(json.dumps(documents, indent=2))
+
+    def run(self) -> Tuple[int, Dict[str, List[float]], int, Dict[str, str]]:
+        total_files: int = len(self.files)
+        total_pages_processed: int = 0
+        trace_ids: Dict[str, str] = defaultdict(list)  # type: ignore
+        failed_jobs: List[str] = []
+        retry_counts: Dict[str, int] = defaultdict(int)
+
+        start_time_ns: int = time.time_ns()
+        self._init_progress_bar(total_files)
+        try:
+            self._processed = 0
+            while (self._processed < len(self.files)) or self._retry_job_ids:
+                # Create a batch (retries first, then new jobs up to batch_size)
+                self._generate_job_batch_for_iteration()
+                job_id_map = self._job_id_map
+                self._retry_job_ids = []
+
+                futures_dict: Dict[Any, str] = self.client.fetch_job_result_async(self._job_ids_batch, data_only=False)
+                for future in as_completed(futures_dict.keys()):
+                    try:
+                        # Block as each future completes; this mirrors CLI behavior
+                        future_response, trace_id = self._handle_future_result(future)
+                        job_id: str = futures_dict[future]
+                        trace_ids[job_id_map[job_id]] = trace_id
+
+                        first_page_metadata = future_response["data"][0]["metadata"]
+                        file_page_counts: Dict[str, int] = {
+                            first_page_metadata["source_metadata"]["source_name"]: first_page_metadata[
+                                "content_metadata"
+                            ]["hierarchy"]["page_count"]
+                        }
+
+                        if self.output_directory:
+                            self._save_response_data(
+                                future_response,
+                                self.output_directory,
+                                images_to_disk=self.save_images_separately,
+                            )
+
+                        total_pages_processed += file_page_counts[list(file_page_counts.keys())[0]]
+                        elapsed_time: float = (time.time_ns() - start_time_ns) / 1e9
+                        if elapsed_time > 0:
+                            pages_per_sec: float = total_pages_processed / elapsed_time
+                        else:
+                            pages_per_sec = None
+
+                        self._process_response(future_response)
+
+                    except TimeoutError:
+                        job_id = futures_dict[future]
+                        src_name = job_id_map[job_id]
+                        retry_counts[src_name] += 1
+                        self._retry_job_ids.append(job_id)
+                    except json.JSONDecodeError as e:
+                        job_id = futures_dict[future]
+                        src_name = job_id_map[job_id]
+                        logger.error(f"Decoding error while processing {job_id}({src_name}): {e}")
+                        failed_jobs.append(f"{job_id}::{src_name}")
+                    except RuntimeError as e:
+                        job_id = futures_dict[future]
+                        src_name = job_id_map[job_id]
+                        logger.error(f"Error while processing '{job_id}' - ({src_name}):\n{e}")
+                        failed_jobs.append(f"{job_id}::{src_name}")
+                    except Exception as e:
+                        job_id = futures_dict[future]
+                        src_name = job_id_map[job_id]
+                        logger.exception(f"Unhandled error while processing {job_id}({src_name}): {e}")
+                        failed_jobs.append(f"{job_id}::{src_name}")
+                    finally:
+                        # Do not update the pbar if this job is going to be retried
+                        if futures_dict[future] not in self._retry_job_ids:
+                            self._update_progress(1, pages_per_sec)
+        finally:
+            self._close_progress_bar()
+
+        # Optionally print telemetry summary
+        if self.show_telemetry and hasattr(self.client, "summarize_telemetry"):
+            try:
+                summary = self.client.summarize_telemetry()
+                logger.info("NvIngestClient Telemetry Summary: %s", json.dumps(summary, indent=2))
+            except Exception:
+                pass
+
+        return total_files, self._trace_times, total_pages_processed, trace_ids

nv_ingest_client/client/interface.py

@@ -404,10 +404,11 @@ class Ingestor:
         save_to_disk: bool = False,
         **kwargs: Any,
     ) -> Union[
-        List[List[Dict[str, Any]]],  # In-memory: List of (response['data'] for each doc)
+        List[List[Dict[str, Any]]],  # In-memory: List of response['data'] for each doc
+        List[Dict[str, Any]],  # In-memory: Full response envelopes when return_full_response=True
         List[LazyLoadedList],  # Disk: List of proxies, one per original doc
         Tuple[
-            Union[List[List[Dict[str, Any]]], List[LazyLoadedList]],
+            Union[List[List[Dict[str, Any]]], List[Dict[str, Any]], List[LazyLoadedList]],
             List[Tuple[str, str]],
         ],
     ]:  # noqa: E501
@@ -423,13 +424,16 @@ class Ingestor:
         **kwargs : Any
             Additional keyword arguments for the underlying client methods. Supported keys:
             'concurrency_limit', 'timeout', 'max_job_retries', 'retry_delay',
-            'data_only', 'verbose'. Unrecognized keys are passed through to
-            process_jobs_concurrently.
+            'data_only', 'return_full_response', 'verbose'. Unrecognized keys are passed
+            through to process_jobs_concurrently.
 
         Returns
         -------
-        results : list of dict
-            List of successful job results when `return_failures` is False.
+        results : list
+            When `return_failures` is False:
+            - Default: List of response['data'] per job (list[list[dict]]).
+            - If `return_full_response=True`: List of full response envelopes (each dict
+              contains keys like 'data', 'trace', 'annotations').
         results, failures : tuple (list of dict, list of tuple of str)
             Tuple containing successful results and failure information when `return_failures` is True.
         """
@@ -549,6 +553,22 @@ class Ingestor:
 
         proc_kwargs = filter_function_kwargs(self._client.process_jobs_concurrently, **kwargs)
 
+        # Telemetry controls (optional)
+        enable_telemetry: Optional[bool] = kwargs.pop("enable_telemetry", None)
+        show_telemetry: Optional[bool] = kwargs.pop("show_telemetry", None)
+        if show_telemetry is None:
+            # Fallback to env NV_INGEST_CLIENT_SHOW_TELEMETRY (0/1), default off
+            try:
+                show_telemetry = bool(int(os.getenv("NV_INGEST_CLIENT_SHOW_TELEMETRY", "0")))
+            except ValueError:
+                show_telemetry = False
+        # If user explicitly wants to show telemetry but did not specify enable_telemetry,
+        # ensure collection is enabled so summary isn't empty.
+        if enable_telemetry is None and show_telemetry:
+            enable_telemetry = True
+        if enable_telemetry is not None and hasattr(self._client, "enable_telemetry"):
+            self._client.enable_telemetry(bool(enable_telemetry))
+
         results, failures = self._client.process_jobs_concurrently(
             job_indices=self._job_ids,
             job_queue_id=self._job_queue_id,
@@ -611,6 +631,16 @@ class Ingestor:
                     logger.info("Purging saved results from disk after successful VDB upload.")
                     self._purge_saved_results(results)
 
+        # Print telemetry summary if requested
+        if show_telemetry:
+            try:
+                summary = self._client.summarize_telemetry()
+                # Print to stdout and log for convenience
+                print("NvIngestClient Telemetry Summary:", json.dumps(summary, indent=2))
+                logger.info("NvIngestClient Telemetry Summary: %s", json.dumps(summary, indent=2))
+            except Exception:
+                pass
+
         return (results, failures) if return_failures else results
 
     def ingest_async(self, **kwargs: Any) -> Future:

nv_ingest_client/nv_ingest_cli.py

@@ -25,10 +25,10 @@ from nv_ingest_client.cli.util.click import click_match_and_validate_files
 from nv_ingest_client.cli.util.click import click_validate_batch_size
 from nv_ingest_client.cli.util.click import click_validate_file_exists
 from nv_ingest_client.cli.util.click import click_validate_task
-from nv_ingest_client.cli.util.processing import create_and_process_jobs
 from nv_ingest_client.cli.util.processing import report_statistics
 from nv_ingest_client.cli.util.system import configure_logging
 from nv_ingest_client.client import NvIngestClient
+from nv_ingest_client.client.ingest_job_handler import IngestJobHandler
 from nv_ingest_client.util.dataset import get_dataset_files
 from nv_ingest_client.util.dataset import get_dataset_statistics
 from nv_ingest_client.util.system import ensure_directory_with_permissions
@@ -290,15 +290,18 @@ def main(
             )
 
             start_time_ns = time.time_ns()
-            (total_files, trace_times, pages_processed, trace_ids) = create_and_process_jobs(
-                files=docs,
+            handler = IngestJobHandler(
                 client=ingest_client,
+                files=docs,
                 tasks=task,
                 output_directory=output_directory,
                 batch_size=batch_size,
                 fail_on_error=fail_on_error,
                 save_images_separately=save_images_separately,
+                show_progress=True,
+                show_telemetry=True,
             )
+            (total_files, trace_times, pages_processed, trace_ids) = handler.run()
 
             report_statistics(start_time_ns, trace_times, pages_processed, total_files)
 

nv_ingest_client/primitives/tasks/extract.py

@@ -86,7 +86,7 @@ class ExtractTask(Task):
         extract_page_as_image: bool = False,
         text_depth: str = "document",
         paddle_output_format: str = "pseudo_markdown",
-        table_output_format: str = "pseudo_markdown",
+        table_output_format: str = "markdown",
     ) -> None:
         """
         Setup Extract Task Config

{nv_ingest_client-2025.10.7.dev20251007.dist-info → nv_ingest_client-2025.10.9.dev20251009.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nv-ingest-client
-Version: 2025.10.7.dev20251007
+Version: 2025.10.9.dev20251009
 Summary: Python client for the nv-ingest service
 Author-email: Jeremy Dyer <jdyer@nvidia.com>
 License:                                  Apache License

{nv_ingest_client-2025.10.7.dev20251007.dist-info → nv_ingest_client-2025.10.9.dev20251009.dist-info}/RECORD

@@ -1,13 +1,14 @@
 nv_ingest_client/__init__.py,sha256=wQSlVx3T14ZgQAt-EPzEczQusXVW0W8yynnUaFFGE3s,143
-nv_ingest_client/nv_ingest_cli.py,sha256=GG7x_fe423NHQRDmpNcTtNI2P_g1xgg9SQ5JjbdBAIU,13592
+nv_ingest_client/nv_ingest_cli.py,sha256=8HpbU6l0i19M9kjZdZKbf03z-CZIZoikigZuo9wD77g,13693
 nv_ingest_client/cli/__init__.py,sha256=wQSlVx3T14ZgQAt-EPzEczQusXVW0W8yynnUaFFGE3s,143
 nv_ingest_client/cli/util/__init__.py,sha256=wQSlVx3T14ZgQAt-EPzEczQusXVW0W8yynnUaFFGE3s,143
 nv_ingest_client/cli/util/click.py,sha256=YjQU1uF148FU5D3ozC2m1kkfOOJxO1U8U552-T8PjU4,20029
-nv_ingest_client/cli/util/processing.py,sha256=7mXPjjNjLzWQY7WSxpm6et6ZEZOj0GYhLqvz-jx6MO4,24002
+nv_ingest_client/cli/util/processing.py,sha256=ULGCYQF1RTDQV_b35YM1WQRqIjR2wQRMJWu41DogagE,6259
 nv_ingest_client/cli/util/system.py,sha256=AQLq0DD2Ns8jRanrKu1tmVBKPA9rl-F3-ZsGI6FXLqE,1105
 nv_ingest_client/client/__init__.py,sha256=eEX9l1qmkLH2lAAZU3eP17SCV06ZjjrshHAB_xbboHA,375
-nv_ingest_client/client/client.py,sha256=wgPeLUByBNcQRkl1FXe7neHNNC5eY2sVve99g5sW41k,65068
-nv_ingest_client/client/interface.py,sha256=LeRtd92y0ab1K1f1nOB6_HpVWHJ_pPcIoLcQJGbjCSs,47218
+nv_ingest_client/client/client.py,sha256=egPegAoe8sVYxWWbNl1V5xJdaABJxgVxX7AHRoa049w,76058
+nv_ingest_client/client/ingest_job_handler.py,sha256=i2PC5AUaglN5aGAqE4Nrbk95TyLYN7P_Nwba0C_19xA,16810
+nv_ingest_client/client/interface.py,sha256=c1SRgS_ryz-DAYRPr8OIW0HpWzUx-GsnlfEK2_K7fZg,48897
 nv_ingest_client/client/util/processing.py,sha256=Ky7x7QbLn3BlgYwmrmoIc-o1VwmlmrcP9tn7GVTi0t0,2502
 nv_ingest_client/primitives/__init__.py,sha256=3rbpLCI7Bl0pntGatAxXD_V01y6dcLhHFheI3wqet-I,269
 nv_ingest_client/primitives/jobs/__init__.py,sha256=-yohgHv3LcCtSleHSaxjv1oO7nNcMCjN3ZYoOkIypIk,469
@@ -19,7 +20,7 @@ nv_ingest_client/primitives/tasks/caption.py,sha256=I1nOpfGb1Ts7QsElwfayhw-F_UcY
 nv_ingest_client/primitives/tasks/chart_extraction.py,sha256=s5hsljgSXxQMZHGekpAg6OYJ9k3-DHk5NmFpvtKJ6Zs,1493
 nv_ingest_client/primitives/tasks/dedup.py,sha256=qort6p3t6ZJuK_74sfOOLp3vMT3hkB5DAu3467WenyY,1719
 nv_ingest_client/primitives/tasks/embed.py,sha256=I6Irmvm1Qj9oqzDGSgfykCtfz8pz9LNxiXO-t29nXv8,5916
-nv_ingest_client/primitives/tasks/extract.py,sha256=yJEMGIiquhPlIofE6ERbM-U5tXk-GjZvvnnWOnU7YOA,9335
+nv_ingest_client/primitives/tasks/extract.py,sha256=bRriVkQyXN-UwzprHIt4Lp0iwmAojLEXqBb-IUrf3vY,9328
 nv_ingest_client/primitives/tasks/filter.py,sha256=wjcfSBGhdEyPh2tf42NMcyKZziigm24CO9B4obpQytU,2618
 nv_ingest_client/primitives/tasks/infographic_extraction.py,sha256=SyTjZQbdVA3QwM5yVm4fUzE4Gu4zm4tAfNLDZMvySV8,1537
 nv_ingest_client/primitives/tasks/split.py,sha256=8UkB3EialsOTEbsOZLxzmnDIfTJzC6uvjNv21IbgAVA,2332
@@ -46,9 +47,9 @@ nv_ingest_client/util/vdb/__init__.py,sha256=ZmoEzeM9LzwwrVvu_DVUnjRNx-x8ahkNeIr
 nv_ingest_client/util/vdb/adt_vdb.py,sha256=UubzAMSfyrqqpD-OQErpBs25hC2Mw8zGZ4waenGXPOk,515
 nv_ingest_client/util/vdb/milvus.py,sha256=dYXszrWdwYYASBW6t8lMI6QK9-BzhV6HAUYjt3cIDsE,78602
 nv_ingest_client/util/vdb/opensearch.py,sha256=I4FzF95VWCOkyzhfm-szdfK1Zd9ugUc8AxxpAdEMWGE,7538
-nv_ingest_client-2025.10.7.dev20251007.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
-nv_ingest_client-2025.10.7.dev20251007.dist-info/METADATA,sha256=405VU6NsNx7hRRd_QqvRZwNEuX1KtYg6nPFIPs9DL_Y,30626
-nv_ingest_client-2025.10.7.dev20251007.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
-nv_ingest_client-2025.10.7.dev20251007.dist-info/entry_points.txt,sha256=3uQVZkTZIjO08_bjTV-g0CDF5H1nrP1zWXU9gJOweuI,137
-nv_ingest_client-2025.10.7.dev20251007.dist-info/top_level.txt,sha256=1eMhBFD3SiWmpXnod2LM66C1HrSLSk96ninZi5XX-cE,17
-nv_ingest_client-2025.10.7.dev20251007.dist-info/RECORD,,
+nv_ingest_client-2025.10.9.dev20251009.dist-info/licenses/LICENSE,sha256=xx0jnfkXJvxRnG63LTGOxlggYnIysveWIZ6H3PNdCrQ,11357
+nv_ingest_client-2025.10.9.dev20251009.dist-info/METADATA,sha256=rscM-NBJXWXk1Ghg5KG0KTU56a4yWAV0c419opVrDS0,30626
+nv_ingest_client-2025.10.9.dev20251009.dist-info/WHEEL,sha256=_zCd3N1l69ArxyTb8rzEoP9TpbYXkqRFSNOD5OuxnTs,91
+nv_ingest_client-2025.10.9.dev20251009.dist-info/entry_points.txt,sha256=3uQVZkTZIjO08_bjTV-g0CDF5H1nrP1zWXU9gJOweuI,137
+nv_ingest_client-2025.10.9.dev20251009.dist-info/top_level.txt,sha256=1eMhBFD3SiWmpXnod2LM66C1HrSLSk96ninZi5XX-cE,17
+nv_ingest_client-2025.10.9.dev20251009.dist-info/RECORD,,