Capacidad de procesar imagenes sin texto

app.py

@@ -30,19 +30,10 @@ async def echo_image(image: UploadFile = File(...)):
     return StreamingResponse(BytesIO(contents), media_type=image.content_type)
 
 @app.post(
-        "/procesa_dni/", 
+        "/procesa_documento/", 
         tags=["Rapicash"],       
         summary="Procesamiento de DNI")
-async def procesa_dni(image: UploadFile = File(...)):
+async def procesa_documento(image: UploadFile = File(...)):
     if not image.content_type.startswith("image/"):
         return {"error": "El archivo no es una imagen"}
-    return await funciones.procesa_dni(image)
-
-@app.post(
-        "/procesa_pasaporte/",
-        tags=["Rapicash"],        
-        summary="Procesamiento de DNI")
-async def procesa_pasaporte(image: UploadFile = File(...)):
-    if not image.content_type.startswith("image/"):
-        return {"error": "El archivo no es una imagen"}
-    return await funciones.procesa_pasaporte(image)
+    return await funciones.procesa_documento(image)

funciones.py

@@ -2,15 +2,22 @@ import herramientas
 import documentos
 import time
 
-
-async def procesa_dni(image):
+async def procesa_documento(image):
 
 	textos_extraidos = await herramientas.procesaImagen(image)
-
-	#Campos DNI Panamá.
-	nombre, apellido, identificacion, fecha_nacimiento, sexo = await documentos.dni(textos_extraidos)
-
-	return {
+	print("Textos extraídos: ")
+	print(textos_extraidos)
+	
+	documento = herramientas.define_documento(textos_extraidos)
+	print("El documento fue: ", documento)
+
+	if documento == 'dni':
+		# Llama a la función 'dni' si el documento es un DNI
+		nombre, apellido, identificacion, fecha_nacimiento, sexo = await documentos.dni(textos_extraidos)
+		print("Procesado como DNI.")
+
+		return {
+		"documento": documento,
 		"nombre": nombre,
 		"apellido": apellido,
 		"identificacion": identificacion,
@@ -18,15 +25,31 @@ async def procesa_dni(image):
 		"sexo": sexo
 	}
 
-async def procesa_pasaporte(image):
-
-	textos_extraidos = await herramientas.procesaImagen(image)
-
-	#Campos DNI Panamá.
-	nombre, apellido, identificacion = await documentos.pasaporte(textos_extraidos)
+	elif documento == 'pasaporte':
+		# Llama a la función 'pasaporte' si el documento es un pasaporte
+		#nombre, apellido, identificacion, fecha_nacimiento, sexo = await documentos.pasaporte(textos_extraidos)
+		nombre, apellido, identificacion, pasaporte, fecha_nacimiento, sexo, fecha_expedicion, fecha_vencimiento = 'pasaporte', 'pasaporte', 'pasaporte', 'pasaporte', 'pasaporte', 'pasaporte', 'pasaporte', 'pasaporte'
+		print("Procesado como Pasaporte.")
 
-	return {
+		return {
+		"documento": documento,
 		"nombre": nombre,
 		"apellido": apellido,
-		"identificacion": identificacion
-	}
+		"identificacion": identificacion,
+		"pasaporte": pasaporte,
+		"fecha_nacimiento": fecha_nacimiento,
+		"sexo": sexo,
+		"fecha_expedicion": fecha_expedicion,
+		"fecha_vencimiento": fecha_vencimiento
+	}
+
+	else:
+		# Maneja cualquier otro caso no esperado
+		print(f"Tipo de documento no reconocido: {documento}")
+		# Podrías asignar None a las variables o levantar un error aquí
+		#nombre, apellido, identificacion, fecha_nacimiento, sexo = None, None, None, None, None
+		return {
+		"error": "El documento no es un dni o pasaporte válido o requiere ser más legible.",
+	}
+
+	

herramientas.py

@@ -25,7 +25,7 @@ def listaTextosExtraidos(dict_recibido):
     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)
@@ -41,45 +41,93 @@ def buscaIndexPalabra(arreglo, palabra):
             return i
     return None # Cambiado de 'error' a None
 
-def buscaIndexMultiplesPalabras(arreglo, palabras_requeridas):
+def buscaIndexMultiplesPalabras_Corregida(arreglo, conceptos_requeridos):
     """
-    Busca el índice de la primera línea en un arreglo de textos
-    que contenga TODAS las palabras especificadas en palabras_requeridas.
+    Busca el índice de la primera línea que contiene todas las palabras requeridas (o sus alternativas)
+    y devuelve la línea con las alternativas corregidas a su forma preferida.
 
     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.
+        arreglo (list): Lista de strings de texto extraído (limpios).
+        conceptos_requeridos (list): Lista de diccionarios, donde cada diccionario define un concepto:
+                                     Ej: {'preferida': 'nacimiento', 'alternativas': ['nacimento', 'nacimuento']}
 
     Returns:
-        int: El índice de la primera línea que contiene todas las palabras,
-             o None si ninguna línea las contiene.
+        tuple: (índice, línea_corregida) si se encuentra, o (None, None) si no se encuentra.
     """
