herramientas.py

import tempfile
import time
from gradio_client import Client, handle_file
import re 

async def imageToTemp(image):

    try:
        with tempfile.NamedTemporaryFile(delete=False, suffix=f"_{image.filename}") as tmp_file:
            contents = await image.read()
            tmp_file.write(contents)
            temp_file_path = tmp_file.name
        
        print(f"Archivo temporal guardado en: {temp_file_path}")
        return temp_file_path

    except Exception as e:
        print(f"Error al procesar el archivo: {e}")
        return {"error": "Error al procesar la imagen"}
    

def listaTextosExtraidos(dict_recibido):

    result = dict_recibido['data']
    print("Datos extraídos (acceso directo):")
    
    textos_extraidos = [] 
    print("Líneas encontradas con modelo IA:")
    for item in result:
        texto = item[1][0] 
        print(texto)
        textos_extraidos.append(texto)
    return textos_extraidos

#Herramientas para DNI Panamá.

def buscaIndexPalabra(arreglo, palabra):
    palabra_limpia = palabra.lower().replace(" ", "")
    for i, texto_limpio in enumerate(arreglo):
        if palabra_limpia in texto_limpio:
            return i
    return None # Cambiado de 'error' a None

def buscaIndexMultiplesPalabras(arreglo, palabras_requeridas):
    """
    Busca el índice de la primera línea en un arreglo de textos
    que contenga TODAS las palabras especificadas en palabras_requeridas.

    Args:
        arreglo (list): Una lista de strings (los textos limpios).
        palabras_requeridas (list): Una lista de strings, donde cada string
                                   es una palabra que debe estar presente en la línea.
                                   La búsqueda es insensible a mayúsculas/minúsculas
                                   y limpia espacios en las palabras requeridas.

    Returns:
        int: El índice de la primera línea que contiene todas las palabras,
             o None si ninguna línea las contiene.
    """

    print("Estoy en busca palabras múltiples.")


    # Limpiar y normalizar todas las palabras requeridas de una vez
    palabras_requeridas_limpias = [p.lower().replace(" ", "") for p in palabras_requeridas]

    print("Las palabras requeridas límpias son: ", palabras_requeridas_limpias)

    for i, texto_linea in enumerate(arreglo):
        # Convertir la línea actual a minúsculas para una comparación insensible a mayúsculas/minúsculas
        texto_linea_lower = texto_linea.lower()

        print("La línea que estoy analizando es: ", texto_linea_lower)

        # Verificar si TODAS las palabras requeridas están en la línea actual
        # Usamos 'all()' para asegurarnos de que CADA palabra_limpia esté en texto_linea_lower
        if all(palabra_limpia in texto_linea_lower for palabra_limpia in palabras_requeridas_limpias):
            print(f"Todas las palabras están en la línea {i}")
            return i # Retorna el índice de la primera línea que cumple la condición
            
    return None # Si ninguna línea contiene todas las palabras

def buscarPatronCedula(lista_textos):    
    for i, texto in enumerate(lista_textos):
        if texto and texto[0].isdigit() and '-' in texto:     
            return i 
    return 'error'

async def procesaImagen(image):

    temp_image = await imageToTemp(image)

    client = Client("BuzzwordMx/ai_ocr")
    dict_recibido = client.predict(
            img=handle_file(temp_image),
            lang="en",
            api_name="/predict"
    )             
    #Aquí es donde personalizo el proceso:
    textos_extraidos = listaTextosExtraidos(dict_recibido) 
    return textos_extraidos

def obtener_fecha(texto):
    # El patrón busca:
    # - "FECHADENACIMIENTO" (insensible a mayúsculas/minúsculas)
    # - Seguido opcionalmente de CERO o MÁS caracteres que NO SEAN UN DÍGITO (lo que inicia la fecha).
    #   Esto cubrirá ':', '.', espacios, o cualquier otro carácter de separación.
    # - Captura el patrón de fecha: \d{1,2}-[A-Za-z0-9]{3}-\d{4}
    patron = r"FECHADENACIMIENTO[^\d]*(\d{1,2}-[A-Za-z0-9]{3}-\d{4})"
    
    match = re.search(patron, texto, re.IGNORECASE)
    
    fecha_encontrada = None
    if match:
        fecha_encontrada = match.group(1)
        
        if fecha_encontrada:
            partes_fecha = fecha_encontrada.split('-')
            if len(partes_fecha) == 3:
                dia = partes_fecha[0]
                mes = partes_fecha[1].lower() # Convierte el mes a minúsculas
                año = partes_fecha[2]
                return f"{dia}-{mes}-{año}"
            else:
                # Esto se ejecutaría si el formato de la fecha extraída no es el esperado (ej. 2 partes)
                return fecha_encontrada 
    
    return None # Si no se encontró el patrón de fecha

def obtener_sexo(texto):
    # El patrón ahora busca "Sexo" O "Seno" (insensible a mayúsculas/minúsculas)
    # Seguido opcionalmente de un ":"
    # Seguido opcionalmente de espacios en blanco
    # Captura la siguiente letra
    patron = r"(Sexo|Seno):?\s*([A-Za-z])"
    
    # re.search busca la primera ocurrencia del patrón en el texto
    # re.IGNORECASE hace que la búsqueda sea insensible a mayúsculas/minúsculas para "Sexo" y "Seno"
    match = re.search(patron, texto, re.IGNORECASE)
    
    if match:
        # match.group(2) devuelve lo que se capturó en el SEGUNDO grupo de paréntesis,
        # que es la letra del sexo/seno. match.group(1) sería "Sexo" o "Seno".
        return match.group(2)
    else:
        return None