csf-scraper-python 0.1.1__py3-none-any.whl

csf_scraper/__init__.py

@@ -0,0 +1,119 @@
+"""Obtiene los datos fiscales actuales de una persona moral o física del SAT.
+
+El núcleo de la librería no depende de ningún cliente de LLM. Los adaptadores
+que sí lo requieren (por ahora :class:`GeminiImageReader`, que necesita el
+extra ``llm-gemini``) se resuelven de forma perezosa (:pep:`562`), de modo que
+``import csf_scraper`` funciona con las dependencias base únicamente.
+"""
+
+from typing import TYPE_CHECKING
+
+from csf_scraper.data_extractor import DataExtractor
+from csf_scraper.exceptions import (
+    CifDownloadException,
+    CifNotFoundException,
+    CsfScraperException,
+)
+from csf_scraper.exceptions.image_reader import (
+    CifFromImageNotFoundException,
+    ImageExtractorNotConfiguredException,
+    ImageReaderApiException,
+    ImageReaderAuthenticationException,
+    ImageReaderUnavailableException,
+    ImageReadingException,
+    InvalidImageException,
+    InvalidImageFormatException,
+    RfcFromImageNotFoundException,
+)
+from csf_scraper.exceptions.pdf_reader import (
+    CifFromPdfNotFoundException,
+    EmptyPdfContentException,
+    PdfToTextConvertException,
+    RfcFromPdfNotFoundException,
+)
+from csf_scraper.exceptions.value_objects import (
+    InvalidIdCifFormatException,
+    InvalidRfcFormatException,
+)
+from csf_scraper.image_readers import (
+    CSF_PROMPT,
+    MAX_RETRIES,
+    MAX_RETRY_BACKOFF,
+    RETRY_BACKOFF,
+    RETRY_PROMPT,
+    CsfImageExtractor,
+    ImageReaderPort,
+    LlmImageReaderService,
+    RfcCifSchema,
+)
+from csf_scraper.pdf_reader import CsfPdfExtractor, PdfCsfTextParser, PdfTextProvider
+from csf_scraper.persona import Persona
+from csf_scraper.persona_fisica import PersonaFisica
+from csf_scraper.persona_moral import PersonaMoral
+from csf_scraper.ports import RfcCifExtractorPort
+from csf_scraper.regimen import Regimen
+from csf_scraper.rfc_cif_data import RfcCifData
+from csf_scraper.scraper import Scraper
+from csf_scraper.value_objects import CsfImage, IdCif, Rfc
+
+if TYPE_CHECKING:
+    from csf_scraper.image_readers.adapters.llms import GeminiImageReader
+
+__all__ = [
+    "CSF_PROMPT",
+    "MAX_RETRIES",
+    "MAX_RETRY_BACKOFF",
+    "RETRY_BACKOFF",
+    "RETRY_PROMPT",
+    "CifDownloadException",
+    "CifFromImageNotFoundException",
+    "CifFromPdfNotFoundException",
+    "CifNotFoundException",
+    "CsfImage",
+    "CsfImageExtractor",
+    "CsfPdfExtractor",
+    "CsfScraperException",
+    "DataExtractor",
+    "EmptyPdfContentException",
+    "GeminiImageReader",
+    "IdCif",
+    "ImageExtractorNotConfiguredException",
+    "ImageReaderApiException",
+    "ImageReaderAuthenticationException",
+    "ImageReaderPort",
+    "ImageReaderUnavailableException",
+    "ImageReadingException",
+    "InvalidIdCifFormatException",
+    "InvalidImageException",
+    "InvalidImageFormatException",
+    "InvalidRfcFormatException",
+    "LlmImageReaderService",
+    "PdfCsfTextParser",
+    "PdfTextProvider",
+    "PdfToTextConvertException",
+    "Persona",
+    "PersonaFisica",
+    "PersonaMoral",
+    "Regimen",
+    "Rfc",
+    "RfcCifData",
+    "RfcCifExtractorPort",
+    "RfcCifSchema",
+    "RfcFromImageNotFoundException",
+    "RfcFromPdfNotFoundException",
+    "Scraper",
+]
+
+
+def __getattr__(name: str) -> object:
+    """Resuelve los adaptadores opcionales de forma perezosa.
+
+    Así ``from csf_scraper import GeminiImageReader`` sigue funcionando, pero
+    solo importa el SDK de Google cuando alguien realmente lo pide.
+    """
+    if name == "GeminiImageReader":
+        from csf_scraper.image_readers.adapters.llms import GeminiImageReader
+
+        return GeminiImageReader
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

