Update app.py

app.py

@@ -1,435 +1,115 @@
-# app.py (archivo completo — pégalo tal cual)
 import gradio as gr
-import datetime
-import random
 import json
 import os
-from hashlib import md5
-from PIL import Image
-import io
+from datetime import datetime
+from chatbot_nuti import buscar_respuesta
+from coach_emocional import coach_emocional_inteligente
+from login import cargar_usuarios, registrar_usuario, iniciar_sesion
 
-# -------------------- ARCHIVOS / CONSTANTES --------------------
-USUARIOS_FILE = "usuarios.json"
 SESION_FILE = "sesion.json"
-MEMORIA_NUTI = "memoria_nuti.json"
-MEMORIA_COACH = "memoria_coach.json"
-CACHE_CLASS = {}  # cache en memoria para clasificador
 
-# -------------------- UTILIDADES: USUARIOS / SESIÓN --------------------
-def cargar_usuarios():
-    if os.path.exists(USUARIOS_FILE):
-        with open(USUARIOS_FILE, "r", encoding="utf-8") as f:
-            return json.load(f)
-    return {}
-
-def guardar_usuarios(u):
-    with open(USUARIOS_FILE, "w", encoding="utf-8") as f:
-        json.dump(u, f, indent=2, ensure_ascii=False)
-
-def registrar_usuario(nombre, email, password):
-    usuarios = cargar_usuarios()
-    if not email or not password or not nombre:
-        return "⚠️ Completa todos los campos."
-    if email in usuarios:
-        return "⚠️ Ya existe una cuenta con ese correo."
-    usuarios[email] = {"nombre": nombre, "password": password, "created": str(datetime.datetime.now())}
-    guardar_usuarios(usuarios)
-    # crear sesión al registrarse
-    with open(SESION_FILE, "w", encoding="utf-8") as f:
-        json.dump({"usuario": email}, f)
-    return "✅ Registro exitoso. Sesión iniciada."
-
-def iniciar_sesion(email, password):
-    usuarios = cargar_usuarios()
-    if email not in usuarios:
-        return "❌ Usuario no encontrado."
-    if usuarios[email]["password"] != password:
-        return "🔐 Contraseña incorrecta."
-    with open(SESION_FILE, "w", encoding="utf-8") as f:
+# ---------- FUNCIONES DE SESIÓN ---------- #
+def guardar_sesion(email):
+    with open(SESION_FILE, "w") as f:
         json.dump({"usuario": email}, f)
-    return f"✅ Bienvenido de nuevo, {usuarios[email]['nombre']}!"
 
-def obtener_usuario_sesion():
+def cargar_sesion():
     if os.path.exists(SESION_FILE):
-        with open(SESION_FILE, "r", encoding="utf-8") as f:
-            data = json.load(f)
-            return data.get("usuario")
+        with open(SESION_FILE, "r") as f:
+            return json.load(f).get("usuario")
     return None
 
