nv-ingest 2025.8.12.dev20250812__tar.gz → 2025.8.13.dev20250813__tar.gz

{nv_ingest-2025.8.12.dev20250812 → nv_ingest-2025.8.13.dev20250813}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nv-ingest
-Version: 2025.8.12.dev20250812
+Version: 2025.8.13.dev20250813
 Summary: Python module for multimodal document ingestion
 Author-email: Jeremy Dyer <jdyer@nvidia.com>
 License:                                  Apache License

{nv_ingest-2025.8.12.dev20250812 → nv_ingest-2025.8.13.dev20250813}/nv_ingest/framework/orchestration/ray/stages/meta/ray_actor_stage_base.py

@@ -9,6 +9,7 @@ from abc import ABC, abstractmethod
 from typing import Any, Dict, Optional
 import os
 import psutil
+import gc
 
 import ray
 import ray.actor
@@ -129,6 +130,13 @@ class RayActorStage(ABC):
 
         self._actor_id_str = self._get_actor_id_str()
 
+        # --- PyArrow memory cleanup configuration/state ---
+        # Allow stages to configure the cleanup interval (seconds) via their config.
+        # Defaults to 5 minutes if not provided.
+        self._memory_cleanup_interval_seconds: int = int(getattr(self.config, "memory_cleanup_interval_seconds", 300))
+        self._last_memory_cleanup_time: float = time.time()
+        self._memory_cleanups_performed: int = 0
+
     @staticmethod
     def _get_actor_id_str() -> str:
         """
@@ -344,6 +352,16 @@ class RayActorStage(ABC):
                     # This is the primary path for "successful processing".
                     self.stats["processed"] += 1
 
+                    # Time-based PyArrow memory cleanup check (best-effort, low overhead)
+                    try:
+                        current_time = time.time()
+                        if (current_time - self._last_memory_cleanup_time) >= self._memory_cleanup_interval_seconds:
+                            self._force_arrow_memory_cleanup()
+                            self._last_memory_cleanup_time = current_time
+                    except Exception:
+                        # Never allow cleanup issues to interfere with processing
+                        pass
+
                 except ray.exceptions.ObjectLostError:
                     # This error is handled inside the loop to prevent the actor from crashing.
                     # We log it and continue to the next message.
@@ -386,10 +404,71 @@ class RayActorStage(ABC):
             # This block executes when the processing thread is about to exit,
             # either due to self._running becoming False or an unhandled critical exception.
             self._logger.debug(f"[{self._actor_id_str}] Processing loop thread finished.")
+            # Perform a best-effort final memory cleanup on exit
+            try:
+                self._force_arrow_memory_cleanup()
+            except Exception:
+                pass
             # Signal that this actor's processing duties are complete.
             # External monitors (e.g., via a future from stop()) can use this signal.
             self._shutdown_signal_complete = True
 
+    def _force_arrow_memory_cleanup(self) -> None:
+        """
+        Best-effort memory cleanup for PyArrow allocations.
+
+        - Runs Python garbage collection to drop unreachable references.
+        - If PyArrow is available and its default memory pool supports
+          release_unused(), request it to return free pages to the OS.
+
+        Designed to be safe to call periodically; any failures are logged at
+        debug/warning levels and are non-fatal.
+        """
+        try:
+            # First, trigger Python GC to maximize reclaimable memory
+            gc.collect()
+
+            try:
+                import pyarrow as pa  # Local import to avoid hard dependency at import time
+
+                pool = pa.default_memory_pool()
+                try:
+                    before_bytes = getattr(pool, "bytes_allocated", lambda: 0)()
+                except Exception:
+                    before_bytes = 0
+
+                released = False
+                if hasattr(pool, "release_unused"):
+                    try:
+                        pool.release_unused()
+                        released = True
+                    except Exception as e_release:
+                        self._logger.debug(f"[{self._actor_id_str}] Arrow pool release_unused() failed: {e_release}")
+
+                try:
+                    after_bytes = getattr(pool, "bytes_allocated", lambda: before_bytes)()
+                except Exception:
+                    after_bytes = before_bytes
+
+                if released:
+                    delta_mb = max(0, (before_bytes - after_bytes) / (1024 * 1024))
+                    if delta_mb > 0:
+                        self._logger.debug(
+                            f"[{self._actor_id_str}] Arrow cleanup released ~{delta_mb:.2f}"
+                            f" MB (pool now {after_bytes/(1024*1024):.2f} MB)."
+                        )
+                self._memory_cleanups_performed += 1
+            except ModuleNotFoundError:
+                # PyArrow not present; nothing to do beyond GC.
+                self._memory_cleanups_performed += 1
+            except Exception as e_pa:
+                # Any other PyArrow-related issues are non-fatal.
+                self._logger.debug(f"[{self._actor_id_str}] Arrow cleanup skipped due to error: {e_pa}")
+                self._memory_cleanups_performed += 1
+        except Exception as e:
+            # As a last resort, swallow any errors to avoid interfering with the actor loop.
+            self._logger.debug(f"[{self._actor_id_str}] Memory cleanup encountered an error: {e}")
+
     def _get_memory_usage_mb(self) -> float:
         """
         Gets the total memory usage of the current actor process (RSS).

{nv_ingest-2025.8.12.dev20250812 → nv_ingest-2025.8.13.dev20250813}/nv_ingest.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: nv-ingest
-Version: 2025.8.12.dev20250812
+Version: 2025.8.13.dev20250813
 Summary: Python module for multimodal document ingestion
 Author-email: Jeremy Dyer <jdyer@nvidia.com>
 License:                                  Apache License