csf_scraper/data_extractor.py

@@ -0,0 +1,74 @@
+"""Extracción de datos fiscales a partir del HTML de la consulta del CSF."""
+
+from bs4 import BeautifulSoup, Tag
+
+from csf_scraper.exceptions import CifNotFoundException
+from csf_scraper.persona_fisica import PersonaFisica
+from csf_scraper.persona_moral import PersonaMoral
+from csf_scraper.regimen import Regimen
+
+_XML_DECLARATION = '<?xml version="1.0" encoding="UTF-8" ?>'
+
+
+def _normalize_whitespace(value: str) -> str:
+    """Colapsa cualquier espacio en blanco en un único espacio y recorta los extremos."""
+    return " ".join(value.split())
+
+
+class DataExtractor:
+    """Extrae los datos de una persona desde el HTML de la consulta del CSF."""
+
+    def __init__(self, html: str) -> None:
+        self.html = html
+
+    def extract(self, is_fisica: bool) -> PersonaMoral | PersonaFisica:
+        """Construye la persona correspondiente; lanza :class:`CifNotFoundException`."""
+        person: PersonaMoral | PersonaFisica = PersonaFisica() if is_fisica else PersonaMoral()
+        soup = BeautifulSoup(self._clear_html(self.html), "lxml")
+
+        if soup.select("span[class=ui-messages-info-detail]"):
+            raise CifNotFoundException("Failed to found CIF info.")
+
+        fields = type(person).model_fields
+        for field, title in person.field_titles.items():
+            value = self._find_value(soup, title)
+            if field in fields:
+                setattr(person, field, value)
+            else:
+                person.extra_data[field] = value
+
+        person.regimenes = self._get_regimenes(soup)
+        return person
+
+    def _find_value(self, soup: BeautifulSoup, title: str) -> str:
+        for element in soup.select('td[role="gridcell"] > span'):
+            if title not in _normalize_whitespace(element.get_text()):
+                continue
+            row = element.find_parent("tr")
+            text = _normalize_whitespace(row.get_text()) if isinstance(row, Tag) else ""
+            return text.replace(title, " ").strip()
+        return ""
+
+    @staticmethod
+    def _clear_html(html: str) -> str:
+        return html.replace(_XML_DECLARATION, "")
+
+    @staticmethod
+    def _get_regimenes(soup: BeautifulSoup) -> list[Regimen]:
+        tables = soup.select('tbody[class="ui-datatable-data ui-widget-content"]')
+        if len(tables) < 5:
+            return []
+
+        values = [
+            _normalize_whitespace(cell.get_text())
+            for cell in tables[4].select('td[role="gridcell"]')
+            if not cell.select("span")
+        ]
+
+        regimenes: list[Regimen] = []
+        for index in range(0, len(values), 2):
+            regimen = Regimen(regimen=values[index])
+            if index + 1 < len(values):
+                regimen.fecha_alta = values[index + 1]  # type: ignore[assignment]
+            regimenes.append(regimen)
+        return regimenes

csf_scraper/date_parser.py

@@ -0,0 +1,26 @@
+"""Conversión de fechas ``dd-mm-yyyy`` a :class:`datetime.datetime`."""
+
+from datetime import datetime
+from typing import Annotated, Any
+
+from pydantic import BeforeValidator
+
+
+def parse_date(value: str) -> datetime | None:
+    """Convierte una fecha ``dd-mm-yyyy`` a la medianoche; ``None`` si es inválida."""
+    try:
+        return datetime.strptime(value, "%d-%m-%Y")
+    except (TypeError, ValueError):
+        return None
+
+
+def _coerce_date(value: Any) -> datetime | None:
+    if value is None or isinstance(value, datetime):
+        return value
+    if isinstance(value, str):
+        return parse_date(value)
+    return None
+
+
+#: Campo de fecha opcional que acepta ``datetime``, ``None`` o una cadena ``dd-mm-yyyy``.
+DateField = Annotated[datetime | None, BeforeValidator(_coerce_date)]

csf_scraper/exceptions/__init__.py