-# -------------------- MEMORIA (Nuti y Coach) --------------------
-def cargar_json(path):
-    if os.path.exists(path):
-        with open(path, "r", encoding="utf-8") as f:
-            return json.load(f)
-    return {}
-
-def guardar_json(path, data):
-    with open(path, "w", encoding="utf-8") as f:
-        json.dump(data, f, indent=2, ensure_ascii=False)
-
-def cargar_memoria_nuti(usuario):
-    data = cargar_json(MEMORIA_NUTI)
-    return data.get(usuario, {"historial": []})
-
-def actualizar_memoria_nuti(usuario, pregunta, respuesta):
-    data = cargar_json(MEMORIA_NUTI)
-    if usuario not in data:
-        data[usuario] = {"historial": []}
-    data[usuario]["historial"].append({
-        "pregunta": pregunta,
-        "respuesta": respuesta,
-        "fecha": str(datetime.datetime.now())
-    })
-    # limitar historial a últimos 50
-    data[usuario]["historial"] = data[usuario]["historial"][-50:]
-    guardar_json(MEMORIA_NUTI, data)
-
-def cargar_memoria_coach(usuario):
-    data = cargar_json(MEMORIA_COACH)
-    return data.get(usuario, {"historial": []})
-
-def actualizar_memoria_coach(usuario, entrada, respuesta, estado_emocional=None):
-    data = cargar_json(MEMORIA_COACH)
-    if usuario not in data:
-        data[usuario] = {"historial": []}
-    registro = {"entrada": entrada, "respuesta": respuesta, "fecha": str(datetime.datetime.now())}
-    if estado_emocional:
-        registro["estado_emocional"] = estado_emocional
-    data[usuario]["historial"].append(registro)
-    data[usuario]["historial"] = data[usuario]["historial"][-50:]
-    guardar_json(MEMORIA_COACH, data)
-
-# -------------------- CLASIFICADOR DE IMÁGENES (intenta transformers, si no fallback) --------------------
-def cargar_modelo_transformers():
-    try:
-        # Import dentro de la función para fallar suavemente si no está instalado
-        from transformers import pipeline
-        model = pipeline("image-classification", model="nateraw/food")
-        return model
-    except Exception:
-        return None
-
-MODEL_PIPELINE = cargarmodelo := None
-try:
-    MODEL_PIPELINE = cargar_modelo_transformers()
-except Exception:
-    MODEL_PIPELINE = None
-
-def resize_imagen_pil(img, size=(224,224)):
-    if isinstance(img, Image.Image):
-        return img.convert("RGB").resize(size)
-    # si es bytes
-    try:
-        im = Image.open(io.BytesIO(img))
-        return im.convert("RGB").resize(size)
-    except Exception:
-        return None
-
-def clasificar_imagen(img):
-    """
-    Intenta usar transformers pipeline; si no está disponible usa fallback simple.
-    Devuelve una lista tipo [{'label':'pizza', 'score':0.9}] para compatibilidad.
-    """
-    # cache by bytes hash
-    try:
-        buf = io.BytesIO()
-        if isinstance(img, Image.Image):
-            img.save(buf, format="JPEG")
-            k = md5(buf.getvalue()).hexdigest()
-        else:
-            # if it's a path or raw bytes
-            raw = img if isinstance(img, (bytes, bytearray)) else str(img).encode("utf-8")
-            k = md5(raw).hexdigest()
-        if k in CACHE_CLASS:
-            return CACHE_CLASS[k]
-    except Exception:
-        k = None
-
-    # try transformers model
-    if MODEL_PIPELINE:
-        try:
-            res = MODEL_PIPELINE(img)
-            CACHE_CLASS[k] = res
-            return res
-        except Exception:
-            pass
-
-    # fallback classifier (heurístico basado en tamaño/colors)
-    try:
-        im = img if isinstance(img, Image.Image) else Image.open(io.BytesIO(img))
-        im_small = im.resize((64,64)).convert("RGB")
-        pixels = list(im_small.getdata())
-        # average R,G,B
-        r = sum(p[0] for p in pixels)/len(pixels)
-        g = sum(p[1] for p in pixels)/len(pixels)
-        b = sum(p[2] for p in pixels)/len(pixels)
-        # heurística simple
-        if r > 150 and g < 120:
-            label = "pizza"
-        elif g > r and g > b:
-            label = "salad"
-        elif b > r and b > g:
-            label = "fish"
-        else:
-            label = "pasta"
-        res = [{"label": label, "score": 0.6}]
-        if k:
-            CACHE_CLASS[k] = res
-        return res
-    except Exception:
-        return [{"label":"unknown","score":0.0}]
-
-# -------------------- BASES DE CONOCIMIENTO (Nuti y Coach) --------------------
-TEMAS_NUTRICION = {
-    "desayuno": [
-        "Un desayuno equilibrado (proteína + carbohidratos complejos + fruta) mejora concentración y saciedad.",
-        "Evita azúcares simples por la mañana; prueba avena o yogurt natural con fruta."
-    ],
-    "almuerzo": [
-        "Incluye proteína, verduras y un carbohidrato integral para energía sostenida.",
-        "No olvides una porción de verduras para vitaminas y fibra."
-    ],
-    "cena": [
-        "Cena ligera 2 horas antes de dormir para una mejor calidad de sueño.",
-        "Sopa de verduras con proteína magra es una excelente opción nocturna."
-    ]
-}
-
-PALABRAS_CLAVE = {
-    "ansiedad": "Cuando sientas ansiedad, prueba respirar 4-4-4 (inhala 4s, mantén 4s, exhala 4s). Bebe agua y espera 5-10 min antes de decidir comer.",
-    "estrés": "El estrés puede aumentar los antojos. Pausas cortas, hidratarte y caminar 10 min ayudan mucho.",
-    "peso": "El peso es un indicador, no la definición. Enfócate en hábitos sostenibles y salud, no solo en la balanza.",
-    "agua": "Beber suficiente agua ayuda al hambre real vs. hambre emocional. Intenta un vaso antes de cada comida."
-}
-
-# -------------------- FUNCIONES INTELIGENTES (sin API externa) --------------------
-def buscar_respuesta(usuario, mensaje, historial=None):
-    """
-    Nuti local: usa historial y reglas para generar respuesta contextual.
-    historial: lista de dicts opcional
-    """
-    texto = (mensaje or "").lower().strip()
-    historial = historial or cargar_memoria_nuti(usuario)["historial"] if usuario else []
-
-    # detección rápida de temas por palabra
-    for clave, frases in TEMAS_NUTRICION.items():
-        if clave in texto:
-            resp = random.choice(frases)
-            actualizar_memoria_nuti(usuario, mensaje, resp)
-            return resp
-
-    for palabra, resp in PALABRAS_CLAVE.items():
-        if palabra in texto:
-            actualizar_memoria_nuti(usuario, mensaje, resp)
-            return resp
-
-    # si hay historial, intentar continuidad
-    if historial:
-        # mira últimas interacciones y responde con continuidad
-        last = historial[-1]
-        resp = f"Veo que antes hablaste de \"{last.get('pregunta','...')[:60]}\". {random.choice(['¿Quieres que profundicemos?','Puedo sugerirte un plan corto para esto.'])}"
-        actualizar_memoria_nuti(usuario, mensaje, resp)
-        return resp
-
-    # fallback más elaborado
-    respuestas_generales = [
-        "Cuéntame más: ¿qué buscas — perder peso, ganar músculo, mejorar energía o algo más?",
-        "Puedo darte un ejemplo de menú, una receta o un plan de ejercicio breve. ¿Cuál prefieres?",
-        "Pequeños cambios diarios hacen gran diferencia. ¿Qué hábito te gustaría mejorar primero?"
-    ]
-    resp = random.choice(respuestas_generales)
-    actualizar_memoria_nuti(usuario, mensaje, resp)
-    return resp
-
-def coach_emocional_inteligente(usuario, mensaje, historial=None):
-    """
-    Coach emocional local: empatía + recomendaciones prácticas, usando historial.
-    historial: lista opcional de entradas previas (de app)
-    """
-    texto = (mensaje or "").lower().strip()
-    historial = historial or cargar_memoria_coach(usuario)["historial"] if usuario else []
-
-    # detectar emoción en texto
-    if any(x in texto for x in ["ansiedad", "ansioso", "nervioso"]):
-        resp = ("Siento que estás ansioso/a. Prueba respiraciones lentas (inhala 4s, exhala 6s), bebe agua y "
-                "si puedes, camina 5-10 minutos. Para picar, una fruta o un puñado de nueces ayuda.")
-        estado = "ansioso"
-    elif any(x in texto for x in ["triste", "deprim", "mal", "melanc"]):
-        resp = ("Lamento que te sientas así. Hablar con alguien de confianza o escribir cómo te sientes ayuda. "
-                "Una merienda ligera, descansar y movimiento suave (una caminata) pueden mejorar el ánimo.")
-        estado = "triste"
-    elif any(x in texto for x in ["feliz", "contento", "genial"]):
-        resp = ("¡Qué bien que te sientes así! Mantén esos hábitos: come variado, hidrátate y celebra los logros.")
-        estado = "positivo"
-    else:
-        # si no hay emoción clara, usar historial para seguimiento
-        if historial:
-            last = historial[-1]
-            resp = (f"Recuerdo que antes comentaste: '{last.get('entrada','...')[:80]}'. "
-                    "¿Quieres seguir con eso o prefieres cambiar de tema? Puedo sugerir técnicas prácticas.")
-        else:
-            resp = ("Cuéntame más sobre cómo te sientes hoy: ¿ansioso, estresado, triste, con hambre emocional? "
-                    "Así te doy una recomendación práctica.")
-        estado = "neutral"
-
-    actualizar_memoria_coach(usuario, mensaje, resp, estado_emocional=estado)
-    return resp
-
-# -------------------- APP: ESTADO GLOBAL (comida, metas) --------------------
-# Mantendremos un registro simple en memoria/archivo llamado registro.json
-REGISTRO_FILE = "registro.json"
-def cargar_registro():
-    if os.path.exists(REGISTRO_FILE):
-        with open(REGISTRO_FILE, "r", encoding="utf-8") as f:
-            return json.load(f)
-    # estructura inicial
-    base = {"meta_diaria": 0, "restantes": 0, "quemas": 0, "puntos": 0, "registro": [], "badges": [], "emocion": "", "nivel": 1, "historial_nuti": {}, "historial_emocional": {}}
-    guardar_registro(base)
-    return base
-
-def guardar_registro(data):
-    with open(REGISTRO_FILE, "w", encoding="utf-8") as f:
-        json.dump(data, f, indent=2, ensure_ascii=False)
-
-estado = cargar_registro()  # carga inicial
-
-# -------------------- DATOS AUXILIARES --------------------
-calorias_promedio = {
-    "pizza": 285, "hamburger": 354, "apple": 95, "banana": 105,
-    "salad": 150, "pasta": 350, "rice": 200, "ice cream": 210,
-    "donut": 195, "fish": 206, "chicken": 239, "broccoli": 55
-}
-
-actividades = {
-    "Correr": 700, "Caminar": 250, "Fútbol": 600,
-    "Natación": 550, "Básquetbol": 500, "Voleibol": 400, "Yoga": 200,
-}
-
-nutriologos = [
-    {"nombre": "Dra. Ana López", "pais": "México", "estado": "Sonora", "ciudad": "Hermosillo",
-     "especialidad": "Nutrición deportiva", "direccion": "Av. Universidad 200", "contacto": "Instagram: @dra.analpz"},
-    {"nombre": "Lic. Jorge Ramírez", "pais": "México", "estado": "CDMX", "ciudad": "Coyoacán",
-     "especialidad": "Control de peso", "direccion": "Centro NutriVida, Av. Pacífico 300", "contacto": "Tel: +52 55 1234 5678"},
-    {"nombre": "Dra. Camila Torres", "pais": "Colombia", "estado": "Antioquia", "ciudad": "Medellín",
-     "especialidad": "Nutrición infantil", "direccion": "Cra 40 #23", "contacto": "Email: camilatorresnutri@gmail.com"},
-]
+def cerrar_sesion():
+    if os.path.exists(SESION_FILE):
+        os.remove(SESION_FILE)
+    return "Sesión cerrada. 👋"
 