-
-    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)
+    print(f"\n--- Iniciando búsqueda y corrección ---")
+    
+    # Paso 1: Normalizar los conceptos y prepararlos para la búsqueda y corrección
+    conceptos_preparados = []
+    for concepto in conceptos_requeridos:
+        preferida = concepto['preferida'].lower().replace(" ", "")
+        alternativas = [alt.lower().replace(" ", "") for alt in concepto.get('alternativas', [])]
+        
+        # Combinamos la preferida con las alternativas para la búsqueda
+        todas_las_formas = [preferida] + alternativas
+        
+        conceptos_preparados.append({
+            'preferida': preferida,
+            'todas_las_formas': todas_las_formas,
+            'alternativas': alternativas  # Solo las alternativas para saber cuáles corregir
+        })
 
     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()
+        
+        # Variables para seguir el rastro de la línea actual
+        es_coincidencia_completa = True
+        palabras_encontradas_en_linea = {} # Almacena {forma_encontrada: forma_preferida}
+
+        # Paso 2: Verificar si TODAS las condiciones se cumplen en esta línea
+        for concepto in conceptos_preparados:
+            encontrado_en_esta_linea = False
+            
+            # Buscamos si alguna forma (preferida o alternativa) está en la línea
+            for forma in concepto['todas_las_formas']:
+                if forma in texto_linea_lower:
+                    encontrado_en_esta_linea = True
+                    
+                    # Guardamos qué forma se encontró y cuál es la preferida
+                    palabras_encontradas_en_linea[forma] = concepto['preferida']
+                    
+                    # Hemos encontrado una forma para este concepto, pasamos al siguiente concepto
+                    break 
+            
+            if not encontrado_en_esta_linea:
+                es_coincidencia_completa = False
+                print(f"Fallo en línea {i}: No se encontró el concepto '{concepto['preferida']}' ni sus alternativas.")
+                break # Si falta un concepto, pasamos a la siguiente línea del arreglo
 
-        print("La línea que estoy analizando es: ", texto_linea_lower)
+        # Paso 3: Si se encontró una coincidencia completa, corregimos la línea y la retornamos
+        if es_coincidencia_completa:
+            print(f"ÉXITO: Coincidencia completa en el índice {i}.")
+            print(f"Texto linea es: {texto_linea}")
 
-        # 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
+            linea_corregida = texto_linea
+            
+            for forma_encontrada, forma_preferida in palabras_encontradas_en_linea.items():
+                # Nota: Esta corrección simple asume que la palabra encontrada está exactamente igual que en la lista de alternativas (minusculas y sin espacios)
+                # Para un OCR más variable, necesitarías una lógica de reemplazo más avanzada (ej. re.sub), 
+                # pero para tu caso de "nacimento" a "nacimiento" esto funciona si la palabra se encuentra exactamente.
+
+                # Usamos re.sub para reemplazar la palabra encontrada con la preferida, insensible a mayúsculas/minúsculas
+                # (re.escape para manejar caracteres especiales si los hubiera)
+                patron_reemplazo = re.compile(re.escape(forma_encontrada), re.IGNORECASE)
+                
+                # Reemplazamos la palabra encontrada en la línea original con la forma preferida
+                linea_corregida = patron_reemplazo.sub(forma_preferida, linea_corregida, count=1)
+
+            print(f"Línea corregida: '{linea_corregida}'")
+            # Ahora corregimos la línea original usando la información de las palabras encontradas
             
-    return None # Si ninguna línea contiene todas las palabras
+            arreglo[i] = linea_corregida             
+            return i, arreglo
+    
+    print(f"\n--- Búsqueda finalizada ---")
+    print("Ninguna línea contiene todas las palabras requeridas.")
+    return None, None
 
+########################################################################
 def buscarPatronCedula(lista_textos):    
     for i, texto in enumerate(lista_textos):
         if texto and texto[0].isdigit() and '-' in texto:     
@@ -88,17 +136,21 @@ def buscarPatronCedula(lista_textos):
 
 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
+    try:
+        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
+    except Exception as e:
+        print(f"Error al procesar el archivo: {e}")
+    
 
 def obtener_fecha(texto):
     # El patrón busca:
@@ -143,4 +195,35 @@ def obtener_sexo(texto):
         # que es la letra del sexo/seno. match.group(1) sería "Sexo" o "Seno".
         return match.group(2)
     else:
