multixtract 0.1.1__py3-none-any.whl

multixtract/extractors/pdf.py

@@ -0,0 +1,347 @@
+"""PDF extractor (PyMuPDF + pdfplumber).
+
+Extracts text and tables with pdfplumber and images with PyMuPDF, applying
+cross-page deduplication via xref tracking. This is the reference
+implementation of the :class:`~multixtract.interfaces.DocumentExtractor`
+protocol; behaviour is identical to the original ``extract_document``.
+
+Requires the ``[pdf]`` extra (PyMuPDF + pdfplumber). These are imported lazily
+inside :meth:`PdfExtractor.extract` so importing ``multixtract`` (and the
+registry) never pulls in the heavy PDF stack until a PDF is actually parsed.
+"""
+from __future__ import annotations
+
+import io
+import logging
+import os
+import re
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+from ..filters import ImageFilterPipeline
+from ._image_utils import (
+    VECTOR_EXTS,
+    WDP_EXTS,
+    batch_convert_vectors_to_png,
+    decode_wdp_to_png,
+    ensure_rgb_png,
+)
+
+log = logging.getLogger("multixtract.extractors.pdf")
+
+# PDF date tokens: "D:20231015120000+05'30'" or "D:20231015120000Z" etc.
+_PDF_DATE_RE = re.compile(
+    r"D:(\d{4})(\d{2})(\d{2})(\d{2})(\d{2})(\d{2})"
+)
+
+
+def _parse_pdf_date(value: Any) -> Optional[str]:
+    """Convert a raw PDF date string to ISO-8601 (best-effort). Returns None on failure."""
+    if not isinstance(value, str):
+        return None
+    date_match = _PDF_DATE_RE.search(value)
+    if not date_match:
+        return None
+    year, month, day, hour, minute, second = date_match.groups()
+    return f"{year}-{month}-{day}T{hour}:{minute}:{second}"
+
+
+def _normalize_pdf_metadata(
+    raw: Dict[str, Any],
+    page_count: int,
+    table_count: int,
+) -> Dict[str, Any]:
+    """Normalize raw pdfplumber metadata to the shared schema.
+
+    Maps common PDF info-dict keys (case-insensitively, with or without leading
+    slash) to canonical names, parses PDF date strings, and appends computed
+    aggregates so the shape matches the DOCX metadata dict.
+    """
+    def _get(*keys: str) -> Any:
+        for k in keys:
+            for candidate in (k, k.lstrip("/"), f"/{k}"):
+                if candidate in raw:
+                    return raw[candidate]
+                if candidate.lower() in {rk.lower(): rv for rk, rv in raw.items()}:
+                    for rk, rv in raw.items():
+                        if rk.lower() == candidate.lower():
+                            return rv
+        return None
+
+    return {
+        "author":        _get("Author", "/Author") or None,
+        "creator":       _get("Creator", "/Creator") or None,
+        "producer":      _get("Producer", "/Producer") or None,
+        "title":         _get("Title", "/Title") or None,
+        "subject":       _get("Subject", "/Subject") or None,
+        "keywords":      _get("Keywords", "/Keywords") or None,
+        "created":       _parse_pdf_date(_get("CreationDate", "/CreationDate")),
+        "modified":      _parse_pdf_date(_get("ModDate", "/ModDate")),
+        "page_count":    page_count,
+        "table_count":   table_count,
+        "raw":           raw,
+    }
+
+
+def _is_blank_table(rows: List[List[str]]) -> bool:
+    """Return True if every cell in the table is empty/whitespace/None."""
+    return all(not (cell or "").strip() for row in rows for cell in row)
+
+
+def _extract_page_elements(page: Any) -> List[Dict[str, Any]]:
+    """Return page content as an ordered elements list.
+
+    Uses pdfplumber ``find_tables()`` to locate table regions with bboxes, then
+    crops the page into strips to extract prose text. Uses column-aware cropping:
+    for each table, text to the LEFT and RIGHT of the table at the same y-band
+    is also captured as separate strips. This handles multi-column layouts where
+    prose and tables sit side-by-side at the same vertical position.
+
+    The result is a list of dicts in vertical (reading) order::
+
+        {"type": "text",  "content": "<stripped text>"}
+        {"type": "table", "rows": [["header", ...], ["row", ...], ...]}
+
+    Tables are never duplicated into the text stream; each character on the page
+    appears in exactly one element.
+    """
+    # pdfplumber top-left origin: bbox = (x0, top, x1, bottom), top < bottom.
+    tables_sorted = sorted(page.find_tables(), key=lambda t: t.bbox[1])
+
+    elements: List[Dict[str, Any]] = []
+    prev_bottom = 0.0
+
+    for table in tables_sorted:
+        x0, t_top, x1, t_bottom = table.bbox
+
+        # 1. Full-width strip ABOVE this table (skip negligible gaps < 2 pt)
+        if t_top > prev_bottom + 2:
+            strip = page.crop((0, prev_bottom, page.width, t_top))
+            text = strip.extract_text()
+            if text and text.strip():
+                elements.append({"type": "text", "content": text.strip()})
+
+        # 2. LEFT strip beside table — prose in the left column at same y-band
+        if x0 > 10:
+            strip = page.crop((0, t_top, x0, t_bottom))
+            text = strip.extract_text()
+            if text and text.strip():
+                elements.append({"type": "text", "content": text.strip()})
+
+        # 3. Table — clean None cells to empty string; skip all-blank tables
+        #    (chart legend boxes and axis tick tables produce blank table regions)
+        rows = table.extract() or []
+        clean_rows = [
+            [c if c is not None else "" for c in row]
+            for row in rows
+        ]
+        if clean_rows and not _is_blank_table(clean_rows):
+            elements.append({"type": "table", "rows": clean_rows})
+
+        # 4. RIGHT strip beside table — prose in the right column at same y-band
+        if x1 < page.width - 10:
+            strip = page.crop((x1, t_top, page.width, t_bottom))
+            text = strip.extract_text()
+            if text and text.strip():
+                elements.append({"type": "text", "content": text.strip()})
+
+        prev_bottom = max(prev_bottom, t_bottom)
+
+    # Text after last table (or full page when there are no tables)
+    if prev_bottom < page.height - 2:
+        strip = page.crop((0, prev_bottom, page.width, page.height))
+        text = strip.extract_text()
+        if text and text.strip():
+            elements.append({"type": "text", "content": text.strip()})
+
+    return elements
+
+
+class PdfExtractor:
+    """DocumentExtractor for ``.pdf`` files."""
+
+    extensions: Tuple[str, ...] = (".pdf",)
+
+    def __init__(self, vector_timeout: int = 120) -> None:
+        self.vector_timeout = vector_timeout
+
+    def extract(
+        self,
+        path: str,
+        image_filter: Optional[ImageFilterPipeline] = None,
+    ) -> Tuple[Dict[str, Any], List[Dict[str, Any]]]:
+        try:
+            import fitz  # PyMuPDF
+            import pdfplumber
+        except ImportError as e:
+            raise ImportError(
+                "PDF support requires PyMuPDF + pdfplumber: pip install 'multixtract[pdf]'"
+            ) from e
+        from PIL import Image
+
+        if image_filter is None:
+            image_filter = ImageFilterPipeline()
+        image_filter.reset()
+
+        base_name = os.path.splitext(os.path.basename(path))[0]
+        document: Dict[str, Any] = {"metadata": {}, "pgs": []}
+        prepared_images: List[Dict[str, Any]] = []
+        seen_xrefs: Set[int] = set()
+        doc_fitz = None
+
+        try:
+            with pdfplumber.open(path) as pdf:  # raises FileNotFoundError/PDFSyntaxError on bad path
+                _raw_meta = dict(pdf.metadata or {})
+                doc_fitz = fitz.open(path)
+
+                # Pass 1: build page dicts and collect xrefs in first-appearance order.
+                # xref_order stores (xref, page_idx, img_idx_on_page) for each unique xref.
+                xref_order: List[Tuple[int, int, int]] = []
+
+                for page_idx, page in enumerate(pdf.pages):
+                    # Guard: PyMuPDF and pdfplumber use independent parsers and
+                    # can disagree on page count for corrupted/non-linear PDFs.
+                    fitz_page = doc_fitz[page_idx] if page_idx < len(doc_fitz) else None
+
+                    hyperlinks: List[str] = []
+                    if fitz_page is not None:
+                        for _link in fitz_page.get_links():
+                            _uri = _link.get("uri", "")
+                            if _uri and _uri.startswith(("http://", "https://", "ftp://")):
+                                hyperlinks.append(_uri)
+                        hyperlinks = list(dict.fromkeys(hyperlinks))
+
+                    # Use _extract_page_elements for bbox-clean extraction (no
+                    # text/table overlap, Y-position ordered), then flatten to
+                    # the shared {txt, tables} schema used by all four extractors.
+                    _elems = _extract_page_elements(page)
+
+                    document["pgs"].append({
+                        "pg_num":     page_idx + 1,
+                        "kind":       "page",
+                        "title":      "",
+                        "elements":   _elems,
+                        "txt":        "\n\n".join(
+                            e["content"] for e in _elems if e["type"] == "text"
+                        ),
+                        "tables":     [
+                            e["rows"] for e in _elems if e["type"] == "table"
+                        ],
+                        "imgs":       [],
+                        "hyperlinks": hyperlinks,
+                    })
+
+                    if fitz_page is None:
+                        log.debug(
+                            "pg %d of %s has no fitz page (parser mismatch); skipping images",
+                            page_idx + 1, base_name,
+                        )
+                        continue
+
+                    img_counter = 0
+                    for img in fitz_page.get_images(full=True):
+                        xref = img[0]
+                        if xref in seen_xrefs:
+                            image_filter.note_duplicate()
+                            continue
+                        seen_xrefs.add(xref)
+                        xref_order.append((xref, page_idx, img_counter))
+                        img_counter += 1
+
+                # Minimum-page guarantee: ensure downstream always has at least one page.
+                if not document["pgs"]:
+                    document["pgs"].append({
+                        "pg_num": 1, "kind": "page", "title": "", "elements": [],
+                        "txt": "", "tables": [], "hyperlinks": [], "imgs": [],
+                    })
+
+                # Normalize metadata now that aggregates are known.
+                _table_count = sum(len(pg["tables"]) for pg in document["pgs"])
+                document["metadata"] = _normalize_pdf_metadata(
+                    _raw_meta, len(document["pgs"]), _table_count
+                )
+
+                # Pass 2: extract raw bytes and categorize into vector / WDP / raster.
+                vector_items: List[Tuple[str, bytes]] = []
+                wdp_items: List[Tuple[str, bytes]] = []
+                raster_cache: Dict[int, Any] = {}    # xref -> fitz base_image dict
+                xref_fake_path: Dict[int, str] = {}  # xref -> key used in `converted`
+
+                for xref, page_idx, _img_idx in xref_order:
+                    try:
+                        base_image = doc_fitz.extract_image(xref)
+                    except Exception as exc:
+                        log.debug(
+                            "xref %d image extraction failed on pg %d of %s: %s",
+                            xref, page_idx + 1, base_name, exc,
+                        )
+                        continue
+                    ext = f".{base_image['ext'].lower()}"
+                    # Use a synthetic path as the dict key so batch_convert_vectors_to_png
+                    # can write a temp file with a sensible name and extension.
+                    fake_path = f"xref_{xref}{ext}"
+                    xref_fake_path[xref] = fake_path
+                    if ext in VECTOR_EXTS:
+                        vector_items.append((fake_path, base_image["image"]))
+                    elif ext in WDP_EXTS:
+                        wdp_items.append((fake_path, base_image["image"]))
+                    else:
+                        raster_cache[xref] = base_image
+
+                # Pass 3: batch-convert all vector (EMF/WMF/SVG) and WDP images to PNG.
+                converted = batch_convert_vectors_to_png(vector_items, self.vector_timeout)
+                converted.update(decode_wdp_to_png(wdp_items))
+
+                # Pass 4: run prepare_image for every image that survived.
+                for xref, page_idx, img_idx in xref_order:
+                    fake_path = xref_fake_path.get(xref)
+                    if fake_path is None:
+                        continue  # extraction failed in pass 2
+
+                    if fake_path in converted:
+                        image_bytes = converted[fake_path]
+                        ext_out = "png"
+                    elif xref in raster_cache:
+                        base_image = raster_cache[xref]
+                        image_bytes = base_image["image"]
+                        ext_out = base_image["ext"]
+                        if ext_out == "png" and not image_bytes[:4].startswith(b"\x89PNG"):
+                            fixed = ensure_rgb_png(image_bytes)
+                            if fixed is None:
+                                continue
+                            image_bytes = fixed
+                    else:
+                        continue  # vector/WDP conversion failed; skip
+
+                    try:
+                        with Image.open(io.BytesIO(image_bytes)) as image:
+                            width, height = image.size
+                    except Exception as exc:
+                        log.debug(
+                            "image decode failed for xref %d on pg %d of %s: %s",
+                            xref, page_idx + 1, base_name, exc,
+                        )
+                        continue
+
+                    prepared = image_filter.prepare_image(
+                        image_bytes=image_bytes,
+                        ext=ext_out,
+                        width=width,
+                        height=height,
+                        image_id=f"page_{page_idx + 1}_img_{img_idx}",
+                        page_number=page_idx + 1,
+                        img_idx=img_idx,
+                    )
+                    if prepared is not None:
+                        prepared_images.append(prepared)
+        except ImportError:
+            raise
+        except Exception:
+            log.warning("PdfExtractor failed for %s", path, exc_info=True)
+            document["_base_name"] = base_name
+            return document, []
+        finally:
+            if doc_fitz is not None:
+                doc_fitz.close()
+
+        document["_base_name"] = base_name
+        return document, prepared_images