-misiones = [
-    "🥤 Bebe 8 vasos de agua.",
-    "🍎 Come 3 frutas distintas.",
-    "🚶 Camina 20 minutos.",
-    "🌈 Come 4 colores de comida diferentes.",
-    "🧘 Haz 10 minutos de respiración o yoga."
-]
+# ---------- MEMORIA DE CONVERSACIÓN ---------- #
+MEMORIA_NUTI = {}
+MEMORIA_COACH = {}
 
-# -------------------- FUNCIONES EXPUESTAS A LA UI --------------------
-def calcular_calorias_ui(edad, peso, altura, sexo, actividad_str):
-    if not all([edad, peso, altura, sexo]):
-        return "⚠️ Completa tus datos para calcular."
-    try:
-        edad = float(edad); peso = float(peso); altura = float(altura)
-    except Exception:
-        return "⚠️ Datos inválidos. Revisa números."
-    if sexo.lower() == "hombre":
-        bmr = 88.36 + (13.4 * peso) + (4.8 * altura) - (5.7 * edad)
+def obtener_memoria(usuario, tipo="nuti"):
+    if tipo == "nuti":
+        return MEMORIA_NUTI.setdefault(usuario, [])
     else:
-        bmr = 447.6 + (9.2 * peso) + (3.1 * altura) - (4.3 * edad)
-    niveles = {"Sedentario": 1.2, "Ligero": 1.375, "Moderado": 1.55, "Activo": 1.725, "Muy activo": 1.9}
-    tdee = bmr * niveles.get(actividad_str, 1.2)
-    estado["meta_diaria"] = round(tdee)
-    estado["restantes"] = round(tdee)
-    guardar_registro(estado)
-    return f"🔥 Tu meta calórica diaria es de {round(tdee)} cal."
-
-def analizar_foto_ui(img, usuario):
-    if estado.get("meta_diaria", 0) == 0:
-        return "⚠️ Primero calcula tu meta diaria."
-    if img is None:
-        return "⚠️ Sube una foto."
-    img_opt = resize_imagen_pil(img)
-    result = clasificar_imagen(img_opt)
-    nombre = result[0]["label"].lower() if result else "comida"
-    calorias = calorias_promedio.get(nombre, 250)
-    estado["restantes"] = max(0, estado["restantes"] - calorias)
-    estado["registro"].append({"fecha": str(datetime.datetime.now()), "tipo": "comida", "nombre": nombre, "calorias": calorias, "usuario": usuario})
-    estado["puntos"] += 10
-    guardar_registro(estado)
-    return f"🍽️ {nombre.title()} ≈ {calorias} cal. Restan {estado['restantes']} / {estado['meta_diaria']} cal."
-
-def registrar_actividad_ui(tipo, duracion, usuario):
-    try:
-        dur = float(duracion)
-    except Exception:
-        return "⚠️ Duración inválida."
-    if tipo not in actividades:
-        return "Selecciona una actividad válida."
-    quemadas = int(actividades[tipo] * (dur / 60))
-    estado["restantes"] += quemadas
-    estado["quemas"] += quemadas
-    estado["registro"].append({"fecha": str(datetime.datetime.now()), "tipo":"actividad", "nombre":tipo, "calorias":quemadas, "usuario": usuario})
-    estado["puntos"] += 15
-    guardar_registro(estado)
-    return f"🏃‍♂️ {tipo} durante {dur} min ≈ {quemadas} cal quemadas. Restantes: {estado['restantes']}."
-
-def coach_emocional_ui(texto, usuario):
-    if not usuario:
-        usuario = "usuario_desconocido"
-    memoria = cargar_memoria_coach(usuario)["historial"]
-    resp = coach_emocional_inteligente(usuario, texto, memoria)
-    return resp
-
-def chat_nuti_ui(pregunta, usuario):
-    if not usuario:
-        usuario = "usuario_desconocido"
-    memoria = cargar_memoria_nuti(usuario)["historial"]
-    resp = buscar_respuesta(usuario, pregunta, memoria)
-    return resp
-
-def buscar_nutriologo_ui(pais, estado_, ciudad):
-    if not pais or not estado_ or not ciudad:
-        return "Introduce país, estado y ciudad."
-    resultados = [n for n in nutriologos if n["pais"].lower()==pais.lower() and n["estado"].lower()==estado_.lower() and n["ciudad"].lower()==ciudad.lower()]
-    if not resultados:
-        return "😔 No se encontraron nutriólogos en esa zona aún."
-    salida = "👩‍⚕️ Nutriólogos disponibles:\n"
-    for n in resultados:
-        salida += f"\n• {n['nombre']} — {n['especialidad']}\n  📍 {n['direccion']}\n  📞 {n['contacto']}\n"
-    return salida
-
-def generar_mision_ui():
-    mision = random.choice(misiones)
-    return f"🎯 Tu misión de hoy: {mision}"
-
-# -------------------- INTERFAZ GRADIO --------------------
-with gr.Blocks() as demo:
-    gr.Markdown("# 🥦 NutriBot Ultra — Demo local")
-    # Estado de login en gradio
-    usuario_state = gr.State(value=None)
-    saludo = gr.Markdown("")
-
-    # Columnas: login visible inicialmente
-    with gr.Column():
-        with gr.Box(visible=True) as login_box:
-            gr.Markdown("## 🔐 Iniciar sesión / Registrarse")
-            email_login = gr.Textbox(label="Correo electrónico")
-            pass_login = gr.Textbox(label="Contraseña", type="password")
-            salida_login = gr.Textbox(label="Mensaje")
-
-            nombre_reg = gr.Textbox(label="Nombre completo")
-            email_reg = gr.Textbox(label="Correo electrónico (registro)")
-            pass_reg = gr.Textbox(label="Contraseña (registro)", type="password")
+        return MEMORIA_COACH.setdefault(usuario, [])
+
+# ---------- CHATBOT NUTI ---------- #
+def conversar_nuti(mensaje, email):
+    memoria = obtener_memoria(email, "nuti")
+    memoria.append({"user": mensaje})
+    respuesta = buscar_respuesta(mensaje, memoria)
+    memoria.append({"nuti": respuesta})
+    return respuesta
+
+# ---------- COACH EMOCIONAL ---------- #
+def conversar_coach(mensaje, email):
+    memoria = obtener_memoria(email, "coach")
+    memoria.append({"user": mensaje})
+    respuesta = coach_emocional_inteligente(mensaje, memoria)
+    memoria.append({"coach": respuesta})
+    return respuesta
+
+# ---------- INTERFAZ PRINCIPAL (NutriBot) ---------- #
+def crear_interfaz_nutribot(email):
+    with gr.Blocks(title="NutriBot Ultra 🥗") as app:
+        gr.Markdown(f"## 🌈 ¡Bienvenido, {email}! Tu asistente inteligente de salud y bienestar 🧠💪")
+        gr.Markdown("Habla con Nuti o con tu Coach Emocional, según cómo te sientas hoy 💚")
+
+        with gr.Tab("🤖 Chat con Nuti"):
+            chat_nuti = gr.Chatbot(label="Nuti - Tu guía nutricional")
+            entrada_nuti = gr.Textbox(label="Escribe algo para Nuti")
+            boton_nuti = gr.Button("Enviar")
+            boton_nuti.click(conversar_nuti, inputs=[entrada_nuti, gr.State(email)], outputs=chat_nuti)
+
+        with gr.Tab("🧘 Coach Emocional"):
+            chat_coach = gr.Chatbot(label="Coach Emocional - Bienestar Mental")
+            entrada_coach = gr.Textbox(label="Cuéntame cómo te sientes hoy...")
+            boton_coach = gr.Button("Enviar")
+            boton_coach.click(conversar_coach, inputs=[entrada_coach, gr.State(email)], outputs=chat_coach)
+
+        gr.Button("Cerrar sesión 🚪").click(cerrar_sesion, outputs=None)
+
+    return app
+
+# ---------- LOGIN Y REGISTRO ---------- #
+def interfaz_login():
+    with gr.Blocks(title="Inicio de Sesión - NutriBot Ultra") as login_ui:
+        gr.Markdown("# 🥗 Bienvenido a NutriBot Ultra 🌟\nTu IA de nutrición y bienestar emocional.")
+
+        with gr.Tab("🔑 Iniciar sesión"):
+            email = gr.Textbox(label="Correo electrónico")
+            password = gr.Textbox(label="Contraseña", type="password")
+            boton_login = gr.Button("Entrar")
+            mensaje_login = gr.Textbox(label="Estado")
+            
+            def login_action(email, password):
+                res = iniciar_sesion(email, password)
+                if res.startswith("✅"):
+                    guardar_sesion(email)
+                    return gr.update(visible=False), gr.update(visible=True)
+                return res
+
+            boton_login.click(login_action, inputs=[email, password], outputs=[login_ui, mensaje_login])
+
+        with gr.Tab("📝 Registrarse"):
+            nombre = gr.Textbox(label="Nombre completo")
+            correo = gr.Textbox(label="Correo electrónico")
+            contra = gr.Textbox(label="Contraseña", type="password")
+            boton_reg = gr.Button("Crear cuenta")
             salida_reg = gr.Textbox(label="Resultado del registro")
+            boton_reg.click(registrar_usuario, inputs=[nombre, correo, contra], outputs=salida_reg)
 
-            btn_login = gr.Button("Entrar")
-            btn_reg = gr.Button("Registrarse")
+    return login_ui
 
-        with gr.Box(visible=False) as app_box:
-            # Saludo dinámico
-            saludo_md = gr.Markdown("")
+# ---------- FLUJO PRINCIPAL ---------- #
+def main():
+    usuario_actual = cargar_sesion()
+    if usuario_actual:
+        app = crear_interfaz_nutribot(usuario_actual)
+    else:
+        app = interfaz_login()
+    app.launch()
 
-            # TABS de la app
-            with gr.Tabs():
-                with gr.TabItem("🧍 Tu perfil"):
-                    edad = gr.Number(label="Edad (años)")
-                    peso = gr.Number(label="Peso (kg)")
-                    altura = gr.Number
+if __name__ == "__main__":
+    main()