docslight-lite 0.1.0__py3-none-any.whl

docslight/local/office_loader.py

@@ -0,0 +1,128 @@
+"""Office document loading as Markdown."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Any
+
+from docslight.exceptions import DependencyMissingError, UnsupportedFormatError
+from docslight.local.loaders import LOCAL_DEPS_MESSAGE, LoadedTextDocument
+
+LEGACY_OFFICE_EXTENSIONS = {".doc", ".ppt", ".xls"}
+
+
+def load_workbook(path: Path, **kwargs: Any) -> Any:
+    """Load an XLSX workbook with optional dependency handling."""
+    try:
+        from openpyxl import load_workbook as openpyxl_load_workbook
+    except ModuleNotFoundError as exc:  # pragma: no cover - depends on environment
+        raise DependencyMissingError(LOCAL_DEPS_MESSAGE) from exc
+    return openpyxl_load_workbook(path, **kwargs)
+
+
+class OfficeMarkdownLoader:
+    """Load modern Office files into basic Markdown."""
+
+    def load(self, path: Path | str) -> LoadedTextDocument:
+        """Load a DOCX, PPTX, or XLSX file into Markdown."""
+        source_path = Path(path)
+        suffix = source_path.suffix.lower()
+        if suffix in LEGACY_OFFICE_EXTENSIONS:
+            raise UnsupportedFormatError("Legacy Office files must convert to DOCX, PPTX, or XLSX")
+        if suffix == ".docx":
+            return self._load_docx(source_path)
+        if suffix == ".pptx":
+            return self._load_pptx(source_path)
+        if suffix == ".xlsx":
+            return self._load_xlsx(source_path)
+        raise UnsupportedFormatError(f"Unsupported Office format: {suffix or source_path.name}")
+
+    def _load_docx(self, path: Path) -> LoadedTextDocument:
+        try:
+            from docx import Document
+        except ModuleNotFoundError as exc:  # pragma: no cover - depends on environment
+            raise DependencyMissingError(LOCAL_DEPS_MESSAGE) from exc
+
+        document = Document(str(path))
+        parts = [paragraph.text for paragraph in document.paragraphs if paragraph.text.strip()]
+        for table in document.tables:
+            rows: list[list[str]] = []
+            for row in table.rows:
+                cells = [cell.text.strip() for cell in row.cells]
+                if any(cells):
+                    rows.append(cells)
+            if rows:
+                parts.append(self._rows_to_markdown(rows))
+        return LoadedTextDocument(
+            markdown="\n\n".join(parts),
+            metadata={
+                "document_type": "docx",
+                "page_count": 1,
+                "paragraph_count": len(document.paragraphs),
+                "table_count": len(document.tables),
+            },
+        )
+
+    def _load_pptx(self, path: Path) -> LoadedTextDocument:
+        try:
+            from pptx import Presentation
+        except ModuleNotFoundError as exc:  # pragma: no cover - depends on environment
+            raise DependencyMissingError(LOCAL_DEPS_MESSAGE) from exc
+
+        presentation = Presentation(str(path))
+        slide_parts: list[str] = []
+        for index, slide in enumerate(presentation.slides, start=1):
+            texts: list[str] = []
+            for shape in slide.shapes:
+                text = getattr(shape, "text", "")
+                if text.strip():
+                    texts.append(text.strip())
+            slide_parts.append("\n\n".join([f"# Slide {index}", *texts]))
+        return LoadedTextDocument(
+            markdown="\n\n".join(slide_parts),
+            metadata={
+                "document_type": "pptx",
+                "page_count": len(presentation.slides),
+                "slide_count": len(presentation.slides),
+            },
+        )
+
+    def _load_xlsx(self, path: Path) -> LoadedTextDocument:
+        workbook = load_workbook(path, data_only=True, read_only=True)
+        sheets: list[str] = []
+        try:
+            for worksheet in workbook.worksheets:
+                rows = [self._format_row(row) for row in worksheet.iter_rows(values_only=True)]
+                rows = [row for row in rows if row]
+                sheets.append(
+                    "\n".join([f"## Sheet: {worksheet.title}", self._rows_to_markdown(rows)])
+                )
+            return LoadedTextDocument(
+                markdown="\n\n".join(sheets),
+                metadata={
+                    "document_type": "xlsx",
+                    "page_count": len(workbook.worksheets),
+                    "sheet_count": len(workbook.worksheets),
+                    "sheet_names": [worksheet.title for worksheet in workbook.worksheets],
+                },
+            )
+        finally:
+            workbook.close()
+
+    def _format_row(self, row: tuple[Any, ...]) -> list[str]:
+        values = ["" if value is None else str(value) for value in row]
+        if not any(values):
+            return []
+        return values
+
+    def _rows_to_markdown(self, rows: list[list[str]]) -> str:
+        if not rows:
+            return ""
+        escaped_rows = [[self._escape_table_cell(cell) for cell in row] for row in rows]
+        header = escaped_rows[0]
+        separator = ["---"] * len(header)
+        markdown_rows = [header, separator, *escaped_rows[1:]]
+        return "\n".join("| " + " | ".join(row) + " |" for row in markdown_rows)
+
+    def _escape_table_cell(self, value: str) -> str:
+        return value.replace("\n", " ").replace("\r", " ").replace("|", "\\|")

docslight/local/paddle_parser.py

@@ -0,0 +1,173 @@
+"""PaddleOCR PP-StructureV3 parser adapter for local files."""
+
+from __future__ import annotations
+
+import os
+import sys
+from collections.abc import Iterable
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Any
+
+from docslight.exceptions import DependencyMissingError, LocalProcessingError
+from docslight.local.loaders import LOCAL_DEPS_MESSAGE
+from docslight.result import ParseResult
+
+DEFAULT_PPSTRUCTUREV3_OPTIONS: dict[str, Any] = {
+    "use_doc_orientation_classify": False,
+    "use_doc_unwarping": False,
+    "use_textline_orientation": False,
+    "use_formula_recognition": False,
+    "use_chart_recognition": False,
+    # "layout_detection_model_name": "PP-DocLayout-M",
+    "use_region_detection": False,
+    "text_recognition_model_name": "PP-OCRv5_mobile_rec",
+    "text_detection_model_name": "PP-OCRv5_mobile_det",
+
+}
+
+
+@dataclass(frozen=True)
+class OCRLine:
+    """One OCR text line."""
+
+    text: str
+    bbox: list[Any] | None
+    confidence: float | None
+
+    def to_json(self) -> dict[str, Any]:
+        """Return a JSON-serializable representation."""
+        return {
+            "text": self.text,
+            "bbox": self.bbox,
+            "confidence": self.confidence,
+        }
+
+
+@dataclass(frozen=True)
+class OCRPage:
+    """OCR result for one page."""
+
+    page_number: int
+    lines: list[OCRLine]
+
+    def to_json(self) -> dict[str, Any]:
+        """Return a JSON-serializable representation."""
+        return {
+            "page_number": self.page_number,
+            "lines": [line.to_json() for line in self.lines],
+        }
+
+
+class PaddleOCRParser:
+    """Run PP-StructureV3 over local PDF and image files."""
+
+    def __init__(self, pipeline: Any | None = None, **pipeline_options: Any) -> None:
+        self.pipeline_options = {**DEFAULT_PPSTRUCTUREV3_OPTIONS, **pipeline_options}
+        self._pipeline: Any = pipeline
+        self._device_label: str | None = None
+
+    def parse(self, path: Path | str) -> ParseResult:
+        """Parse a local PDF or image into structured Markdown and page JSON."""
+        pipeline = self._load_pipeline()
+        raw_results = self._predict(pipeline, Path(path))
+        markdown_pages, pages = self._normalize_results(raw_results)
+        return ParseResult(
+            markdown=self._build_markdown(pipeline, markdown_pages),
+            pages=pages,
+        )
+
+    def _load_pipeline(self) -> Any:
+        if self._pipeline is not None:
+            return self._pipeline
+        os.environ.setdefault("PADDLE_PDX_ENABLE_MKLDNN_BYDEFAULT", "0")
+        try:
+            from paddleocr import PPStructureV3
+        except (ImportError, ModuleNotFoundError) as exc:  # pragma: no cover - depends on env
+            raise DependencyMissingError(LOCAL_DEPS_MESSAGE) from exc
+        self.pipeline_options.setdefault("device", _detect_device())
+        self._device_label = (
+            "GPU" if str(self.pipeline_options["device"]).startswith("gpu") else "CPU"
+        )
+        print(
+            f"DocSlight local PP-StructureV3 inference device: {self._device_label}",
+            file=sys.stderr,
+        )
+        self._pipeline = PPStructureV3(**self.pipeline_options)
+        return self._pipeline
+
+    def _predict(self, pipeline: Any, path: Path) -> list[Any]:
+        try:
+            raw_results = pipeline.predict(input=str(path))
+        except LocalProcessingError:
+            raise
+        except Exception as exc:  # noqa: BLE001
+            raise LocalProcessingError(f"Local PaddleOCR parsing failed: {exc}") from exc
+        if raw_results is None:
+            return []
+        if isinstance(raw_results, list):
+            return raw_results
+        if isinstance(raw_results, Iterable) and not isinstance(raw_results, (str, bytes, dict)):
+            return list(raw_results)
+        raise LocalProcessingError("Unexpected PP-StructureV3 result format")
+
+    def _normalize_results(self, results: list[Any]) -> tuple[list[Any], list[dict[str, Any]]]:
+        markdown_pages: list[Any] = []
+        pages: list[dict[str, Any]] = []
+        for result in results:
+            if result is None:
+                continue
+            if not hasattr(result, "markdown") or not hasattr(result, "json"):
+                raise LocalProcessingError("Unexpected PP-StructureV3 result format")
+            markdown_pages.append(result.markdown)
+            pages.append(self._normalize_page_payload(result.json))
+        return markdown_pages, pages
+
+    def _normalize_page_payload(self, payload: Any) -> dict[str, Any]:
+        if callable(payload):
+            payload = payload()
+        if not isinstance(payload, dict):
+            raise LocalProcessingError("Unexpected PP-StructureV3 result format")
+        data = payload.get("res", payload)
+        if not isinstance(data, dict):
+            raise LocalProcessingError("Unexpected PP-StructureV3 result format")
+        return data
+
+    def _build_markdown(self, pipeline: Any, markdown_pages: list[Any]) -> str:
+        if not markdown_pages:
+            return ""
+        if len(markdown_pages) == 1:
+            return self._markdown_to_text(markdown_pages[0])
+        combined_markdown = pipeline.concatenate_markdown_pages(markdown_pages)
+        return self._markdown_to_text(combined_markdown)
+
+    def _markdown_to_text(self, markdown: Any) -> str:
+        if markdown is None:
+            return ""
+        if isinstance(markdown, str):
+            return markdown
+        if isinstance(markdown, dict):
+            text = markdown.get("markdown_texts", markdown.get("markdown", ""))
+            if isinstance(text, str):
+                return text
+        raise LocalProcessingError("Unexpected PP-StructureV3 result format")
+
+
+def _detect_device() -> str:
+    try:
+        import paddle
+    except ModuleNotFoundError:
+        return "cpu"
+
+    try:
+        device = getattr(paddle, "device", None)
+        cuda = getattr(device, "cuda", None) if device is not None else None
+        if cuda is None or cuda.device_count() <= 0:
+            return "cpu"
+        if device is not None and device.is_compiled_with_cuda():
+            return "gpu"
+        if hasattr(paddle, "is_compiled_with_cuda") and paddle.is_compiled_with_cuda():
+            return "gpu"
+    except Exception:
+        return "cpu"
+    return "cpu"

docslight/local/pipeline.py

@@ -0,0 +1,213 @@
+"""Local document parsing pipeline."""
+
+from __future__ import annotations
+
+import importlib
+import inspect
+import io
+import json
+import zipfile
+from dataclasses import replace
+from pathlib import Path
+from typing import Any, cast
+
+from docslight.config import DocSlightConfig
+from docslight.exceptions import ConfigurationError, UnsupportedFormatError
+from docslight.local.layout_blocks import build_layout_blocks
+from docslight.local.loaders import OFFICE_EXTENSIONS, RASTER_EXTENSIONS, FileLoader
+from docslight.local.markdown import MarkdownBuilder
+from docslight.local.office_loader import LEGACY_OFFICE_EXTENSIONS, OfficeMarkdownLoader
+from docslight.local.paddle_parser import PaddleOCRParser
+from docslight.result import ExtractResult, ParseResult
+
+FIXED_LLM_PARAMETERS = {"markdown", "fields", "schema", "document_types"}
+
+
+def _cloud_extract_result(data: dict[str, Any]) -> dict[str, Any]:
+    if _is_page_grouped_result(data):
+        return data
+
+    table_bboxes = data.get("_table_bboxes") if isinstance(data.get("_table_bboxes"), dict) else {}
+    grouped: dict[str, dict[str, Any]] = {}
+    for key, value in data.items():
+        if key == "_table_bboxes":
+            continue
+        if key == "tables" and isinstance(value, dict):
+            for table_name, rows in value.items():
+                page_key = _page_key(table_bboxes.get(table_name))
+                page = grouped.setdefault(page_key, {})
+                tables = page.setdefault("tables", {})
+                if isinstance(tables, dict):
+                    tables[table_name] = rows
+            continue
+        page_key = _page_key(value)
+        grouped.setdefault(page_key, {})[key] = _cloud_extract_value(value)
+    return grouped or {"Page_1": {}}
+
+
+def _is_page_grouped_result(data: dict[str, Any]) -> bool:
+    return bool(data) and all(isinstance(key, str) and key.startswith("Page_") for key in data)
+
+
+def _page_key(value: Any) -> str:
+    if isinstance(value, dict):
+        page_id = value.get("page_id") or value.get("page")
+        if page_id is not None:
+            return f"Page_{page_id}"
+        bboxes = value.get("bboxes") or value.get("bbox")
+        if isinstance(bboxes, list):
+            candidates = bboxes if bboxes and isinstance(bboxes[0], dict) else [value]
+            for candidate in candidates:
+                if isinstance(candidate, dict):
+                    page_id = candidate.get("page_id") or candidate.get("page")
+                    if page_id is not None:
+                        return f"Page_{page_id}"
+    return "Page_1"
+
+
+def _cloud_extract_value(value: Any) -> Any:
+    if isinstance(value, dict) and "value" in value:
+        return "" if value["value"] is None else value["value"]
+    return "" if value is None else value
+
+
+def _with_local_parse_outputs(result: ParseResult) -> ParseResult:
+    raw_response = result.to_standard_json()
+    return replace(
+        result,
+        raw_response=raw_response,
+        raw_archive=_build_parse_archive(result.markdown, raw_response),
+    )
+
+
+def _build_parse_archive(markdown: str, payload: dict[str, Any]) -> bytes:
+    buffer = io.BytesIO()
+    with zipfile.ZipFile(buffer, "w", compression=zipfile.ZIP_DEFLATED) as archive:
+        archive.writestr("result.md", markdown)
+        archive.writestr(
+            "result.json",
+            json.dumps(payload, ensure_ascii=False, indent=2),
+        )
+    return buffer.getvalue()
+
+
+def _build_llm_extractor(config: dict[str, Any]) -> Any:
+    """Build the local LLM extractor while keeping Task 8 dependency lazy."""
+    module = importlib.import_module("docslight.local.llm_extractor")
+    return module.LocalLLMExtractor(module.provider_from_config(config))
+
+
+class LocalPipeline:
+    """Parse and extract documents using local components."""
+
+    def __init__(
+        self,
+        loader: Any | None = None,
+        parser: Any | None = None,
+        office_loader: Any | None = None,
+        markdown_builder: MarkdownBuilder | None = None,
+        llm_extractor: Any | None = None,
+    ) -> None:
+        self.loader = loader or FileLoader()
+        self.parser = parser or PaddleOCRParser()
+        self.office_loader = office_loader or OfficeMarkdownLoader()
+        self.markdown_builder = markdown_builder or MarkdownBuilder()
+        self.llm_extractor = llm_extractor
+
+    @classmethod
+    def from_config(cls, config: DocSlightConfig) -> LocalPipeline:
+        """Build a local pipeline from SDK configuration."""
+        llm_extractor = None
+        if config.local_llm:
+            try:
+                llm_extractor = _build_llm_extractor(config.local_llm)
+            except ModuleNotFoundError as exc:
+                if exc.name == "docslight.local.llm_extractor":
+                    raise ConfigurationError("local_llm support is not available") from exc
+                raise
+        return cls(llm_extractor=llm_extractor)
+
+    def parse(self, path: Path | str, **options: Any) -> ParseResult:
+        """Parse a local document into Markdown."""
+        source_path = Path(path)
+        suffix = source_path.suffix.lower()
+        if suffix in LEGACY_OFFICE_EXTENSIONS:
+            raise UnsupportedFormatError("Legacy Office files must convert to DOCX, PPTX, or XLSX")
+        if suffix in OFFICE_EXTENSIONS:
+            return self._parse_office(source_path, options)
+        if suffix in RASTER_EXTENSIONS:
+            return self._parse_raster(source_path, suffix, options)
+        raise UnsupportedFormatError(f"Unsupported local format: {suffix or source_path.name}")
+
+    def extract(
+        self,
+        path: Path | str,
+        fields: list[str] | dict[str, Any] | None = None,
+        schema: dict[str, Any] | None = None,
+        document_types: list[str] | None = None,
+        **options: Any,
+    ) -> ExtractResult:
+        """Extract structured data from a local document."""
+        llm_extractor = self.llm_extractor
+        if llm_extractor is None:
+            raise ConfigurationError("local_llm must be configured")
+        parsed = self.parse(path, **options)
+        candidate_options = dict(options)
+        layout_blocks = build_layout_blocks(parsed.pages)
+        if layout_blocks:
+            candidate_options["layout_blocks"] = layout_blocks
+        llm_options = self._supported_llm_options(llm_extractor, candidate_options)
+        extracted = cast(ExtractResult, llm_extractor.extract(
+            parsed.markdown,
+            fields=fields,
+            schema=schema,
+            document_types=document_types,
+            **llm_options,
+        ))
+        return replace(
+            extracted,
+            data=_cloud_extract_result(extracted.data),
+            metadata={**extracted.metadata, **parsed.metadata},
+        )
+
+    def _parse_raster(self, path: Path, suffix: str, options: dict[str, Any]) -> ParseResult:
+        parsed = self.parser.parse(path)
+        document_type = "pdf" if suffix == ".pdf" else "image"
+        metadata = self._merge_metadata(
+            {
+                "engine": "ppstructurev3-local",
+                "mode": "local",
+                "document_type": document_type,
+                "page_count": len(parsed.pages),
+            },
+            {**parsed.metadata, **options},
+        )
+        result = replace(parsed, metadata=metadata)
+        return _with_local_parse_outputs(result)
+
+    def _parse_office(self, path: Path, options: dict[str, Any]) -> ParseResult:
+        document = self.office_loader.load(path)
+        metadata = self._merge_metadata({"mode": "local", **document.metadata}, options)
+        result = ParseResult(markdown=document.markdown, pages=[], metadata=metadata)
+        return _with_local_parse_outputs(result)
+
+    def _merge_metadata(
+        self,
+        base_metadata: dict[str, Any],
+        options: dict[str, Any],
+    ) -> dict[str, Any]:
+        metadata = dict(base_metadata)
+        for key, value in options.items():
+            if key not in metadata:
+                metadata[key] = value
+        return metadata
+
+    def _supported_llm_options(self, llm_extractor: Any, options: dict[str, Any]) -> dict[str, Any]:
+        candidate_options = {
+            key: value for key, value in options.items() if key not in FIXED_LLM_PARAMETERS
+        }
+        signature = inspect.signature(llm_extractor.extract)
+        parameters = signature.parameters
+        if any(parameter.kind == inspect.Parameter.VAR_KEYWORD for parameter in parameters.values()):
+            return candidate_options
+        return {key: value for key, value in candidate_options.items() if key in parameters}

docslight/preview.py

@@ -0,0 +1,46 @@
+"""Preview rendering helpers for the local Web UI."""
+
+from __future__ import annotations
+
+import base64
+from pathlib import Path
+from typing import Any
+
+from docslight.exceptions import DependencyMissingError, LocalProcessingError
+
+PDF_PREVIEW_DEPENDENCY_MESSAGE = (
+    "Install docslight-lite[local] to enable PDF preview rendering."
+)
+
+
+def render_pdf_preview(path: Path, max_pages: int | None = None) -> dict[str, Any]:
+    """Render PDF pages to PNG data URLs for browser overlay highlighting."""
+    try:
+        import fitz  # type: ignore[import-not-found]
+    except ModuleNotFoundError as exc:
+        raise DependencyMissingError(PDF_PREVIEW_DEPENDENCY_MESSAGE) from exc
+
+    pages: list[dict[str, Any]] = []
+    try:
+        with fitz.open(path) as document:
+            page_count = len(document) if max_pages is None else min(len(document), max_pages)
+            for page_index in range(page_count):
+                page = document.load_page(page_index)
+                pixmap = page.get_pixmap(matrix=fitz.Matrix(1, 1), alpha=False)
+                image = base64.b64encode(pixmap.tobytes("png")).decode("ascii")
+                rect = page.rect
+                pages.append(
+                    {
+                        "page_id": page_index + 1,
+                        "page_index": page_index,
+                        "width": float(rect.width),
+                        "height": float(rect.height),
+                        "image": f"data:image/png;base64,{image}",
+                    }
+                )
+    except Exception as exc:
+        if isinstance(exc, DependencyMissingError):
+            raise
+        raise LocalProcessingError("PDF preview rendering failed") from exc
+
+    return {"kind": "pdf", "pages": pages}

docslight/providers/__init__.py

@@ -0,0 +1,6 @@
+"""Provider integrations for document parsing workflows."""
+
+from docslight.providers.ollama import OllamaProvider
+from docslight.providers.openai_compatible import OpenAICompatibleProvider
+
+__all__ = ["OllamaProvider", "OpenAICompatibleProvider"]

docslight/providers/ollama.py

@@ -0,0 +1,30 @@
+"""Ollama local chat completion provider."""
+
+from __future__ import annotations
+
+from docslight.providers.openai_compatible import OpenAICompatibleProvider
+
+
+class OllamaProvider(OpenAICompatibleProvider):
+    """OpenAI-compatible provider configured for Ollama."""
+
+    def __init__(
+        self,
+        model: str,
+        base_url: str = "http://localhost:11434",
+        api_key: str = "ollama",
+        timeout: float = 120.0,
+    ) -> None:
+        super().__init__(
+            model=model,
+            base_url=_normalize_ollama_base_url(base_url),
+            api_key=api_key,
+            timeout=timeout,
+        )
+
+
+def _normalize_ollama_base_url(base_url: str) -> str:
+    normalized = base_url.rstrip("/")
+    if normalized.endswith("/v1"):
+        return normalized
+    return f"{normalized}/v1"

docslight/providers/openai_compatible.py

@@ -0,0 +1,64 @@
+"""OpenAI-compatible chat completion provider."""
+
+from __future__ import annotations
+
+from typing import Any
+
+from docslight.exceptions import DependencyMissingError, LocalProcessingError
+
+INSTALL_LOCAL_LLM_MESSAGE = (
+    "Install local LLM dependencies with: pip install 'docslight-lite[local-llm]'"
+)
+NO_TEXT_CONTENT_MESSAGE = "OpenAI-compatible provider returned no text content"
+REQUEST_FAILED_MESSAGE = "OpenAI-compatible provider request failed"
+
+
+class OpenAICompatibleProvider:
+    """Provider for OpenAI-compatible chat completion APIs."""
+
+    def __init__(
+        self,
+        model: str,
+        base_url: str,
+        api_key: str = "",
+        timeout: float = 120.0,
+        extra_body: dict[str, Any] | None = None,
+    ) -> None:
+        self.model = model
+        self.base_url = base_url
+        self.api_key = api_key
+        self.timeout = timeout
+        self.extra_body = extra_body or {}
+
+    def complete(self, messages: list[dict[str, str]]) -> str:
+        """Return chat completion content from an OpenAI-compatible endpoint."""
+        try:
+            from openai import OpenAI
+        except ImportError as exc:
+            raise DependencyMissingError(INSTALL_LOCAL_LLM_MESSAGE) from exc
+
+        client = OpenAI(
+            api_key=self.api_key,
+            base_url=self.base_url,
+            timeout=self.timeout,
+        )
+        try:
+            request_kwargs: dict[str, Any] = {
+                "model": self.model,
+                "messages": messages,
+                "temperature": 0,
+            }
+            if self.extra_body:
+                request_kwargs["extra_body"] = self.extra_body
+            response = client.chat.completions.create(**request_kwargs)
+        except Exception as exc:
+            raise LocalProcessingError(REQUEST_FAILED_MESSAGE) from exc
+        try:
+            choice = response.choices[0]
+            message = choice.message
+            content: Any = message.content
+        except (AttributeError, IndexError, TypeError) as exc:
+            raise LocalProcessingError(NO_TEXT_CONTENT_MESSAGE) from exc
+        if not isinstance(content, str):
+            raise LocalProcessingError(NO_TEXT_CONTENT_MESSAGE)
+        return content