@@ -0,0 +1,17 @@
+"""Excepciones de la librería."""
+
+
+class CsfScraperException(Exception):
+    """Tipo base de todas las excepciones de la librería."""
+
+
+class CifDownloadException(CsfScraperException):
+    """La petición HTTP para descargar la información del CIF falló."""
+
+    def __init__(self, url: str) -> None:
+        super().__init__("The request has failed")
+        self.url = url
+
+
+class CifNotFoundException(CsfScraperException):
+    """No se encontró la información del CIF en la respuesta del SAT."""

csf_scraper/exceptions/image_reader.py

@@ -0,0 +1,106 @@
+"""Excepciones del lector de imágenes (CSF escaneada)."""
+
+from csf_scraper.exceptions import CsfScraperException
+
+
+class InvalidImageException(CsfScraperException):
+    """La ruta de la imagen no existe o no puede leerse."""
+
+
+class InvalidImageFormatException(CsfScraperException):
+    """El archivo recibido no es una imagen soportada (JPEG o PNG)."""
+
+
+class ImageExtractorNotConfiguredException(CsfScraperException):
+    """No se inyectó un extractor de imágenes (motor LLM/OCR)."""
+
+    def __init__(self) -> None:
+        super().__init__(
+            "An image extractor is required to obtain the data from an image; "
+            "inject one via Scraper(..., image_extractor=...).",
+        )
+
+
+class ImageReadingException(CsfScraperException):
+    """El motor de lectura de imágenes (LLM/OCR) falló al procesar la CSF.
+
+    ``provider`` y ``model`` identifican el motor que falló, de modo que un
+    adaptador pueda reportar el origen del error sin exponer credenciales.
+    """
+
+    def __init__(
+        self,
+        message: str = "The image reader failed to process the CSF.",
+        *,
+        provider: str | None = None,
+        model: str | None = None,
+    ) -> None:
+        super().__init__(message)
+        self.provider = provider
+        self.model = model
+
+
+class ImageReaderApiException(ImageReadingException):
+    """La API del proveedor del modelo respondió con un error.
+
+    Es la traducción propia de las excepciones de cada proveedor: el resto de
+    la librería no importa ni conoce las librerías de Gemini, OpenAI, etc.
+
+    ``status_code`` es el código HTTP devuelto por el proveedor (``None`` si no
+    hubo respuesta, por ejemplo en un fallo de red) y ``retryable`` indica si
+    vale la pena volver a intentarlo: los fallos temporales (saturación,
+    indisponibilidad, límite de peticiones, red) sí lo son; los de credenciales
+    o de petición mal formada, no.
+    """
+
+    def __init__(
+        self,
+        message: str = "The model provider API returned an error.",
+        *,
+        provider: str | None = None,
+        model: str | None = None,
+        status_code: int | None = None,
+        retryable: bool = False,
+    ) -> None:
+        super().__init__(message, provider=provider, model=model)
+        self.status_code = status_code
+        self.retryable = retryable
+
+
+class ImageReaderUnavailableException(ImageReaderApiException):
+    """El servicio del proveedor está saturado, caído o no es alcanzable.
+
+    Siempre es reintentable: la misma imagen y las mismas credenciales pueden
+    funcionar una vez que el proveedor se recupere.
+    """
+
+    def __init__(
+        self,
+        message: str = "The model provider is temporarily unavailable.",
+        *,
+        provider: str | None = None,
+        model: str | None = None,
+        status_code: int | None = None,
+    ) -> None:
+        super().__init__(
+            message,
+            provider=provider,
+            model=model,
+            status_code=status_code,
+            retryable=True,
+        )
+
+
+class ImageReaderAuthenticationException(ImageReaderApiException):
+    """El proveedor rechazó las credenciales (API key inválida, vencida o sin permiso).
+
+    No es reintentable: repetir la petición con la misma clave fallará igual.
+    """
+
+
+class RfcFromImageNotFoundException(CsfScraperException):
+    """No se pudo obtener el RFC de la imagen procesada."""
+
+
+class CifFromImageNotFoundException(CsfScraperException):
+    """No se pudo obtener el idCIF de la imagen procesada."""

csf_scraper/exceptions/pdf_reader.py

