File size: 3,464 Bytes
68e8c03
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
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
93
94
95
"""Carregamento e extração de texto de arquivos PDF com tratamento de erros."""

from dataclasses import dataclass
from io import BytesIO
from pathlib import Path
from typing import BinaryIO

from pypdf import PdfReader
from pypdf.errors import PdfReadError


@dataclass(frozen=True)
class DocumentPage:
    """Representa o conteúdo extraído de uma única página de PDF."""

    text: str
    source: str
    page: int


class DocumentLoadError(Exception):
    """Erro levantado quando um arquivo PDF não pode ser lido ou está vazio."""


def load_pdf(
    file_source: str | Path | BinaryIO,
    filename: str | None = None,
    max_size_mb: int = 20,
) -> list[DocumentPage]:
    """Extrai o texto de cada página de um PDF, preservando nome do arquivo e página.

    Args:
        file_source: Caminho do arquivo no disco ou objeto binário em memória (ex.: UploadedFile).
        filename: Nome de exibição do arquivo. Obrigatório quando file_source não for um caminho.
        max_size_mb: Tamanho máximo permitido em megabytes.

    Returns:
        Lista de DocumentPage com texto não vazio.

    Raises:
        DocumentLoadError: Se o arquivo estiver vazio, exceder o limite, corrompido ou sem texto.
    """
    max_bytes = max_size_mb * 1024 * 1024
    source_name = filename
    if isinstance(file_source, (str, Path)):
        path = Path(file_source)
        if not path.exists() or not path.is_file():
            raise DocumentLoadError(f"Arquivo não encontrado: {path}")
        file_size = path.stat().st_size
        if file_size == 0:
            raise DocumentLoadError(f"O arquivo '{path.name}' está vazio.")
        if file_size > max_bytes:
            raise DocumentLoadError(
                f"O arquivo '{path.name}' excede o limite de {max_size_mb} MB."
            )
        source_name = source_name or path.name
        stream: BinaryIO | Path = path
    else:
        source_name = source_name or getattr(file_source, "name", "documento.pdf")
        raw_bytes = file_source.read()
        if not raw_bytes:
            raise DocumentLoadError(f"O arquivo '{source_name}' está vazio.")
        if len(raw_bytes) > max_bytes:
            raise DocumentLoadError(
                f"O arquivo '{source_name}' excede o limite de {max_size_mb} MB."
            )
        stream = BytesIO(raw_bytes)

    try:
        reader = PdfReader(stream)
    except (PdfReadError, Exception) as exc:
        raise DocumentLoadError(f"Não foi possível ler o PDF '{source_name}': arquivo inválido ou corrompido.") from exc

    if reader.is_encrypted:
        try:
            # Tenta descriptografar com senha vazia (comum em PDFs protegidos apenas contra edição)
            if reader.decrypt("") == 0:
                raise DocumentLoadError(f"O PDF '{source_name}' está protegido por senha.")
        except Exception as exc:
            raise DocumentLoadError(f"O PDF '{source_name}' está protegido por senha.") from exc

    pages: list[DocumentPage] = []
    for page_number, page in enumerate(reader.pages, start=1):
        extracted = (page.extract_text() or "").strip()
        if extracted:
            pages.append(DocumentPage(text=extracted, source=source_name, page=page_number))

    if not pages:
        raise DocumentLoadError(
            f"Nenhum texto extraível foi encontrado em '{source_name}'. "
            "Verifique se o PDF não é apenas uma imagem digitalizada."
        )

    return pages