%pip install "google-genai>=1"

from google import genai

# Crear cliente
api_key = "YOUR_API_KEY" # Sustitúyela por tu clave API.
client = genai.Client(api_key=api_key)

# Define el modelo a utilizar
model_id = "gemini-2.0-flash" # Utilice también "gemini-2.0-flash-lite-preview-02-05" o "gemini-2.0-pro-exp-02-05".

# Subir archivo PDF
invoice_pdf = client.files.upload(file="factura.pdf", config={'nombre_visualizacion': 'factura'})

# Ver en cuántos tokens se convierte el archivo
tamaño_archivo = client.models.count_tokens(model=model_id, contents=factura_pdf)
print(f'Fichero: {invoice_pdf.display_name} equivale a {file_size.total_tokens} tokens')

# Salida de ejemplo: Archivo: factura igual a 821 tokens

def extraer_datos_estructurados(ruta_archivo: str, modelo: BaseModel).
    # Carga de un archivo en la API de archivos
    file = client.files.upload(file=ruta_archivo, config={'display_name': file_path.split('/')[-1].split('.') [0]})

    # Generación de una respuesta estructurada mediante la API Gemini
    prompt = f "Extraer los datos estructurados del siguiente archivo PDF"
    response = client.models.generate_content(model=model_id,
                                             contents=[prompt, file], config={'response_mime_content')
                                             
                                                     'response_schema': model})

    # transforma la respuesta en un modelo Pydantic y lo devuelve
    return respuesta.analizada

from pydantic import ModeloBase, Campo

clase Artículo(BaseModel).
    descripción: str = Field(descripción="La descripción del artículo")
    cantidad: float = Field(description="La cantidad del artículo")
    valor_bruto: float = Field(description="Valor bruto del artículo")

clase Factura(BaseModel).
    """Extraer el número de factura, la fecha y todos los elementos de la lista con la descripción, la cantidad y el valor bruto y el valor bruto total.""""
    número_factura: str = Field(description="El número de factura, por ejemplo 1234567890")
    date: str = Field(description="Fecha de la factura, por ejemplo 2024-01-01")
    items: list[Item] = Field(description="La lista de artículos con descripción, cantidad y valor bruto")
    valor_bruto_total: float = Field(description="Valor bruto total de la factura")

# Extrae los datos utilizando este modelo
result = extraer_datos_estructurados("factura.pdf", Factura)

# Salida de resultados
print(f "Factura extraída: {result.invoice_number} en {result.date} con valor bruto total {result.total_gross_worth}")
para artículo en resultado.artículos: print(f "Artículo: {artículo_valor_bruto}")
    print(f "Artículo: {artículo.descripción} con cantidad {artículo.cantidad} y valor bruto {artículo.valor_bruto}")

clase Formulario(BaseModel).
    """Extraer el número de formulario, la fecha de inicio fiscal, la fecha de finalización fiscal y las obligaciones del plan de principio de año y de final de año.""""
    form_number: str = Field(description="El número de formulario")
    fecha_inicio: str = Field(description="Fecha de entrada en vigor")
    beginning_of_year: float = Field(description="El pasivo del plan a principios de año")
    end_of_year: float = Field(description="El pasivo del plan al final del año")

# Extraer datos
result = extraer_datos_estructurados("escritura_form.pdf", Formulario)

# salida resultados
print(f'Número de formulario extraído: {result.número_formulario} con fecha de inicio {result.fecha_inicio}. \nPlan pasivo inicio del año {result.inicio_del_año} y fin del año {result.fin_del_año}')
# Ejemplo de salida: Número de formulario extraído: CA530082 con fecha de inicio 02/05/2022.
# Pasivo del plan principio del año 40000,0 y final del año 55000,0

CHUNKING_PROMPT = """OCR la siguiente página en Markdown. Las tablas deben tener formato HTML.
No rodee su salida con triple backticks.
Divida el documento en secciones de aproximadamente 250 - 1000 palabras. Nuestro objetivo es
Nuestro objetivo es identificar partes de la página con el mismo tema semántico.
Estos trozos se incrustarán y se utilizarán en una canalización RAG.
Rodee los trozos con etiquetas   html.""""

# utiliza esta instrucción para el procesamiento
response = cliente.modelos.generar_contenido(
    model=id_modelo,
    contents=[CHUNKING_PROMPT, pdf_file]
)

chunked_content = response.text

class Person(BaseModel): first_name: str = Field(description="El nombre de la persona")
    first_name: str = Field(description="El nombre de la persona")
    last_name: str = Field(description="El apellido de la persona")
    last_name: str = Field(description="El apellido de la persona") last_name: str = Field(description="El apellido de la persona")
    work_topics: list[Topic] = Field(description="Los campos de interés de la persona, si no se proporcionan devuelva una lista vacía")

# Generar una respuesta utilizando el modelo Persona
prompt = "Philipp Schmid es un Ingeniero Senior de Relaciones con Desarrolladores de IA en Google DeepMind trabajando en Gemini, Gemma con la misión de ayudar a cada desarrollador a construir y beneficiarse de la IA de manera responsable".
response = client.models.generate_content(
    model=id_modelo,
    contents=prompt,
    config={'response_mime_type': 'application/json', 'response_schema': Person}
)

El SDK # convierte automáticamente la respuesta en un modelo Pydantic
philipp: Persona = respuesta.analizada
print(f "El nombre es {philipp.first_name}")

async def batch_process_pdfs(file_paths, model, batch_size=10):: results = [].
    resultados = []
    for i in range(0, len(rutas_archivo), tamaño_lote):: batch = rutas_archivo[i:i+tamaño_lote): batch = rutas_archivo[i:i
        batch = rutas_archivo[i:i+tamaño_lote]: results = [] for i in range(0, len(rutas_archivo), tamaño_lote).
        tasks = [extraer_datos_estructurados(ruta, modelo) para ruta en lote].
        resultados_lote = await asyncio.gather(*tareas)
        results.extend(resultados_lote)
        print(f "Lote procesado {i//tamaño_lote + 1}/{(len(rutas_archivo)+tamaño_lote-1)//tamaño_lote}")
    devolver resultados

def extraer_con_reintentos(ruta_archivo, modelo, max_reintentos=3):: for intento en rango(max_reintentos)
    para intento en rango(max_reintentos).
        intentar.
            return extraer_datos_estructurados(ruta_archivo, modelo): for intento en rango(entradas_máx): try.
        except Exception as e: if attempt == max_retries
            if attempt == max_retries - 1: print(f "Error al acceder al archivo.
                print(f "No se ha podido procesar {ruta_archivo} tras {máx_intentos} intentos: {e}")
                return Ninguno
            print(f "Intento {intento+1} fallido, reintento: {e}")
            time.sleep(2 **intento) # estrategia de reintento exponencial

TABLE_EXTRACTION_PROMPT = """Extraiga todas las tablas del PDF como tablas HTML.
Conserve la estructura exacta, incluidas las celdas combinadas, los encabezados y el formato.
Cada tabla debe ser semánticamente completa y mantener las relaciones entre celdas.
Para los valores numéricos, mantenga su formato exacto como se muestra en el documento.""""