289 lines
10 KiB
Python
289 lines
10 KiB
Python
"""Parser do texto bíblico: reconstrói livro, capítulo e versículo.
|
||
|
||
O PDF do projeto (Almeida Revista e Corrigida) traz o índice com a página inicial de
|
||
cada livro, capítulos no formato `[N]` e versículos numerados no início da linha.
|
||
O parser usa o índice quando disponível e cai para o cabeçalho da página quando não.
|
||
"""
|
||
|
||
from __future__ import annotations
|
||
|
||
import re
|
||
import unicodedata
|
||
from dataclasses import dataclass
|
||
from typing import Iterable, Mapping
|
||
|
||
from .extraction import PageText
|
||
|
||
# Os livros canônicos presentes nesta edição da Almeida (L.C.C./eBooksBrasil).
|
||
# A edição não inclui Neemias nem Ester: o índice do PDF vai de Esdras (p. 1407)
|
||
# direto para Jó (p. 1440), e as páginas 1407–1439 são o livro de Esdras.
|
||
BOOKS: tuple[str, ...] = (
|
||
# Antigo Testamento
|
||
"Gênesis", "Êxodo", "Levítico", "Números", "Deuteronômio", "Josué", "Juízes",
|
||
"Rute", "I Samuel", "II Samuel", "I Reis", "II Reis", "I Crônicas",
|
||
"II Crônicas", "Esdras", "Jó", "Salmos", "Provérbios",
|
||
"Eclesiastes", "Cântico dos Cânticos", "Isaias", "Jeremias", "Lamentações",
|
||
"Ezequiel", "Daniel", "Oséias", "Joel", "Amós", "Abdias", "Jonas", "Miqueias",
|
||
"Naum", "Habacuque", "Sofonias", "Ageu", "Zacarias", "Malaquias",
|
||
# Novo Testamento
|
||
"Mateus", "Marcos", "Lucas", "João", "Atos", "Romanos", "I Coríntios",
|
||
"II Coríntios", "Galatas", "Efésios", "Filipenses", "Colossenses",
|
||
"I Tessalonicenses", "II Tessalonicenses", "I Timóteo", "II Timóteo", "Tito",
|
||
"Filemom", "Hebreus", "Tiago", "I Pedro", "II Pedro", "I João", "II João",
|
||
"III João", "Judas", "Apocalipse",
|
||
)
|
||
|
||
# Variantes de grafia encontradas em digitalizações e em transcrições.
|
||
BOOK_ALIASES: dict[str, str] = {
|
||
"Lamentações de Jeremias": "Lamentações",
|
||
"Cânticos": "Cântico dos Cânticos",
|
||
"Cântico dos Canticos": "Cântico dos Cânticos",
|
||
"Salmo": "Salmos",
|
||
"Provérbios": "Provérbios",
|
||
"Eclesiastes": "Eclesiastes",
|
||
"Apocalipse": "Apocalipse",
|
||
"Coríntios I": "I Coríntios",
|
||
"Coríntios II": "II Coríntios",
|
||
"Tessalonicenses I": "I Tessalonicenses",
|
||
"Tessalonicenses II": "II Tessalonicenses",
|
||
"Timóteo I": "I Timóteo",
|
||
"Timóteo II": "II Timóteo",
|
||
"Pedro I": "I Pedro",
|
||
"Pedro II": "II Pedro",
|
||
"João I": "I João",
|
||
"João II": "II João",
|
||
"João III": "III João",
|
||
"Samuel I": "I Samuel",
|
||
"Samuel II": "II Samuel",
|
||
"Reis I": "I Reis",
|
||
"Reis II": "II Reis",
|
||
"Crônicas I": "I Crônicas",
|
||
"Crônicas II": "II Crônicas",
|
||
}
|
||
|
||
# Livros do canoneto completo ausentes nesta edição (Neemias, Ester). Não são
|
||
# reconhecidos, para que páginas de outras edições não sejam atribuídas a eles.
|
||
_OPTIONAL_BOOKS: tuple[str, ...] = ()
|
||
|
||
|
||
def _normalize(text: str) -> str:
|
||
"""Remove acentos e normaliza espaços, para comparação tolerante."""
|
||
decomposed = unicodedata.normalize("NFKD", text)
|
||
stripped = "".join(ch for ch in decomposed if not unicodedata.combining(ch))
|
||
return re.sub(r"\s+", " ", stripped).strip().casefold()
|
||
|
||
|
||
_NORMALIZED_BOOKS: dict[str, str] = {_normalize(name): name for name in BOOKS}
|
||
for _alias, _canonical in BOOK_ALIASES.items():
|
||
_NORMALIZED_BOOKS[_normalize(_alias)] = _canonical
|
||
|
||
|
||
def canonical_book(name: str) -> str | None:
|
||
"""Devolve o nome canônico do livro, ou None se não reconhecido."""
|
||
return _NORMALIZED_BOOKS.get(_normalize(name))
|
||
|
||
|
||
@dataclass(frozen=True)
|
||
class VerseChunk:
|
||
"""Um versículo indexável com seus metadados de origem."""
|
||
|
||
book: str
|
||
chapter: int
|
||
verse: int
|
||
page: int
|
||
file: str
|
||
text: str
|
||
|
||
@property
|
||
def reference(self) -> str:
|
||
"""Referência no formato `Livro Capítulo:Versículo`."""
|
||
return f"{self.book} {self.chapter}:{self.verse}"
|
||
|
||
@property
|
||
def chunk_id(self) -> str:
|
||
"""ID determinístico do chunk no banco vetorial."""
|
||
import hashlib
|
||
|
||
key = f"{self.file}|{self.book}|{self.chapter}|{self.verse}"
|
||
return hashlib.sha1(key.encode("utf-8")).hexdigest()
|
||
|
||
|
||
_CHAPTER_RE = re.compile(r"^\[\s*(\d{1,3})\s*\]$")
|
||
_CHAPTER_TEXT_RE = re.compile(r"^(?:CAP[ÍI]TULO|Chapter)\s+(\d{1,3})$", re.IGNORECASE)
|
||
_VERSE_RE = re.compile(r"^(\d{1,3})\s+(.*)$")
|
||
_VERSE_ONLY_RE = re.compile(r"^(\d{1,3})$")
|
||
_INDEX_ENTRY_RE = re.compile(r"^\s*([^:]{2,40}?)\s*:\s*(\d{1,5})\s*$")
|
||
_HYPHEN_END_RE = re.compile(r"(\w)-\s*$")
|
||
_HYPHEN_START_RE = re.compile(r"^\s*(\w)")
|
||
|
||
|
||
def parse_book_index(text: str) -> dict[str, int]:
|
||
"""Extrai `{livro: página_inicial}` do índice de um PDF de Bíblia.
|
||
|
||
Formato esperado (o do PDF do projeto):
|
||
|
||
ANTIGO TESTAMENTO: 5
|
||
Gênesis: 6
|
||
Êxodo: 168
|
||
"""
|
||
starts: dict[str, int] = {}
|
||
for raw_line in text.splitlines():
|
||
line = raw_line.strip()
|
||
if not line:
|
||
continue
|
||
match = _INDEX_ENTRY_RE.match(line)
|
||
if not match:
|
||
continue
|
||
name, page = match.group(1).strip(), int(match.group(2))
|
||
if "TESTAMENTO" in name.upper():
|
||
continue
|
||
canonical = canonical_book(name)
|
||
if canonical is None:
|
||
continue
|
||
starts[canonical] = page
|
||
return starts
|
||
|
||
|
||
def _join_hyphenated(previous: str, following: str) -> str:
|
||
"""Religa palavra hifenizada no fim da linha.
|
||
|
||
`esconde-` + `me.` vira `escondeme.`. Hifens lexicais (não no fim da linha)
|
||
permanecem intactos.
|
||
"""
|
||
match = _HYPHEN_END_RE.search(previous)
|
||
if not match:
|
||
return f"{previous} {following}".strip()
|
||
tail = _HYPHEN_START_RE.match(following)
|
||
if not tail:
|
||
return f"{previous} {following}".strip()
|
||
word = match.group(1)
|
||
continuation = tail.group(1)
|
||
return f"{previous[: match.start(1)]}{word}{continuation}{following[tail.end(1):]}"
|
||
|
||
|
||
class BibleParser:
|
||
"""Converte páginas extraídas em uma lista de versículos."""
|
||
|
||
def __init__(self) -> None:
|
||
self._books = tuple(BOOKS) + _OPTIONAL_BOOKS
|
||
|
||
def book_for_page(
|
||
self, page: int, book_starts: Mapping[str, int]
|
||
) -> str | None:
|
||
"""Livro ao qual a página pertence, pela faixa do índice.
|
||
|
||
A página pertence ao último livro cujo início é menor ou igual a ela.
|
||
"""
|
||
if not book_starts:
|
||
return None
|
||
candidates = [(start, book) for book, start in book_starts.items() if start <= page]
|
||
if not candidates:
|
||
return None
|
||
return max(candidates, key=lambda item: item[0])[1]
|
||
|
||
def parse(
|
||
self,
|
||
pages: Iterable[PageText],
|
||
file_name: str,
|
||
book_starts: Mapping[str, int] | None = None,
|
||
) -> list[VerseChunk]:
|
||
"""Converte as páginas do documento em versículos indexáveis."""
|
||
book_starts = book_starts or {}
|
||
chunks: list[VerseChunk] = []
|
||
|
||
current_book: str | None = None
|
||
current_chapter = 0
|
||
current_verse = 0
|
||
current_text: list[str] = []
|
||
current_page = 0
|
||
|
||
def flush() -> None:
|
||
nonlocal current_text
|
||
if current_book and current_chapter and current_verse and current_text:
|
||
text = " ".join(part for part in current_text if part).strip()
|
||
if text:
|
||
chunks.append(
|
||
VerseChunk(
|
||
book=current_book,
|
||
chapter=current_chapter,
|
||
verse=current_verse,
|
||
page=current_page,
|
||
file=file_name,
|
||
text=text,
|
||
)
|
||
)
|
||
current_text = []
|
||
|
||
for page in pages:
|
||
page_book = self.book_for_page(page.page, book_starts)
|
||
lines = page.text.splitlines()
|
||
header_book = self._detect_header_book(lines)
|
||
|
||
if page_book is None and header_book is None:
|
||
# Página fora de qualquer livro (índice, copyright): descarta.
|
||
flush()
|
||
current_book = None
|
||
current_chapter = 0
|
||
current_verse = 0
|
||
continue
|
||
|
||
if page_book is not None:
|
||
if current_book != page_book:
|
||
flush()
|
||
current_book = page_book
|
||
current_chapter = 0
|
||
current_verse = 0
|
||
elif header_book is not None:
|
||
if current_book != header_book:
|
||
flush()
|
||
current_book = header_book
|
||
current_chapter = 0
|
||
current_verse = 0
|
||
|
||
current_page = page.page
|
||
|
||
for raw_line in lines:
|
||
line = raw_line.strip()
|
||
if not line:
|
||
continue
|
||
|
||
chapter_match = _CHAPTER_RE.match(line) or _CHAPTER_TEXT_RE.match(line)
|
||
if chapter_match:
|
||
flush()
|
||
current_chapter = int(chapter_match.group(1))
|
||
current_verse = 0
|
||
continue
|
||
|
||
verse_match = _VERSE_RE.match(line)
|
||
if verse_match and current_chapter:
|
||
flush()
|
||
current_verse = int(verse_match.group(1))
|
||
current_text = [verse_match.group(2).strip()]
|
||
continue
|
||
|
||
verse_only = _VERSE_ONLY_RE.match(line)
|
||
if verse_only and current_chapter:
|
||
flush()
|
||
current_verse = int(verse_only.group(1))
|
||
current_text = []
|
||
continue
|
||
|
||
if current_verse and current_text:
|
||
current_text[-1] = _join_hyphenated(current_text[-1], line)
|
||
elif current_verse:
|
||
current_text.append(line)
|
||
|
||
flush()
|
||
return chunks
|
||
|
||
def _detect_header_book(self, lines: list[str]) -> str | None:
|
||
"""Procura o nome do livro nas primeiras linhas da página."""
|
||
for raw_line in lines[:5]:
|
||
candidate = raw_line.strip()
|
||
if not candidate or len(candidate) > 40:
|
||
continue
|
||
canonical = canonical_book(candidate)
|
||
if canonical is not None:
|
||
return canonical
|
||
return None
|