@@ -0,0 +1,33 @@
+"""Excepciones del lector de PDF."""
+
+from csf_scraper.exceptions import CsfScraperException
+
+
+class CifFromPdfNotFoundException(CsfScraperException):
+    """No se pudo obtener el idCIF del PDF procesado."""
+
+
+class EmptyPdfContentException(CsfScraperException):
+    """El contenido del PDF está vacío."""
+
+
+class RfcFromPdfNotFoundException(CsfScraperException):
+    """No se pudo obtener el RFC del PDF procesado."""
+
+
+class PdfToTextConvertException(CsfScraperException):
+    """La ejecución de ``pdftotext`` falló."""
+
+    def __init__(
+        self,
+        message: str,
+        command: list[str],
+        exit_code: int,
+        output: str,
+        error: str,
+    ) -> None:
+        super().__init__(message)
+        self.command = command
+        self.exit_code = exit_code
+        self.output = output
+        self.error = error

csf_scraper/exceptions/value_objects.py

@@ -0,0 +1,11 @@
+"""Excepciones de los value objects del dominio."""
+
+from csf_scraper.exceptions import CsfScraperException
+
+
+class InvalidRfcFormatException(CsfScraperException, ValueError):
+    """El valor recibido no corresponde al formato de un RFC."""
+
+
+class InvalidIdCifFormatException(CsfScraperException, ValueError):
+    """El valor recibido no corresponde al formato de un idCIF."""

csf_scraper/image_readers/__init__.py

@@ -0,0 +1,52 @@
+"""Lectura de imágenes de la Constancia de Situación Fiscal.
+
+El paquete base solo expone el puerto, el adaptador de ruta y la base de los
+lectores LLM. :class:`GeminiImageReader` vive en
+``csf_scraper.image_readers.adapters`` y requiere el extra ``llm-gemini``, por
+eso se resuelve de forma perezosa (:pep:`562`).
+"""
+
+from typing import TYPE_CHECKING
+
+from csf_scraper.image_readers.csf_image_extractor import CsfImageExtractor
+from csf_scraper.image_readers.ports import ImageReaderPort
+from csf_scraper.image_readers.schemas import RfcCifSchema
+from csf_scraper.image_readers.services import (
+    CSF_PROMPT,
+    MAX_RETRIES,
+    MAX_RETRY_BACKOFF,
+    RETRY_BACKOFF,
+    RETRY_PROMPT,
+    LlmImageReaderService,
+)
+
+if TYPE_CHECKING:
+    from csf_scraper.image_readers.adapters.llms import GeminiImageReader
+
+__all__ = [
+    "CSF_PROMPT",
+    "MAX_RETRIES",
+    "MAX_RETRY_BACKOFF",
+    "RETRY_BACKOFF",
+    "RETRY_PROMPT",
+    "CsfImageExtractor",
+    "GeminiImageReader",
+    "ImageReaderPort",
+    "LlmImageReaderService",
+    "RfcCifSchema",
+]
+
+
+def __getattr__(name: str) -> object:
+    """Resuelve :class:`GeminiImageReader` de forma perezosa.
+
+    Mantiene el import base libre de ``google-genai`` y de
+    ``llama-index-llms-google-genai``; si se pide sin el extra ``llm-gemini``
+    se propaga el ``ModuleNotFoundError`` del paquete faltante.
+    """
+    if name == "GeminiImageReader":
+        from csf_scraper.image_readers.adapters.llms import GeminiImageReader
+
+        return GeminiImageReader
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

csf_scraper/image_readers/adapters/__init__.py

@@ -0,0 +1,18 @@
+"""Adaptadores de los lectores de imagen."""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from csf_scraper.image_readers.adapters.llms import GeminiImageReader
+
+__all__ = ["GeminiImageReader"]
+
+
+def __getattr__(name: str) -> object:
+    """Reexporta los adaptadores concretos de forma perezosa."""
+    if name == "GeminiImageReader":
+        from csf_scraper.image_readers.adapters.llms import GeminiImageReader
+
+        return GeminiImageReader
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

csf_scraper/image_readers/adapters/llms/__init__.py

