Update app.py

app.py

@@ -1,121 +1,187 @@
-import os
 import re
-import random
+import os
 import gradio as gr
-from transformers import pipeline
+import random
+from fuzzywuzzy import fuzz
 
-# Cargar dataset desde archivo
+# Función para cargar el dataset desde el archivo local
 def cargar_dataset(filename="datos_alojamientos.txt"):
-    if not os.path.exists(filename):
-        raise FileNotFoundError(f"Archivo no encontrado: {filename}")
-    with open(filename, "r", encoding="utf-8") as f:
-        contenido = f.read().strip()
-    return [bloque.strip() for bloque in contenido.split("---") if bloque.strip()]
-
-dataset = cargar_dataset()
-
-# Cargar TinyBERT para búsqueda semántica
-tinybert_pipeline = pipeline("feature-extraction", model="huawei-noah/TinyBERT_General_4L_312D")
+    dataset = []
+    try:
+        if not os.path.exists(filename):
+            print(f"Archivo no encontrado: {filename}")
+            return []
+        
+        with open(filename, "r", encoding="utf-8") as f:
+            contenido = f.read().strip()
+            # Dividir por bloques separados por el separador personalizado
+            alojamientos = [bloque.strip() for bloque in contenido.split("------------------------------------------------------------------------------------------") if bloque.strip()]
+        print(f"Cargados {len(alojamientos)} alojamientos.")
+        return alojamientos
+    except Exception as e:
+        print(f"Error al cargar el dataset: {e}")
+        return []
 
-# Normalización de texto
+# Función para limpiar y normalizar texto
 def limpiar_texto(texto):
     return re.sub(r'\s+', ' ', texto.strip().lower())
 
-def obtener_valor(texto, patron):
+# Función para extraer valores de manera segura
+def obtener_valor(texto, patron, valor_predeterminado="No especificado"):
     match = re.search(patron, texto, re.IGNORECASE | re.MULTILINE)
-    return match.group(1).strip() if match else "No disponible"
+    if match:
+        valor = match.group(1).strip() if match.group(1) else valor_predeterminado
+        print(f"Valor extraído para patrón '{patron}': {valor}")
+        return valor
+    print(f"No se encontró coincidencia para patrón '{patron}'.")
+    return valor_predeterminado
 
+# Función para extraer la lista de servicios correctamente
 def obtener_servicios(texto):
-    match = re.findall(r"servicios\s*:\s*(.+)", texto, re.IGNORECASE | re.MULTILINE)
-    return "\n".join([f"🛠 {s.strip()}" for s in match[0].split(",")]) if match else "No especificado"
-
-# Filtrar alojamientos usando TinyBERT
-def filtrar_alojamientos(pregunta):
-    pregunta = limpiar_texto(pregunta)
-    resultados = []
-    
-    # Convertir la pregunta en un embedding usando TinyBERT
-    pregunta_embedding = tinybert_pipeline(pregunta)[0][0]  # Extraer el embedding de la pregunta
-    
-    for alojamiento in dataset:
-        # Convertir el alojamiento en un embedding
-        alojamiento_embedding = tinybert_pipeline(alojamiento)[0][0]
-        
-        # Calcular la similitud entre la pregunta y el alojamiento (similitud de coseno)
-        producto_punto = sum(p * a for p, a in zip(pregunta_embedding, alojamiento_embedding))
-        magnitud_pregunta = (sum(p**2 for p in pregunta_embedding)) ** 0.5
-        magnitud_alojamiento = (sum(a**2 for a in alojamiento_embedding)) ** 0.5
-        similitud = producto_punto / (magnitud_pregunta * magnitud_alojamiento)
-        
-        # Si la similitud es mayor a un umbral, agregar el alojamiento a los resultados
-        if similitud > 0.7:  # Umbral de similitud ajustable
-            resultados.append((alojamiento, similitud))
-    
-    # Ordenar los resultados por similitud (de mayor a menor)
-    resultados.sort(key=lambda x: x[1], reverse=True)
-    
-    # Devolver solo los alojamientos (sin las puntuaciones de similitud)
-    return [alojamiento for alojamiento, _ in resultados]
+    servicios_match = re.findall(r"(?:servicios\s*:\s*)(.+?)(?=\n\S|\Z)", texto, re.IGNORECASE | re.DOTALL)
+    if servicios_match:
+        servicios_lista = [s.strip() for s in servicios_match[0].split(",")]
+        print(f"Servicios extraídos: {servicios_lista}")
+        return "\n".join([f"🛠 {servicio}" for servicio in servicios_lista])
+    print("No se encontraron servicios.")
+    return "No especificado"
 
