File size: 3,493 Bytes
f65336d
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
"""Validate embedded PDFs and render their pages inside the request encoder."""

from __future__ import annotations

from typing import TYPE_CHECKING

if TYPE_CHECKING:
    from PIL import Image

import base64
import binascii
import math
import re

from .embedded import MAX_IMAGE_BYTES, MAX_IMAGES
from pydantic import BaseModel, ConfigDict, StrictStr, model_validator


class ClairDocument(BaseModel):
    model_config = ConfigDict(extra="forbid", frozen=True)

    content_type: StrictStr
    base64: StrictStr

    @model_validator(mode="before")
    @classmethod
    def parse_document(cls, value: object) -> dict[str, str]:
        if isinstance(value, str):
            match = re.fullmatch(
                r"data:application/pdf;base64,([A-Za-z0-9+/]*={0,2})",
                value,
                re.IGNORECASE,
            )
            if match is None:
                raise ValueError("document must be an embedded PDF data URI")
            value = {"content_type": "application/pdf", "base64": match[1]}
        if type(value) is not dict or set(value) != {"content_type", "base64"}:
            raise ValueError("document object must contain content_type and base64")
        if value["content_type"] != "application/pdf" or not isinstance(
            value["base64"], str
        ):
            raise ValueError("document content type must be application/pdf")
        try:
            data = base64.b64decode(value["base64"], validate=True)
        except (binascii.Error, ValueError) as error:
            raise ValueError("document base64 is malformed") from error
        if not data.startswith(b"%PDF-") or len(data) > MAX_IMAGE_BYTES:
            raise ValueError("document must be a PDF within the decoded byte limit")
        return {
            "content_type": "application/pdf",
            "base64": base64.b64encode(data).decode("ascii"),
        }

    def render(self, available_pages: int = MAX_IMAGES) -> list[Image.Image]:
        import pypdfium2 as pdfium

        from .orientation import orient_document

        try:
            pdf = pdfium.PdfDocument(base64.b64decode(self.base64))
            try:
                if not 0 < len(pdf) <= available_pages:
                    raise ValueError(
                        f"PDF pages and images together must not exceed {MAX_IMAGES}"
                    )
                images = []
                for index in range(len(pdf)):
                    page = pdf[index]
                    try:
                        width, height = page.get_size()
                        if not (
                            math.isfinite(width * height) and width > 0 and height > 0
                        ):
                            raise ValueError("PDF page has invalid dimensions")
                        scale = min(2.0, math.sqrt(4_000_000 / (width * height)))
                        bitmap = page.render(scale=scale)
                        try:
                            images.append(
                                orient_document(bitmap.to_pil().convert("RGB"))
                            )
                        finally:
                            bitmap.close()
                    finally:
                        page.close()
                return images
            finally:
                pdf.close()
        except pdfium.PdfiumError as error:
            raise ValueError(
                "PDF cannot be opened or rendered; encrypted PDFs are unsupported"
            ) from error