refactor: strip dead live-page tracking from managed PDFium backend

The Condition, Lock, _live_pages set, _closing flag, and owner back-ref
on pages were remnants of the Group-3b pipeline defensive shutdown that
was not included here. The pipeline always unloads page backends before
calling document.unload(), so _close_live_pages() was always a no-op
and notify_all() had zero waiters.

Reduced ManagedPdfiumDocumentBackend/ManagedPdfiumPageBackend to just
a _closed guard and the abstract _close_native_* dispatch.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: cau-git

docling/backend/docling_parse_backend.py

@@ -30,7 +30,6 @@ class DoclingParsePageBackend(ManagedPdfiumPageBackend):
     def __init__(
         self,
         *,
-        owner: "DoclingParseDocumentBackend",
         dp_doc: PdfDocument,
         page_obj: PdfPage,
         page_no: int,
@@ -40,7 +39,7 @@ def __init__(
         keep_lines: bool = False,
         keep_images: bool = True,
     ):
-        super().__init__(owner)
+        super().__init__()
         self._ppage = page_obj
         self._dp_doc: Optional[PdfDocument] = dp_doc
         self._page_no = page_no
@@ -260,7 +259,6 @@ def load_page(
             ppage = self._pdoc[page_no]
 
         return DoclingParsePageBackend(
-            owner=self,
             dp_doc=self.dp_doc,
             page_obj=ppage,
             page_no=page_no,

docling/backend/managed_pdfium_backend.py

@@ -1,6 +1,5 @@
 from __future__ import annotations
 
-import threading
 from abc import ABC, abstractmethod
 from io import BytesIO
 from pathlib import Path
@@ -23,64 +22,25 @@ def __init__(
         options: PdfBackendOptions = PdfBackendOptions(),
     ) -> None:
         super().__init__(in_doc, path_or_stream, options)
-        self._live_pages: set[ManagedPdfiumPageBackend] = set()
-        self._live_pages_lock = threading.Lock()
-        self._live_pages_cond = threading.Condition(self._live_pages_lock)
-        self._closing = False
         self._closed = False
 
-    def _register_live_page(self, page_backend: ManagedPdfiumPageBackend) -> None:
-        with self._live_pages_cond:
-            if self._closing or self._closed:
-                raise RuntimeError(
-                    "Cannot register a page while the document is closing."
-                )
-            self._live_pages.add(page_backend)
-
-    def _release_live_page(self, page_backend: ManagedPdfiumPageBackend) -> None:
-        with self._live_pages_cond:
-            self._live_pages.discard(page_backend)
-            self._live_pages_cond.notify_all()
-
-    def _close_live_pages(self) -> None:
-        while True:
-            with self._live_pages_cond:
-                live_pages = list(self._live_pages)
-            if not live_pages:
-                return
-            for page_backend in live_pages:
-                page_backend.unload()
-
     @abstractmethod
     def _close_native_document(self) -> None:
         pass
 
     def unload(self) -> None:
-        with self._live_pages_cond:
-            if self._closed:
-                return
-            self._closing = True
-
-        try:
-            self._close_live_pages()
-            self._close_native_document()
-        finally:
-            with self._live_pages_cond:
-                self._closed = True
-                self._closing = False
-                self._live_pages.clear()
-                self._live_pages_cond.notify_all()
-
+        if self._closed:
+            return
+        self._closed = True
+        self._close_native_document()
         super().unload()
 
 
 class ManagedPdfiumPageBackend(PdfPageBackend, ABC):
     """Shared page lifecycle for PDFium-backed page backends."""
 
-    def __init__(self, owner: ManagedPdfiumDocumentBackend) -> None:
-        self._owner: ManagedPdfiumDocumentBackend | None = owner
+    def __init__(self) -> None:
         self._closed = False
-        owner._register_live_page(self)
 
     @abstractmethod
     def _close_native_page(self) -> None:
@@ -89,12 +49,5 @@ def _close_native_page(self) -> None:
     def unload(self) -> None:
         if self._closed:
             return
-
-        owner = self._owner
-        try:
-            self._close_native_page()
-        finally:
-            self._closed = True
-            self._owner = None
-            if owner is not None:
-                owner._release_live_page(self)
+        self._closed = True
+        self._close_native_page()

docling/backend/pypdfium2_backend.py

@@ -111,12 +111,11 @@ def get_pdf_page_geometry(
 class PyPdfiumPageBackend(ManagedPdfiumPageBackend):
     def __init__(
         self,
-        owner: "PyPdfiumDocumentBackend",
         pdfium_doc: pdfium.PdfDocument,
         document_hash: str,
         page_no: int,
     ):
-        super().__init__(owner)
+        super().__init__()
         # Note: lock applied by the caller
         self.valid = True  # No better way to tell from pypdfium.
         self._ppage: pdfium.PdfPage | None = None
@@ -426,7 +425,7 @@ def page_count(self) -> int:
 
     def load_page(self, page_no: int) -> PyPdfiumPageBackend:
         with pypdfium2_lock:
-            return PyPdfiumPageBackend(self, self._pdoc, self.document_hash, page_no)
+            return PyPdfiumPageBackend(self._pdoc, self.document_hash, page_no)
 
     def is_valid(self) -> bool:
         return self.page_count() > 0