@@ -0,0 +1,33 @@
+"""Adaptadores de lectura de imágenes basados en LLMs multimodales.
+
+Este paquete es el único lugar de la librería que conoce el SDK de un
+proveedor concreto. Por eso **no** se importa ningún adaptador al cargar el
+paquete: :class:`GeminiImageReader` requiere el extra ``llm-gemini`` y debe
+resolverse solo cuando se usa (:pep:`562`), para que ``import csf_scraper``
+funcione sin instalar extras.
+"""
+
+from typing import TYPE_CHECKING
+
+if TYPE_CHECKING:
+    from csf_scraper.image_readers.adapters.llms.gemini_image_reader import (
+        GeminiImageReader,
+    )
+
+__all__ = ["GeminiImageReader"]
+
+
+def __getattr__(name: str) -> object:
+    """Resuelve :class:`GeminiImageReader` de forma perezosa.
+
+    Levanta ``ModuleNotFoundError`` (del paquete ``llama-index-llms-google-genai``)
+    si se pide el adaptador sin haber instalado el extra ``llm-gemini``.
+    """
+    if name == "GeminiImageReader":
+        from csf_scraper.image_readers.adapters.llms.gemini_image_reader import (
+            GeminiImageReader,
+        )
+
+        return GeminiImageReader
+
+    raise AttributeError(f"module {__name__!r} has no attribute {name!r}")

csf_scraper/image_readers/adapters/llms/gemini_image_reader.py

@@ -0,0 +1,157 @@
+"""Adaptador del lector de imágenes basado en Gemini (Google GenAI).
+
+Aquí sí se importan las librerías de LlamaIndex y del SDK de Google, porque el
+transporte hacia el proveedor es responsabilidad exclusiva del adaptador::
+
+    from llama_index.llms.google_genai import GoogleGenAI
+
+    reader = GeminiImageReader(api_key="…", model_name="gemini-2.5-flash")
+
+El paquete ``llama-index-llms-google-genai`` es una dependencia opcional
+(``pip install "csf-scraper-python[llm-gemini]"``), junto con el SDK
+``google-genai`` que este adaptador importa directamente.
+
+Las excepciones de ``google.genai.errors`` se traducen en
+:meth:`GeminiImageReader._translate_api_exception` a excepciones de la librería,
+de modo que fuera de este archivo nadie necesita conocer el SDK de Google.
+"""
+
+from __future__ import annotations
+
+from google.genai import errors
+from llama_index.llms.google_genai import GoogleGenAI
+
+from csf_scraper.exceptions.image_reader import (
+    ImageReaderApiException,
+    ImageReaderAuthenticationException,
+    ImageReaderUnavailableException,
+)
+from csf_scraper.image_readers.ports.image_reader_port import ImageReaderPort
+from csf_scraper.image_readers.services.llm_image_reader_service import (
+    MAX_RETRIES,
+    RETRY_BACKOFF,
+    LlmImageReaderService,
+)
+from csf_scraper.rfc_cif_data import RfcCifData
+from csf_scraper.value_objects.csf_image import CsfImage
+
+#: Códigos HTTP de Google que indican una falla temporal del servicio: el
+#: límite de peticiones (429), los errores del servidor (5xx) y los timeouts de
+#: la propia API (408).
+_RETRYABLE_STATUS_CODES = frozenset({408, 429, 500, 502, 503, 504})
+
+#: Estados de Google que también indican una falla temporal, por si la
+#: respuesta llega sin un código HTTP reconocible.
+_RETRYABLE_STATUSES = frozenset(
+    {
+        "RESOURCE_EXHAUSTED",
+        "INTERNAL",
+        "UNAVAILABLE",
+        "DEADLINE_EXCEEDED",
+        "ABORTED",
+        "UNKNOWN",
+    }
+)
+
+#: Estados que indican que las credenciales no sirven: reintentar con la misma
+#: clave daría exactamente el mismo error.
+_AUTHENTICATION_STATUSES = frozenset({"UNAUTHENTICATED", "PERMISSION_DENIED"})
+
+
+class GeminiImageReader(LlmImageReaderService, ImageReaderPort):
+    """Lee el RFC y el idCIF de una imagen de CSF usando Gemini.
+
+    Hereda de :class:`~csf_scraper.image_readers.services.LlmImageReaderService`
+    el prompt, el armado de la imagen, los reintentos, la ejecución del
+    programa multimodal y el mapeo a
+    :class:`~csf_scraper.rfc_cif_data.RfcCifData`. Lo propio de este adaptador
+    es crear el cliente ``GoogleGenAI``, traducir los errores del SDK y exponer
+    ``read()`` delegando en el método plantilla de la clase base.
+
+    Args:
+        api_key: Clave de la API de Google GenAI.
+        model_name: Modelo de Gemini a utilizar.
+        max_retries: Intentos totales antes de rendirse.
+        retry_backoff: Espera inicial, en segundos, entre reintentos por errores
+            de API; se duplica en cada intento.
+    """
+
+    def __init__(
+        self,
+        api_key: str,
+        model_name: str,
+        *,
+        max_retries: int = MAX_RETRIES,
+        retry_backoff: float = RETRY_BACKOFF,
+    ) -> None:
+        if not api_key:
+            raise ValueError("The Gemini image reader requires an API key.")
+
+        if not model_name:
+            raise ValueError("The Gemini image reader requires an Model Name.")
+        super().__init__(
+            model=model_name,
+            max_retries=max_retries,
+            retry_backoff=retry_backoff,
+        )
+        self._llm_provider = GoogleGenAI(api_key=api_key, model=model_name)
+
+    @property
+    def provider(self) -> str:
+        """Identificador del proveedor."""
+        return "gemini"
+
+    async def read(self, image: CsfImage) -> RfcCifData:
+        """Delega el flujo de reintentos y mapeo en el método plantilla."""
+        return await self._run_program(image=image, llm_provider=self._llm_provider)
+
+    def _translate_api_exception(
+        self, exception: Exception
+    ) -> ImageReaderApiException | None:
+        """Traduce ``google.genai.errors`` a excepciones de la librería.
+
+        - Credenciales rechazadas (401/403) →
+          :class:`ImageReaderAuthenticationException`, **sin** reintentar.
+        - Saturación, caída o timeout (429, 408, 5xx) →
+          :class:`ImageReaderUnavailableException`, **con** reintento.
+        - Cualquier otro error de la API →
+          :class:`ImageReaderApiException` con ``retryable=False``.
+
+        Los errores de transporte genéricos (``httpx``, timeouts) los resuelve
+        la implementación base.
+        """
+        translated = super()._translate_api_exception(exception)
+        if translated is not None:
+            return translated
+
+        if not isinstance(exception, errors.APIError):
+            return None
+
+        status_code = exception.code or None
+        status = (exception.status or "").upper()
+
+        if status_code in {401, 403} or status in _AUTHENTICATION_STATUSES:
+            return ImageReaderAuthenticationException(
+                f"The {self.provider} API rejected the credentials: "
+                f"{exception.message or status_code}",
+                provider=self.provider,
+                model=self.model,
+                status_code=status_code,
+            )
+
+        if status_code in _RETRYABLE_STATUS_CODES or status in _RETRYABLE_STATUSES:
+            return ImageReaderUnavailableException(
+                f"The {self.provider} API is temporarily unavailable: "
+                f"{exception.message or status_code}",
+                provider=self.provider,
+                model=self.model,
+                status_code=status_code,
+            )
+
+        return ImageReaderApiException(
+            f"The {self.provider} API returned an error: {exception.message or status_code}",
+            provider=self.provider,
+            model=self.model,
+            status_code=status_code,
+            retryable=False,
+        )

