Busqueda Multiple es AND por default e incluí el OR

app.py

@@ -50,21 +50,22 @@ async def echo_image(
 
 @app.post(
         "/identifica_documento/", 
-        tags=["Documentos"],       
+        tags=["General"],       
         summary="Reconocimiento Avanzado de Documentos")
 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.identifica_documento(image)
 
-@app.post(
-        "/procesa_documento/", 
-        tags=["Documentos"],       
-        summary="Reconocimiento Avanzado de Documentos")
-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_documento(image)
+#PROCESA CUALQUIER DOCUMENTO, ESTABA LISTO PARA DNI Y PASAPORTE PERO LE FALTA INE, SE REANUDA CADA QUE ESTÉ AL DÍA.
+# @app.post(
+#         "/procesa_documento/", 
+#         tags=["General"],       
+#         summary="Reconocimiento Avanzado de Documentos")
+# 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_documento(image)
 
 @app.post(
         "/procesa_ine/", 

conceptos_busqueda.py

@@ -1,7 +1,13 @@
+#Que documentos búsca el sistema actualmente.
+documentos = ['dni', 'ine', 'pasaporte']
+
+#Cada concepto de la lista de cada documento es un OR, es decir, bastará con que encuentre uno de los dos para dar...
+#... por hecho que es esa clase de documento.
+
 dni = [
     {'preferida': 'nombre', 'alternativas': ['noaigre']},
-    {'preferida': 'usual', 'alternativas': []}   
-    ]  
+    {'preferida': 'usual', #'alternativas': []
+     }]  
 
 pasaporte = [
         {'preferida': 'pasaporte', 'alternativas': ['passport']},

herramientas.py

@@ -64,7 +64,100 @@ def buscaIndexPalabra(arreglo, palabra):
             return i
     return None # Cambiado de 'error' a None
 
-def buscaIndexMultiplesPalabras(arreglo_textos, conceptos_requeridos):
+import re
+
+def buscaIndexMultiplesPalabras(arreglo_textos, conceptos_requeridos): #AND por default.
+    """
+    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): 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:
+        tuple: (índice, arreglo_corregido) si se encuentra, o (None, None) si no se encuentra.
+    """
+    print(f"\n--- Entre a busqueda palabras index ---")
+    
+    # Paso 1: Normalizar los conceptos y prepararlos para la búsqueda y corrección
+    conceptos_preparados = []
+    for concepto in conceptos_requeridos:
+        print("Preparación de conceptos, estoy en el concepto: ", concepto)
+        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
+        print("Todas las formas quedó como: ", todas_las_formas)
+        
+        conceptos_preparados.append({
+            'preferida': preferida,
+            'todas_las_formas': todas_las_formas,
+        })
+    
+        print("Conceptos preparados quedó como: ", conceptos_preparados)
+
+    for i, texto_linea in enumerate(arreglo_textos):
+        texto_linea_lower = texto_linea.lower()
+        print("Trabajando la línea: ", texto_linea_lower)
+        
+        # Variables para seguir el rastro de la línea actual
+        es_coincidencia_completa = True # Asume que la coincidencia es completa al inicio de cada línea
+        print("La var es_coincidencia_completa empieza como 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_este_concepto = False
+            print("Revisando CONCEPTO: ", concepto)
+            
+            # Buscamos si alguna forma (preferida o alternativa) está en la línea
+            for forma in concepto['todas_las_formas']:
+                print("Evaluando la siguiente forma en el concepto: Forma: ", forma)
+                print(f"Ahora, si la forma --{forma}-- está en la línea: --{texto_linea_lower}--, entonces: ")
+                if forma in texto_linea_lower:
+                    print(f"¡Encontrado! La forma '{forma}' está en la línea.")
+                    encontrado_en_este_concepto = True
+                    
+                    # Guardamos qué forma se encontró y cuál es la preferida
+                    palabras_encontradas_en_linea[forma] = concepto['preferida']
+                    
+                    print("Estoy por hacer break porque encontré la línea...")
+                    # Hemos encontrado una forma para este concepto, pasamos al siguiente concepto
+                    break # Este break sale del bucle interno, lo cual es correcto
+            
+            # Si no se encontró ninguna forma para el concepto actual, esta línea no es una coincidencia
+            if not encontrado_en_este_concepto:
+                es_coincidencia_completa = False
+                print(f"Línea {i}: Concepto '{concepto['preferida']}' : No encontrado. ¡Fallo en esta línea!")
+                break # Este break sale del bucle principal de conceptos, lo cual es correcto
+            
+        print("Paso: if es_coincidencia_completa:")
+        # Paso 3: Si se encontró una coincidencia completa, corregimos la línea y la retornamos
+        if es_coincidencia_completa:
+            print("Aquí llega cuando encuentra algo, en su línea respectiva.")
+            print(f"ÉXITO: Coincidencia completa en el índice {i}.")
+            print(f"Texto linea es: {texto_linea}")
+
+            linea_corregida = texto_linea
+            
+            for forma_encontrada, forma_preferida in palabras_encontradas_en_linea.items():
+                patron_reemplazo = re.compile(re.escape(forma_encontrada), re.IGNORECASE)
+                linea_corregida = patron_reemplazo.sub(forma_preferida, linea_corregida, count=1)
+            
+            print(f"Línea corregida: '{linea_corregida}'")
+            arreglo_textos[i] = linea_corregida
+            
+            return i, arreglo_textos
+    
+    print("Paso: Búsqueda finalizada.:")
+    print(f"\n--- Búsqueda finalizada ---")
+    print("Ninguna línea contiene todas las palabras requeridas.")
+    return None, None
+
+def buscaIndexMultiplesPalabrasOR(arreglo_textos, conceptos_requeridos):
     """
     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.

identificador.py

@@ -1,6 +1,8 @@
 import herramientas
 import conceptos_busqueda
 import time
+from conceptos_busqueda import documentos as documentos
+
 
 def identifica_documento(textos_extraidos_simplificados):
     """
@@ -12,12 +14,11 @@ def identifica_documento(textos_extraidos_simplificados):
     Returns:
         str: El nombre del primer documento encontrado ('dni', 'pasaporte', etc.),
              o None si ninguno de los documentos fue identificado.
-    """
-    print("Estoy en identifica documento...")
-    documentos = ['ine', 'dni', 'pasaporte']
+    """     
 
     for tipo_documento in documentos:
         print("Revisando tipo de documento: ", tipo_documento)
+        time.sleep(3)
     
         # Usamos 'getattr' para acceder dinámicamente al atributo correcto
         # del objeto 'conceptos_busqueda', como 'conceptos_busqueda.dni'.
@@ -32,13 +33,20 @@ def identifica_documento(textos_extraidos_simplificados):
         # Si la búsqueda encuentra un resultado, salimos inmediatamente y retornamos
         # el nombre del documento.
         if indice is not None:
+            print(f"No fue none, hizo su encuentro en el documento: ", tipo_documento)
+            time.sleep(7)
             # Puedes retornar el tipo_documento y los textos corregidos
             # return tipo_documento, textos_corregidos
             
             # O simplemente el tipo de documento, como en tu ejemplo
             return tipo_documento
+        
+        print("Índice no fue None, continua la búsqueda...")
+        time.sleep(8)
 
     # Si el bucle termina sin encontrar ningún documento, retornamos None
+    print("Se acabó la búsqueda y no encontró nada.")
+    time.sleep(4)
     return None
 
 def identifica_ine(textos_extraidos_simplificados):