super-document-processor 0.1.3__py3-none-any.whl

super_document_processor/utils/pptx_converter.py

@@ -0,0 +1,170 @@
+import io
+import os
+import gc
+import zipfile
+import base64
+import logging
+from pathlib import Path
+from typing import Optional, Union, Dict, Any, List
+from concurrent.futures import ThreadPoolExecutor
+
+try:
+    from super_document_processor.utils.aspose_slide_renderer import (
+        strip_aspose_watermark_from_svg,
+        fix_svg_dimensions,
+        render_svg_to_png_bytes,
+        render_slide_to_png_bytes
+    )
+except ImportError:
+    from utils.aspose_slide_renderer import (
+        strip_aspose_watermark_from_svg,
+        fix_svg_dimensions,
+        render_svg_to_png_bytes,
+        render_slide_to_png_bytes
+    )
+
+logger = logging.getLogger("super_document_processor.pptx_converter")
+
+slides = None
+
+def _ensure_aspose():
+    global slides
+    if slides is None:
+            import aspose.slides as _slides
+            slides = _slides
+
+def render_slide_to_svg_string(aspose_slide, scale: float = 2.0) -> str:
+    """
+    Exports a single Aspose slide object to a cleaned, watermark-stripped SVG string.
+    """
+    svg_stream = io.BytesIO()
+    aspose_slide.write_as_svg(svg_stream)
+    raw_svg = svg_stream.getvalue().decode("utf-8", errors="ignore")
+    clean_svg = strip_aspose_watermark_from_svg(raw_svg)
+    return fix_svg_dimensions(clean_svg, scale=scale)
+
+def convert_pptx(
+    pptx_source: Union[str, Path, bytes, io.BytesIO],
+    format: str = "svg",
+    slide: Optional[int] = None,
+    scale: float = 2.0
+) -> Dict[str, Any]:
+    """
+    Converts slides of a PowerPoint (.pptx) file to SVG or PNG images.
+    
+    Args:
+        pptx_source: File path (str/Path) or raw file bytes.
+        format: Target format - 'svg' or 'png' (also accepts 'img', 'image').
+        slide: Optional 1-based slide index. If None, converts all slides.
+        scale: Resolution scaling multiplier (default 2.0).
+        
+    Returns:
+        Dict containing total slides, format, and slide content payloads.
+    """
+    _ensure_aspose()
+    norm_format = "png" if format.lower() in ("png", "img", "image") else "svg"
+
+    # Load presentation from file path or in-memory byte stream
+    if isinstance(pptx_source, (str, Path)):
+        if not os.path.exists(str(pptx_source)):
+            raise FileNotFoundError(f"PPTX file not found: {pptx_source}")
+        pres = slides.Presentation(str(pptx_source))
+    elif isinstance(pptx_source, bytes):
+        pres = slides.Presentation(io.BytesIO(pptx_source))
+    elif isinstance(pptx_source, io.BytesIO):
+        pres = slides.Presentation(pptx_source)
+    else:
+        raise ValueError("Invalid pptx_source. Must be a file path, bytes, or BytesIO.")
+
+    try:
+        total_slides = len(pres.slides)
+        if total_slides == 0:
+            raise ValueError("The presentation contains no slides.")
+
+        if slide is not None:
+            if slide < 1 or slide > total_slides:
+                raise ValueError(f"Slide index {slide} out of range (total slides: {total_slides}).")
+            
+            aspose_slide = pres.slides[slide - 1]
+            svg_content = render_slide_to_svg_string(aspose_slide, scale=scale)
+            
+            if norm_format == "svg":
+                return {
+                    "slide": slide,
+                    "total_slides": total_slides,
+                    "format": "svg",
+                    "content": svg_content,
+                    "raw_bytes": svg_content.encode("utf-8")
+                }
+            else:
+                png_bytes = render_svg_to_png_bytes(svg_content, scale=scale)
+                return {
+                    "slide": slide,
+                    "total_slides": total_slides,
+                    "format": "png",
+                    "content_base64": base64.b64encode(png_bytes).decode("utf-8"),
+                    "raw_bytes": png_bytes
+                }
+
+        # Convert all slides
+        workers = min(int(os.environ.get("MAX_WORKERS", 3)), total_slides)
+        results = []
+
+        def _process_single(idx_slide_tuple):
+            idx, s = idx_slide_tuple
+            svg_str = render_slide_to_svg_string(s, scale=scale)
+            if norm_format == "svg":
+                return {
+                    "slide": idx,
+                    "format": "svg",
+                    "content": svg_str,
+                    "raw_bytes": svg_str.encode("utf-8")
+                }
+            else:
+                png_b = render_svg_to_png_bytes(svg_str, scale=scale)
+                return {
+                    "slide": idx,
+                    "format": "png",
+                    "content_base64": base64.b64encode(png_b).decode("utf-8"),
+                    "raw_bytes": png_b
+                }
+
+        slide_tuples = list(enumerate(pres.slides, start=1))
+        if workers > 1:
+            with ThreadPoolExecutor(max_workers=workers) as executor:
+                results = list(executor.map(_process_single, slide_tuples))
+        else:
+            results = [_process_single(st) for st in slide_tuples]
+
+        results.sort(key=lambda x: x["slide"])
+
+        return {
+            "total_slides": total_slides,
+            "format": norm_format,
+            "slides": results
+        }
+    finally:
+        try:
+            del pres
+        except Exception:
+            pass
+        gc.collect()
+
+def create_pptx_render_zip(
+    pptx_source: Union[str, Path, bytes, io.BytesIO],
+    format: str = "svg",
+    scale: float = 2.0
+) -> bytes:
+    """
+    Renders all slides in a PPTX and bundles them into a ZIP archive.
+    """
+    res = convert_pptx(pptx_source, format=format, slide=None, scale=scale)
+    ext = "svg" if res["format"] == "svg" else "png"
+    
+    zip_buffer = io.BytesIO()
+    with zipfile.ZipFile(zip_buffer, "w", zipfile.ZIP_DEFLATED) as zip_file:
+        for item in res["slides"]:
+            filename = f"slide_{item['slide']}.{ext}"
+            zip_file.writestr(filename, item["raw_bytes"])
+            
+    return zip_buffer.getvalue()