-# Formatear la respuesta
-def formatear_alojamiento(texto):
-    nombre = obtener_valor(texto, r"alojamiento\s*:\s*(.+)")
-    direccion = obtener_valor(texto, r"dirección\s*:\s*(.+)")
-    telefono = obtener_valor(texto, r"tel[eé]fono[s]*\s*:\s*(.+)")
-    email = obtener_valor(texto, r"email\s*:\s*(.+)")
-    plazas = obtener_valor(texto, r"plazas\s*:\s*(\d+)")
-    mascotas = "Sí" if "mascotas: sí" in texto.lower() else "No"
-    wifi = "Sí" if "wifi: sí" in texto.lower() else "No"
-    servicios = obtener_servicios(texto)
-    return f"""🏠 **{nombre}**\n📍 Dirección: {direccion}\n📞 Teléfono: {telefono}\n📧 Email: {email}\n🛏 Plazas: {plazas}\n🐶 Mascotas: {mascotas}\n📶 Wi-Fi: {wifi}\n{servicios}"""
+# Función para buscar coincidencias difusas
+def buscar_coincidencia(pregunta, texto):
+    similitud = fuzz.partial_ratio(limpiar_texto(pregunta), limpiar_texto(texto))
+    print(f"Similitud entre '{pregunta}' y texto: {similitud}")
+    return similitud > 80  # Umbral ajustado a 80%
 
-# Manejo de paginación
+# Variable global para almacenar resultados previos
 resultados_previos = []
 
+# Función principal para responder preguntas
 def responder_pregunta(pregunta, historial):
     global resultados_previos
-    resultados = filtrar_alojamientos(pregunta)
+    pregunta = limpiar_texto(pregunta)
+    resultados = []
+    cantidad_solicitada = next((int(p) for p in pregunta.split() if p.isdigit()), None)
     
-    if not resultados:
-        return "No se encontraron alojamientos que coincidan con su búsqueda."
+    # 🔥 Lista extendida de palabras clave de servicios
+    palabras_clave_servicios = [
+        "wi fi", "directv", "ropa blanca", "amueblado", "equipado", "habitación", 
+        "cocina", "comedor", "baño", "sommier", "cama", "vajilla completa", "heladera con freezer", 
+        "tv led", "aire acondicionado", "parrilla", "pileta", "lavarropas", "garage", "quincho", "balcón",
+        "cochera", "terraza", "jardín", "microondas", "cafetera", "tostadora", "secador de pelo", 
+        "plancha", "calefacción", "ventilador", "caja fuerte", "servicio de limpieza", "desayuno incluido", "servicio de habitaciones", "gimnasio", "sauna", "jacuzzi", "spa", "piscina", 
+        "estacionamiento", "ascensor", "salón de eventos", "centro de negocios", "alquiler de bicicletas", 
+        "lavandería", "área de juegos", "sala de estar", "chimenea", "vista al mar", "acceso a la playa", 
+        "caja de seguridad", "minibar", "bañera de hidromasaje", "ducha", "bidet", "secador de manos", 
+        "amenities", "Gas", "Gas natural", "cuna", "sofá", "sillón", "armario", "juegos de mesa", "libros"
+    ]
     
-    mostrar = resultados[:3]
-    resultados_previos = resultados[3:]
-    historial += "\n\n".join(formatear_alojamiento(aloj) for aloj in mostrar)
+    # Buscar si alguna palabra clave está en la pregunta
+    busca_servicio = None
+    for servicio in palabras_clave_servicios:
+        if servicio in pregunta:
+            busca_servicio = servicio
+            print(f"Palabra clave de servicio encontrada: {busca_servicio}")
+            break
     
-    if resultados_previos:
-        historial += "\n\n¿Desea ver más opciones?"
+    # Aplicar filtros de búsqueda
+    for alojamiento in dataset:
+        texto_alojamiento = limpiar_texto(alojamiento)
+        
+        # Si hay búsqueda de servicio específico, solo incluir alojamientos que tengan ese servicio
+        if busca_servicio and busca_servicio not in texto_alojamiento:
+            continue
+            
+        # Aplicar los demás criterios de búsqueda
+        if buscar_coincidencia(pregunta, alojamiento) or \
+           (cantidad_solicitada and (f"{cantidad_solicitada} plazas" in alojamiento or f"para {cantidad_solicitada} personas" in alojamiento)):
+            resultados.append(alojamiento)
     
-    return historial
+    if resultados:
+        random.shuffle(resultados)  # 🔥 Ordena aleatoriamente los resultados
+        mostrar_resultados = resultados[:2]  # Muestra al menos 2 alojamientos
+        resultados_previos = resultados[2:]  # Guarda los resultados restantes para "ver más"
+        
+        historial += "\n\n" + "\n\n---\n\n".join(formatear_alojamiento(aloj) for aloj in mostrar_resultados)
+        if len(resultados_previos) > 0:
+            historial += "\n\n🔎 ¿Quieres ver más resultados? Escribe 'ver más'."
+        else:
+            historial += "\n\nNo hay más alojamientos para mostrar."
+        return historial
+    
+    # Personalizar mensaje cuando se busca un servicio específico y no hay resultados
+    if busca_servicio:
+        return f"No encontré alojamientos que tengan '{busca_servicio}' entre sus características."
+    else:
+        return "No encontré alojamientos que coincidan con tu búsqueda."
 