multixtract/extractors/pptx.py

@@ -0,0 +1,303 @@
+"""Native PowerPoint (.pptx) extractor.
+
+Ported from the ZF PPT + GPT-4o Vision pipeline. Extracts, with python-pptx:
+  * presentation metadata (slide count + dimensions)
+  * per-slide title, text (with GroupShape recursion + SmartArt), tables,
+    and hyperlinks (single pass over slide shapes)
+  * images from ``ppt/media/`` mapped to their slide via slide relationships
+
+Vector images (EMF/WMF/SVG, plus EMF-in-.bin) are converted to PNG in one
+headless LibreOffice batch call; JPEG XR (.wdp) via imagecodecs when available.
+Images are filtered through the shared :class:`ImageFilterPipeline` and returned
+as ``prepared_images`` for downstream vision analysis.
+
+Requires the ``[pptx]`` extra (python-pptx). EMF/WMF/SVG need system LibreOffice;
+.wdp needs optional ``imagecodecs``. Both degrade gracefully.
+"""
+from __future__ import annotations
+
+import io
+import logging
+import os
+import xml.etree.ElementTree as ET
+import zipfile
+from collections import defaultdict
+from typing import Any, Dict, List, Optional, Set, Tuple
+
+from ..filters import ImageFilterPipeline
+from ._image_utils import (
+    IMAGE_EXTS,
+    VECTOR_EXTS,
+    WDP_EXTS,
+    batch_convert_vectors_to_png,
+    decode_wdp_to_png,
+    ensure_rgb_png,
+)
+
+log = logging.getLogger("multixtract.extractors.pptx")
+
+_A_NS = "http://schemas.openxmlformats.org/drawingml/2006/main"
+_PKG_REL_NS = "http://schemas.openxmlformats.org/package/2006/relationships"
+
+
+def _iter_all_shapes(shapes, mso):
+    """Recursively yield shapes, descending into GroupShapes."""
+    for shape in shapes:
+        if shape.shape_type == mso.GROUP:
+            yield from _iter_all_shapes(shape.shapes, mso)
+        else:
+            yield shape
+
+
+def _extract_smartart_text(shape) -> Optional[str]:
+    """Extract SmartArt text from drawingml <a:t> nodes."""
+    try:
+        root = ET.fromstring(shape.element.xml)
+        texts = [(t.text or "").strip() for t in root.iter(f"{{{_A_NS}}}t")]
+        texts = [t for t in texts if t]
+        if texts:
+            return " | ".join(texts)
+    except Exception:
+        pass
+    return None
+
+
+def _extract_slide_content(slide, mso) -> Tuple[str, str, List[List[List[str]]], List[str]]:
+    """Single-pass slide extraction: (text, title, tables, hyperlinks)."""
+    texts: List[str] = []
+    title = ""
+    tables: List[List[List[str]]] = []
+    hyperlinks: List[str] = []
+
+    for shape in _iter_all_shapes(slide.shapes, mso):
+        shape_type = shape.shape_type
+        if shape_type == mso.EMBEDDED_OLE_OBJECT:
+            continue
+
+        if shape.has_text_frame:
+            parts = []
+            for para in shape.text_frame.paragraphs:
+                pt = para.text.strip()
+                if pt:
+                    parts.append(pt)
+                for run in para.runs:
+                    try:
+                        if run.hyperlink and run.hyperlink.address:
+                            hyperlinks.append(run.hyperlink.address)
+                    except Exception:
+                        pass
+            shape_text = "\n".join(parts)
+            if not shape_text:
+                continue
+            try:
+                if shape.is_placeholder and shape.placeholder_format.idx == 0:
+                    title = shape_text
+            except Exception:
+                pass
+            texts.append(shape_text)
+
+        elif shape.has_table:
+            table_data = [[cell.text.strip() for cell in row.cells] for row in shape.table.rows]
+            if table_data:
+                tables.append(table_data)
+
+        elif shape_type == mso.PICTURE:
+            pass  # images handled separately
+        else:
+            smartart_text = _extract_smartart_text(shape)
+            if smartart_text:
+                texts.append(f"[SmartArt] {smartart_text}")
+
+    return "\n".join(texts), title, tables, hyperlinks
+
+
+def _build_slide_media_map(zf: zipfile.ZipFile, n_slides: int) -> Dict[int, List[str]]:
+    """Map slide number -> [media paths] from each slide's relationships."""
+    slide_media: Dict[int, List[str]] = defaultdict(list)
+    namelist = set(zf.namelist())
+    for slide_num in range(1, n_slides + 1):
+        rels_path = f"ppt/slides/_rels/slide{slide_num}.xml.rels"
+        if rels_path not in namelist:
+            continue
+        try:
+            root = ET.fromstring(zf.read(rels_path).decode("utf-8"))
+            for rel in root.findall(f"{{{_PKG_REL_NS}}}Relationship"):
+                target = rel.get("Target", "")
+                if "../media/" in target:
+                    slide_media[slide_num].append(f"ppt/media/{target.replace('../media/', '')}")
+        except Exception as exc:
+            log.debug("rels parse failed for slide %d: %s", slide_num, exc)
+    return slide_media
+
+
+def _looks_like_emf_bin(raw: bytes) -> bool:
+    """Detect EMF metafiles stored with a .bin extension."""
+    return len(raw) >= 44 and raw[:4] == b"\x01\x00\x00\x00" and raw[40:44] == b" EMF"
+
+
+class PptxExtractor:
+    """DocumentExtractor for ``.pptx`` (native python-pptx extraction)."""
+
+    extensions: Tuple[str, ...] = (".pptx",)
+
+    def __init__(self, vector_timeout: int = 120) -> None:
+        self.vector_timeout = vector_timeout
+
+    def extract(
+        self,
+        path: str,
+        image_filter: Optional[ImageFilterPipeline] = None,
+    ) -> Tuple[Dict[str, Any], List[Dict[str, Any]]]:
+        try:
+            from pptx import Presentation
+            from pptx.enum.shapes import MSO_SHAPE_TYPE as mso
+        except ImportError as e:
+            raise ImportError(
+                "PowerPoint support requires python-pptx: pip install 'multixtract[pptx]'"
+            ) from e
+        from PIL import Image
+
+        if image_filter is None:
+            image_filter = ImageFilterPipeline()
+        image_filter.reset()
+
+        base_name = os.path.splitext(os.path.basename(path))[0]
+        empty: Dict[str, Any] = {"_base_name": base_name, "metadata": {}, "pgs": []}
+        try:
+            prs = Presentation(path)
+            n_slides = len(prs.slides)
+
+            document: Dict[str, Any] = {
+                "metadata": {
+                    "slide_count":  n_slides,
+                    "slide_width":  prs.slide_width,
+                    "slide_height": prs.slide_height,
+                },
+                "_base_name": base_name,
+                "pgs": [],
+            }
+
+            prepared_images: List[Dict[str, Any]] = []
+            try:
+                zf = zipfile.ZipFile(path, "r")
+            except Exception as exc:
+                log.warning("could not open %s as ZIP for image extraction: %s", base_name, exc)
+                # Still return slide text even if the archive can't be opened.
+                for idx, slide in enumerate(prs.slides):
+                    txt, title, tables, links = _extract_slide_content(slide, mso)
+                    document["pgs"].append({
+                        "pg_num": idx + 1, "kind": "slide", "title": title,
+                        "txt": txt, "tables": tables,
+                        "hyperlinks": list(dict.fromkeys(links)), "imgs": [],
+                    })
+                return document, prepared_images
+
+            try:
+                slide_media_map = _build_slide_media_map(zf, n_slides)
+                seen_media: Set[str] = set()
+
+                # Pre-scan: collect vector / WDP images that need conversion.
+                vector_items, wdp_items = [], []
+                for slide_num in range(1, n_slides + 1):
+                    for media_path in slide_media_map.get(slide_num, []):
+                        if media_path in seen_media:
+                            continue
+                        ext = os.path.splitext(media_path)[1].lower()
+                        try:
+                            raw = zf.read(media_path)
+                        except KeyError:
+                            continue
+                        if ext in VECTOR_EXTS:
+                            vector_items.append((media_path, raw))
+                            seen_media.add(media_path)
+                        elif ext in WDP_EXTS:
+                            wdp_items.append((media_path, raw))
+                            seen_media.add(media_path)
+                        elif ext == ".bin" and _looks_like_emf_bin(raw):
+                            vector_items.append((media_path, raw))
+                            seen_media.add(media_path)
+                converted = batch_convert_vectors_to_png(vector_items, self.vector_timeout)
+                converted.update(decode_wdp_to_png(wdp_items))
+
+                # Track media paths already sent to prepare_image (deduplicates
+                # converted vectors that appear on multiple slides — Bug 8).
+                processed_media: Set[str] = set()
+
+                # Process slides: content + per-slide images.
+                for slide_idx, slide in enumerate(prs.slides):
+                    slide_num = slide_idx + 1
+                    txt, title, tables, links = _extract_slide_content(slide, mso)
+                    document["pgs"].append({
+                        "pg_num":     slide_num,
+                        "kind":       "slide",
+                        "title":      title,
+                        "txt":        txt,
+                        "tables":     tables,
+                        "hyperlinks": list(dict.fromkeys(links)),
+                        "imgs":       [],
+                    })
+
+                    img_idx = 0
+                    for media_path in slide_media_map.get(slide_num, []):
+                        ext = os.path.splitext(media_path)[1].lower()
+                        if ext not in IMAGE_EXTS:
+                            continue
+
+                        # Deduplicate across all slides (covers both converted vectors
+                        # and rasters that appear in multiple slide relationships).
+                        if media_path in processed_media:
+                            image_filter.note_duplicate()
+                            continue
+
+                        if media_path in converted:
+                            image_bytes, ext_out = converted[media_path], "png"
+                        elif ext in VECTOR_EXTS or ext in WDP_EXTS or ext == ".bin":
+                            continue  # conversion failed or non-image .bin
+                        else:
+                            if media_path in seen_media:
+                                image_filter.note_duplicate()
+                                continue  # raster already handled on an earlier slide
+                            try:
+                                image_bytes = zf.read(media_path)
+                            except KeyError:
+                                continue
+                            seen_media.add(media_path)
+                            ext_out = ext.lstrip(".")
+                            ext_out = {"tif": "tiff", "jpg": "jpeg"}.get(ext_out, ext_out)
+                            if ext_out == "png" and not image_bytes[:4].startswith(b"\x89PNG"):
+                                fixed = ensure_rgb_png(image_bytes)
+                                if fixed is None:
+                                    continue
+                                image_bytes = fixed
+
+                        processed_media.add(media_path)
+
+                        try:
+                            with Image.open(io.BytesIO(image_bytes)) as image:
+                                width, height = image.size
+                        except Exception as exc:
+                            log.debug("image decode failed for %s on slide %d of %s: %s",
+                                      media_path, slide_num, base_name, exc)
+                            continue
+
+                        prepared = image_filter.prepare_image(
+                            image_bytes=image_bytes,
+                            ext=ext_out,
+                            width=width,
+                            height=height,
+                            image_id=f"page_{slide_num}_img_{img_idx}",
+                            page_number=slide_num,
+                            img_idx=img_idx,
+                        )
+                        if prepared is not None:
+                            prepared_images.append(prepared)
+                            img_idx += 1  # only advance for images that pass filtering
+            finally:
+                zf.close()
+
+            return document, prepared_images
+        except ImportError:
+            raise
+        except Exception:
+            log.warning("PptxExtractor failed for %s", path, exc_info=True)
+            return empty, []