Trocear documentos con solapamiento

import re
from dataclasses import dataclass


@dataclass
class Trozo:
    doc_id: str
    indice: int
    inicio: int  # posición en el texto original: sirve para citar y para depurar
    fin: int
    texto: str


def _unidades(texto: str, max_chars: int) -> list[tuple[int, int]]:
    """Frases y párrafos como (inicio, fin). Parte por palabras las que no caben."""
    spans = []
    for m in re.finditer(r"\S.*?(?:[.!?](?=\s)|\n\s*\n|$)", texto, re.S):
        ini, fin = m.start(), m.end()
        while fin - ini > max_chars:
            corte = texto.rfind(" ", ini, ini + max_chars)
            if corte <= ini:  # una "palabra" más larga que max_chars
                corte = ini + max_chars
            spans.append((ini, corte))
            ini = corte
            while ini < fin and texto[ini].isspace():
                ini += 1
        if fin > ini:
            spans.append((ini, fin))
    return spans


def _inicio_solape(texto: str, unidades, i: int, j: int, ini: int, max_chars: int, solape: int) -> int:
    """Dónde empieza el trozo siguiente: hasta `solape` caracteres antes del final del actual,
    en un inicio de frase si se puede y, si no, en un inicio de palabra."""
    fin, sig_fin = unidades[j][1], unidades[j + 1][1]
    minimo = max(fin - solape, sig_fin - max_chars, ini + 1)  # que quepa la unidad siguiente
    if minimo >= fin:
        return unidades[j + 1][0]  # sin hueco para solapar
    for u_ini, _ in unidades[i + 1 : j + 1]:
        if minimo <= u_ini < fin:
            return u_ini  # inicio de frase
    espacio = texto.find(" ", minimo, fin)
    if espacio == -1:
        return unidades[j + 1][0]
    pos = espacio + 1
    while pos < fin and texto[pos].isspace():
        pos += 1
    return pos if pos < fin else unidades[j + 1][0]


def trocear(texto: str, doc_id: str, max_chars: int = 1500, solape: int = 200) -> list[Trozo]:
    if solape >= max_chars:
        raise ValueError("El solape debe ser menor que max_chars")
    unidades = _unidades(texto, max_chars)
    trozos: list[Trozo] = []
    i = 0
    ini = unidades[0][0] if unidades else 0
    while i < len(unidades):
        # acumula frases completas mientras quepan en max_chars
        j = i
        while j + 1 < len(unidades) and unidades[j + 1][1] - ini <= max_chars:
            j += 1
        fin = unidades[j][1]
        trozos.append(Trozo(doc_id, len(trozos), ini, fin, texto[ini:fin].strip()))
        if j + 1 == len(unidades):
            break
        ini = _inicio_solape(texto, unidades, i, j, ini, max_chars, solape)
        i = next(n for n in range(i, len(unidades)) if ini < unidades[n][1])
    return trozos


if __name__ == "__main__":
    import sys

    texto = open(sys.argv[1], encoding="utf-8").read()
    for t in trocear(texto, doc_id=sys.argv[1], max_chars=600, solape=120):
        print(f"[{t.indice}] {t.inicio}-{t.fin} ({len(t.texto)} car.) {t.texto[:60]!r}…")

# salida de ejemplo
[0] 0-579 (579 car.) 'El contrato entra en vigor el 1 de enero de 2026. Las partes…'…
[1] 466-1008 (542 car.) 'Las partes acuerdan revisar las tarifas cada doce meses. En…'…
[2] 951-1548 (597 car.) 'En caso de impago, el proveedor podrá suspender el servicio…'…

from trocear import trocear

texto = open("doc.txt", encoding="utf-8").read()
trozos = trocear(texto, "doc", max_chars=600, solape=120)

cubierto = [False] * len(texto)
for t in trozos:
    assert len(t.texto) <= 600
    assert texto[t.inicio : t.fin].strip() == t.texto
    for p in range(t.inicio, t.fin):
        cubierto[p] = True
assert all(cubierto[p] or texto[p].isspace() for p in range(len(texto)))
print(f"{len(trozos)} trozos, todo cubierto")