super_document_processor/utils/vlm.py

@@ -0,0 +1,176 @@
+import base64
+import json
+import logging
+import time
+import urllib.request
+import urllib.error
+
+logger = logging.getLogger("super_document_processor.vlm")
+
+try:
+    from super_document_processor.processor import OPENAI_API_KEY, OPENAI_BASE_URL
+except ImportError:
+    from processor import OPENAI_API_KEY, OPENAI_BASE_URL
+
+def is_vision_unsupported_error(error_msg: str) -> bool:
+    """Detect if the provider specifically rejected image/multimodal input."""
+    err_lower = error_msg.lower()
+    vision_error_indicators = [
+        "image_url",
+        "vision",
+        "multimodal",
+        "does not support image",
+        "expected a string, got an object",
+        "unsupported parameter: messages",
+        "invalid parameter: messages",
+        "model does not support",
+        "unknown parameter: 'image_url'",
+    ]
+    return any(indicator in err_lower for indicator in vision_error_indicators)
+
+def is_invalid_model_error(error_msg: str) -> bool:
+    """Detect if the error is due to an unknown or invalid model name."""
+    err_lower = error_msg.lower()
+    model_error_indicators = [
+        "invalid model",
+        "model not found",
+        "model does not exist",
+        "unknown model",
+        "no such model",
+        "model_not_found",
+        "invalid model name",
+        "/v1/models",
+        "does not exist or you do not have access",
+    ]
+    return any(indicator in err_lower for indicator in model_error_indicators)
+
+def is_auth_error(error_msg: str) -> bool:
+    """Detect authentication or permission errors."""
+    err_lower = error_msg.lower()
+    auth_indicators = [
+        "invalid api key",
+        "incorrect api key",
+        "unauthorized",
+        "authentication",
+        "permission_denied",
+        "status code 401",
+        "code: 401",
+        "status code 403",
+        "code: 403",
+    ]
+    return any(indicator in err_lower for indicator in auth_indicators)
+
+def generate_image_description(image_bytes, model=None, max_retries=3, retry_delay=2):
+    base_url = (OPENAI_BASE_URL).rstrip("/")
+    api_key = OPENAI_API_KEY
+
+    is_local = "localhost" in base_url or "127.0.0.1" in base_url
+    if not api_key and not is_local:
+        raise ValueError(
+            "Cannot process images: OPENAI_API_KEY is not set in the environment.\n"
+            "Please set OPENAI_API_KEY or disable image processing."
+        )
+
+    if not model:
+        raise ValueError(
+            "Cannot process images: No vision model specified.\n"
+            "Please specify a vision-capable model via CLI (--model) or API ('model' parameter)."
+        )
+
+    base64_image = base64.b64encode(image_bytes).decode("utf-8")
+    image_url = f"data:image/jpeg;base64,{base64_image}"
+
+    endpoint = f"{base_url}/chat/completions"
+    payload = {
+        "model": model,
+        "messages": [
+            {
+                "role": "system",
+                "content": """
+You are an advanced multimodal AI specialized in both high-fidelity data extraction and detailed image description. 
+
+### TASK GUIDELINES:
+1. **Table Extraction (High Priority)**: If the image contains a table, you must recreate it perfectly as a **Markdown Table**. 
+   - Include every row and column.
+   - Do not use <br> tags or HTML formatting inside cells.
+   - Do not summarize the data; transcribe it 100% accurately.
+2. **Text Transcription**: Transcribe all other visible text, maintaining logical structure (headings, lists).
+3. **Visual Analysis**: For photographs, diagrams, or UI layouts, provide a detailed description of objects, people, colors, and spatial relationships.
+4. **Logical Structure**: Organize your response with clear Markdown headers (e.g., ## Table Data, ## Visual Description).
+
+### RULES:
+- Prioritize the **content** of the image. If a table is present, it should be the most prominent part of your response.
+- Do not use conversational preambles (e.g., "In this image, I can see...").
+- Maintain objectivity and do not infer meaning beyond what is shown.
+"""
+            },
+            {
+                "role": "user",
+                "content": [
+                    {"type": "text", "text": "Analyze this image in detail. If there are tables, recreate them fully as markdown tables. Transcribe all text and describe all visual elements."},
+                    {"type": "image_url", "image_url": {"url": image_url}}
+                ]
+            }
+        ],
+        "temperature": 0.0,
+        "max_tokens": 4096,
+        "stream": False,
+    }
+
+    req_data = json.dumps(payload).encode("utf-8")
+    headers = {
+        "Content-Type": "application/json",
+        "User-Agent": "SuperDocumentProcessor/1.0"
+    }
+    if api_key:
+        headers["Authorization"] = f"Bearer {api_key}"
+
+    for attempt in range(1, max_retries + 1):
+        try:
+            req = urllib.request.Request(endpoint, data=req_data, headers=headers, method="POST")
+            with urllib.request.urlopen(req, timeout=60) as resp:
+                res_json = json.loads(resp.read().decode("utf-8"))
+                description = res_json["choices"][0]["message"]["content"].strip()
+                return description
+        except urllib.error.HTTPError as e:
+            try:
+                err_body = e.read().decode("utf-8", errors="ignore")
+            except Exception:
+                err_body = ""
+            err_msg = f"HTTP {e.code}: {e.reason} - {err_body}"
+
+            # Fast-fail immediately if the model is invalid/unknown - DO NOT retry
+            if is_invalid_model_error(err_msg):
+                raise ValueError(
+                    f"Invalid model '{model}' specified for vision processing!\n"
+                    f"Provider Error: {err_msg}"
+                ) from e
+
+            # Fast-fail immediately if authentication or permissions fail - DO NOT retry
+            if is_auth_error(err_msg):
+                raise ValueError(
+                    f"Authentication error with configured LLM provider!\n"
+                    f"Provider Error: {err_msg}"
+                ) from e
+
+            # Fast-fail immediately if the model doesn't support images - DO NOT retry
+            if is_vision_unsupported_error(err_msg):
+                raise ValueError(
+                    f"Configured model '{model}' does not support vision/image inputs!\n"
+                    f"Provider Error: {err_msg}\n"
+                    f"Fix: Pass a vision-capable model (e.g. 'gpt-4o', 'google-gemini-3-flash') "
+                    f"or disable image processing."
+                ) from e
+
+            logger.warning(f"VLM attempt {attempt} failed: {err_msg}")
+            if attempt < max_retries:
+                time.sleep(retry_delay)
+            else:
+                return f"Image (description generation failed: {err_msg})"
+        except Exception as e:
+            err_msg = str(e)
+            logger.warning(f"VLM attempt {attempt} failed: {err_msg}")
+            if attempt < max_retries:
+                time.sleep(retry_delay)
+            else:
+                return f"Image (description generation failed: {err_msg})"