-        return None 
+        return None
+    
+def define_documento(textos_extraidos):
+
+    #Definiré si el documento subido es un pasaporte o un dni.
+    textos_extraidos_simplificados = [texto.lower().replace(" ", "") for texto in textos_extraidos]   
+
+    #Busqueda de DNI
+    conceptos_busqueda_dni = [
+    {'preferida': 'nombre', 'alternativas': []},
+    {'preferida': 'usual', 'alternativas': []}   
+    ]    
+    
+    indice, textos_extraidos_corregidos = buscaIndexMultiplesPalabras_Corregida(textos_extraidos_simplificados, conceptos_busqueda_dni)
+    if indice is not None:
+        print("Si es dni...")        
+        return 'dni'
+    else: 
+        #Revisar si es pasaporte.
+        #Busqueda de DNI
+        conceptos_busqueda_pasaporte = [
+        {'preferida': 'pasaporte', 'alternativas': ['passport']},
+        #{'preferida': 'identidad', 'alternativas': []}    
+        ]
+        indice, textos_extraidos_corregidos = buscaIndexMultiplesPalabras_Corregida(textos_extraidos_simplificados, conceptos_busqueda_pasaporte)
+        
+        if indice is not None:
+            print("Si es pasaporte...")            
+            return 'pasaporte' 
+        else: 
+            print("No es pasaporte ni dni.")
+            return None

obtenCampo.py

@@ -2,19 +2,26 @@ import herramientas
 
 
 #Campos para DNI.
-def Nombre(textos_extraidos, textos_extraidos_limpios):
-    indice = herramientas.buscaIndexPalabra(textos_extraidos_limpios, 'usual')
+def Nombre(textos_extraidos, textos_extraidos_simplificados):
+    indice = herramientas.buscaIndexPalabra(textos_extraidos_simplificados, 'usual')
     nombre = textos_extraidos[indice-2]    
     apellido = textos_extraidos[indice-1]
     return nombre, apellido
 
-def Identificacion(textos_extraidos, textos_extraidos_limpios):   
-   indice = herramientas.buscarPatronCedula(textos_extraidos_limpios)   
+def Identificacion(textos_extraidos, textos_extraidos_simplificados):   
+   indice = herramientas.buscarPatronCedula(textos_extraidos_simplificados)   
    identificacion = textos_extraidos[indice]
    return identificacion
 
 def Fecha_Nacimiento(textos_extraidos, textos_extraidos_limpios):
-    indice = herramientas.buscaIndexMultiplesPalabras(textos_extraidos_limpios, ['fecha', 'nacimiento'])
+
+    conceptos_busqueda = [
+    {'preferida': 'fecha', 'alternativas': []},
+    {'preferida': 'nacimiento', 'alternativas': ['nacimento']}    ]
+    
+    indice, textos_extraidos_corregidos = herramientas.buscaIndexMultiplesPalabras_Corregida(textos_extraidos_limpios, conceptos_busqueda)
+    print("182 Ésto es textos extraídos corregidos: ", textos_extraidos_corregidos)
+    textos_extraidos_limpios = textos_extraidos_corregidos
     print("El índice de la fecha de nacimiento es: ", indice)
     texto_fecha_nacimiento = textos_extraidos_limpios[indice] #En ésta ocasión estoy usando el texto limpio para que el patrón lo identifique más fácilmente.
     print("Y su correspondiente texto es: " , texto_fecha_nacimiento)     
@@ -23,18 +30,18 @@ def Fecha_Nacimiento(textos_extraidos, textos_extraidos_limpios):
 
 def Sexo(textos_extraidos, textos_extraidos_limpios):
 
-    indice = herramientas.buscaIndexPalabra(textos_extraidos_limpios, 'sexo')
+    conceptos_busqueda = [
+    {'preferida': 'sexo', 'alternativas': ['sex', 'seno', 'sen']},
+    #{'preferida': 'sangre', 'alternativas': []}    
+    ]
+
+    indice, textos_extraidos_corregidos = herramientas.buscaIndexMultiplesPalabras_Corregida(textos_extraidos_limpios, conceptos_busqueda)
 
-    if indice is None: # Comprobamos si el resultado es None (no encontrado)        
-        indice = herramientas.buscaIndexPalabra(textos_extraidos_limpios, 'seno')
-        if indice is not None:
-            print(f"Se encontró una variación de sexo en el índice: {indice}")            
-        else:
-            print("No se encontró ninguna forma de la palabra sexo.")
-            return None
-    else:
-        print(f"Se encontró palabra directamente.")  
+    textos_extraidos_limpios = textos_extraidos_corregidos
+    print("El índice de genero es: ", indice)
 
-    texto_campo_sexo = textos_extraidos[indice]    
-    sexo = herramientas.obtener_sexo(texto_campo_sexo) 
+    texto_genero = textos_extraidos_limpios[indice]
+    print("Y su correspondiente texto es: " , texto_genero)  
+    
+    sexo = herramientas.obtener_sexo(texto_genero) 
     return sexo