csf_scraper/image_readers/adapters/llms/prompts/__init__.py

@@ -0,0 +1,8 @@
+"""Prompts canónicos usados por los lectores de imagen basados en LLM."""
+
+from csf_scraper.image_readers.adapters.llms.prompts.llm_image_reader_prompt import (
+    CSF_PROMPT,
+    RETRY_PROMPT,
+)
+
+__all__ = ["CSF_PROMPT", "RETRY_PROMPT"]

csf_scraper/image_readers/adapters/llms/prompts/llm_image_reader_prompt.py

@@ -0,0 +1,17 @@
+CSF_PROMPT = (
+    "Analiza la imagen adjunta, que es una Constancia de Situación Fiscal "
+    "emitida por el SAT, y extrae el RFC y el idCIF que aparecen en el "
+    "encabezado del documento. Transcribe ambos valores exactamente como están "
+    "impresos: conserva las mayúsculas, el signo & y la Ñ si aparecen, y no "
+    "elimines los ceros a la izquierda del idCIF. No inventes ni completes "
+    "valores: si un dato no se distingue en la imagen, devuélvelo como cadena "
+    "vacía."
+)
+
+#: Sufijo que se agrega al prompt cuando el intento anterior fue rechazado.
+RETRY_PROMPT = (
+    "\n\nATENCIÓN: el intento #{previous_attempt} fue descartado por este "
+    "motivo:\n{error}\n\n"
+    "Vuelve a revisar la imagen con cuidado, carácter por carácter, y corrige "
+    "exactamente eso antes de responder."
+)