+# Función para mostrar más resultados cuando el usuario escribe "ver más"
 def ver_mas(historial):
     global resultados_previos
+    print(f"Resultados previos disponibles: {len(resultados_previos)}")  # Depuración
+    
     if not resultados_previos:
         return historial + "\n\nNo hay más alojamientos para mostrar."
     
-    mostrar = resultados_previos[:3]
-    resultados_previos = resultados_previos[3:]
-    historial += "\n\n".join(formatear_alojamiento(aloj) for aloj in mostrar)
-    
-    if resultados_previos:
-        historial += "\n\n¿Desea ver más opciones?"
+    mostrar_resultados = resultados_previos[:2]  # Muestra los siguientes 2 alojamientos
+    resultados_previos = resultados_previos[2:]  # Actualiza la lista eliminando los ya mostrados
     
+    historial += "\n\n" + "\n\n---\n\n".join(formatear_alojamiento(aloj) for aloj in mostrar_resultados)
+    if len(resultados_previos) > 0:
+        historial += "\n\n🔎 ¿Quieres ver más resultados? Escribe 'ver más'."
+    else:
+        historial += "\n\nNo hay más alojamientos para mostrar."
     return historial
 
-# Interfaz con Gradio
-with gr.Blocks() as iface:
+# Función para formatear la información de los alojamientos correctamente
+def formatear_alojamiento(texto):
+    nombre = obtener_valor(texto, r"(?:alojamiento\s*:\s*)(.+)")
+    direccion = obtener_valor(texto, r"(?:dirección\s*:\s*)(.+)")
+    telefono = obtener_valor(texto, r"(?:teléfono|teléfonos)\s*:\s*(.+)")
+    plazas = obtener_valor(texto, r"(?:plazas\s*:\s*)(.+)")
+    mascotas = "Sí" if "mascotas\s*:\s*sí" in limpiar_texto(texto) else "No"
+    wifi = "Sí" if "wifi\s*:\s*sí" in limpiar_texto(texto) else "No"
+    servicios = obtener_servicios(texto)
+    
+    # Si el nombre sigue siendo "No especificado", intentamos usar el primer bloque de texto
+    if nombre == "No especificado":
+        nombre = texto.split("\n")[0].strip()
+        print(f"Nombre extraído del primer bloque: {nombre}")
+    
+    return f"""🏠 Nombre: {nombre}
+📍 Dirección: {direccion}
+📞 Teléfono: {telefono}
+🛏 Plazas: {plazas}
+🐶 Política de mascotas: {mascotas}
+📶 Wi-Fi: {wifi}
+{servicios}"""
+
+# Cargar el dataset
+dataset = cargar_dataset()
+
+# Interfaz con Gradio - Mantiene historial del chat
+with gr.Blocks(theme=gr.themes.Default()) as iface:
     gr.Markdown("### Bienvenido a Valer-IA, tu informante turístico virtual 🏡")
+    gr.Markdown("Escribe una consulta sobre alojamientos, por ejemplo: '¿Qué alojamientos aceptan mascotas?' o 'Alojamiento con pileta y aire acondicionado'")
     chat_historial = gr.Textbox(label="Historial de chat", lines=15, interactive=False)
     pregunta_input = gr.Textbox(label="Escribe tu consulta:")
     
     def actualizar_chat(historial, nueva_pregunta):
         nueva_pregunta = nueva_pregunta.strip().capitalize()
-        if nueva_pregunta.lower() == "más" or nueva_pregunta.lower() == "mas":
+        saludos = ["hola", "buenos días", "buenas tardes", "buenas noches", "qué tal", "hey", "saludos"]
+        
+        if nueva_pregunta.lower() in saludos:
+            respuesta = "¡Hola! 😊 Soy Valer-IA, tu asistente turístico virtual. ¿En qué puedo ayudarte hoy?"
+        elif nueva_pregunta.lower() in ["ver mas", "ver más"]:
             return ver_mas(historial), ""
-        return responder_pregunta(nueva_pregunta, historial), ""
+        else:
+            respuesta = responder_pregunta(nueva_pregunta, historial)
+        
+        return respuesta, ""
     
     preguntar_btn = gr.Button("Preguntar")
+    
+    # 🔥 Se borra la pregunta después de ser contestada
     preguntar_btn.click(actualizar_chat, inputs=[chat_historial, pregunta_input], outputs=[chat_historial, pregunta_input])
 
 if __name__ == "__main__":
-    iface.launch()
+    iface.launch()