Update app.py

app.py

@@ -1,5 +1,6 @@
-# app.py - MateAI v18.3: Conciencia Aumentada
+# app.py - MateAI v18.3.1: Conciencia Aumentada (Hotfix de Compatibilidad)
 # Arquitectura por un asistente de IA para un futuro colaborativo.
+# Cambio: Se reemplaza gr.Box por gr.Group para compatibilidad con versiones antiguas de Gradio.
 
 import gradio as gr
 import random
@@ -30,14 +31,12 @@ from firebase_admin import credentials, firestore
 class Config:
     """Clase de configuración central para todos los parámetros de MateAI."""
     APP_NAME = "MateAI v18.3: Conciencia Aumentada"
-    APP_VERSION = "18.3.0-alpha"
+    APP_VERSION = "18.3.1-hotfix"
     
     # --- Configuración de Base de Datos ---
     FIREBASE_COLLECTION_USERS = "users_v18" # Nueva colección para la arquitectura avanzada.
     
     # --- Parámetros del Motor de Personalidad (Basado en el Modelo OCEAN) ---
-    # Estos son los valores iniciales para un nuevo usuario.
-    # El rango de cada rasgo es de -1.0 (bajo) a 1.0 (alto).
     DEFAULT_PSYCH_PROFILE = {
         "openness": 0.0,          # Apertura a nuevas experiencias
         "conscientiousness": 0.0, # Organización y responsabilidad
@@ -65,16 +64,14 @@ class Config:
 # ==============================================================================
 
 # --- Configuración de Logging ---
-# Un buen logging es crucial para depurar un sistema complejo.
 logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
 
 # --- Inicialización del Analizador de Sentimiento ---
-# Cargamos el modelo una vez para no recargarlo en cada request.
+sentiment_analyzer = None
 try:
     sentiment_analyzer = create_analyzer(task="sentiment", lang="es")
     logging.info("Analizador de sentimiento cargado exitosamente.")
 except Exception as e:
-    sentiment_analyzer = None
     logging.error(f"No se pudo cargar el analizador de sentimiento: {e}")
 
 # --- Inicialización de Firebase Admin SDK ---
@@ -84,7 +81,6 @@ try:
         firebase_credentials_json = os.getenv('GOOGLE_APPLICATION_CREDENTIALS_JSON')
         if firebase_credentials_json:
             cred_dict = json.loads(firebase_credentials_json)
-            # Aseguramos el project_id si no está en el JSON (común en algunos entornos)
             if 'project_id' not in cred_dict:
                 cred_dict['project_id'] = 'mateai-815ca' # Reemplazar con tu project_id real si es diferente
             cred = credentials.Certificate(cred_dict)
@@ -102,10 +98,6 @@ except Exception as e:
 # ==============================================================================
 # MÓDULO 3: MODELOS DE DATOS Y CLASES CENTRALES
 # ==============================================================================
-# Definen la estructura de los datos con los que operamos. La clase User
-# es el corazón del sistema, representando el estado completo de un individuo.
-# ==============================================================================
-
 class User:
     """Representa el estado completo de un usuario, incluyendo su personalidad y memoria."""
     def __init__(self, user_id: str, name: str, **kwargs: Any):
@@ -113,96 +105,61 @@ class User:
         self.name: str = name
         self.created_at: datetime = kwargs.get('created_at', datetime.now())
         self.last_login: datetime = kwargs.get('last_login', datetime.now())
-        
-        # El perfil psicológico, la joya de la corona.
         self.psych_profile: Dict[str, float] = kwargs.get('psych_profile', Config.DEFAULT_PSYCH_PROFILE.copy())
-        
-        # Memoria a corto y largo plazo.
         self.memory_stream: List[Dict[str, Any]] = kwargs.get('memory_stream', [])
-        self.short_term_context: Dict[str, Any] = {} # No se persiste, es para la sesión actual.
-        
-        # Sistema de metas, reemplaza a las simples "tareas".
+        self.short_term_context: Dict[str, Any] = {}
         self.goals: List[Dict[str, Any]] = kwargs.get('goals', [])
-        
-        # Gamificación con propósito.
         self.connection_points: int = kwargs.get('connection_points', 0)
         self.achievements: List[str] = kwargs.get('achievements', [])
-        
-        # Metadata para la proactividad.
         self.last_proactive_checkin: Optional[datetime] = kwargs.get('last_proactive_checkin')
 
     def to_dict(self) -> Dict[str, Any]:
         """Serializa el objeto User a un diccionario para guardarlo en Firestore."""
         return {
-            "user_id": self.user_id,
-            "name": self.name,
-            "created_at": self.created_at.isoformat(),
-            "last_login": self.last_login.isoformat(),
-            "psych_profile": self.psych_profile,
-            "memory_stream": self.memory_stream,
-            "goals": self.goals,
-            "connection_points": self.connection_points,
-            "achievements": self.achievements,
+            "user_id": self.user_id, "name": self.name, "created_at": self.created_at.isoformat(),
+            "last_login": self.last_login.isoformat(), "psych_profile": self.psych_profile,
+            "memory_stream": self.memory_stream, "goals": self.goals,
+            "connection_points": self.connection_points, "achievements": self.achievements,
             "last_proactive_checkin": self.last_proactive_checkin.isoformat() if self.last_proactive_checkin else None
         }
 
     @classmethod
     def from_dict(cls, data: Dict[str, Any]) -> 'User':
         """Crea una instancia de User a partir de un diccionario de Firestore."""
-        # Conversión de fechas de ISO string a datetime
         data['created_at'] = datetime.fromisoformat(data.get('created_at', datetime.now().isoformat()))
         data['last_login'] = datetime.fromisoformat(data.get('last_login', datetime.now().isoformat()))
         last_checkin_str = data.get('last_proactive_checkin')
         data['last_proactive_checkin'] = datetime.fromisoformat(last_checkin_str) if last_checkin_str else None
-        
-        # Aseguramos que el perfil psicológico tenga todas las claves
         profile = Config.DEFAULT_PSYCH_PROFILE.copy()
         profile.update(data.get('psych_profile', {}))
         data['psych_profile'] = profile
-
         return cls(**data)
         
     def add_memory(self, content: str, memory_type: str, sentiment: Dict[str, float], tags: List[str] = []):
         """Añade un nuevo recuerdo al flujo de memoria del usuario."""
         if len(self.memory_stream) >= Config.MAX_MEMORY_STREAM_ITEMS:
-            self.memory_stream.pop(0) # Mantiene el tamaño del flujo de memoria
-        
-        memory = {
-            "timestamp": datetime.now().isoformat(),
-            "content": content,
-            "type": memory_type, # 'chat', 'insight', 'goal_set', 'goal_completed'
-            "sentiment": sentiment,
-            "tags": tags
-        }
+            self.memory_stream.pop(0)
+        memory = {"timestamp": datetime.now().isoformat(), "content": content, "type": memory_type, "sentiment": sentiment, "tags": tags}
         self.memory_stream.append(memory)
         logging.info(f"Nuevo recuerdo añadido para {self.name}: {content[:50]}...")
 
 # ==============================================================================
 # MÓDULO 4: GESTOR DE DATOS DE USUARIO (CAPA DE PERSISTENCIA)
 # ==============================================================================
-# Abstrae toda la lógica de comunicación con Firestore. Permite cambiar
-# de base de datos en el futuro sin alterar el resto del código.
-# ==============================================================================
-
 class UserManager:
     """Maneja la carga, creación y actualización de perfiles de usuario en Firestore."""
-    
     @staticmethod
     async def get_user(user_id: str) -> Optional[User]:
-        """Carga un usuario desde Firestore por su ID."""
         if not db or not user_id: return None
         try:
             user_doc_ref = db.collection(Config.FIREBASE_COLLECTION_USERS).document(user_id)
             doc = await asyncio.to_thread(user_doc_ref.get)
             if doc.exists:
                 user_data = doc.to_dict()
-                user_data['user_id'] = doc.id # Aseguramos que el ID esté en los datos.
-                
-                # Actualizar la fecha de último login y guardar inmediatamente.
+                user_data['user_id'] = doc.id
                 user_obj = User.from_dict(user_data)
                 user_obj.last_login = datetime.now()
-                await UserManager.save_user(user_obj) # Guardado asíncrono
-                
+                await UserManager.save_user(user_obj)
                 logging.info(f"Usuario '{user_obj.name}' ({user_id}) cargado y actualizado.")
                 return user_obj
             else:
@@ -214,15 +171,11 @@ class UserManager:
 
     @staticmethod
     async def create_user(name: str) -> Tuple[Optional[User], str]:
-        """Crea un nuevo usuario en Firestore."""
         if not db: return None, "Error: La base de datos no está disponible."
         if not name.strip(): return None, "El nombre no puede estar vacío."
-        
         try:
-            # Generamos un ID de usuario único y legible.
             user_id = f"{name.lower().replace(' ', '_')}_{int(time.time())}"
             new_user = User(user_id=user_id, name=name)
-            
             await UserManager.save_user(new_user)
             msg = f"¡Bienvenido, {name}! Tu perfil ha sido creado. Guarda bien tu ID de Usuario: **{user_id}**"
             logging.info(f"Nuevo usuario creado: {name} ({user_id})")
@@ -233,7 +186,6 @@ class UserManager:
 
     @staticmethod
     async def save_user(user: User) -> bool:
-        """Guarda el estado completo de un objeto User en Firestore."""
         if not db: return False
         try:
             user_doc_ref = db.collection(Config.FIREBASE_COLLECTION_USERS).document(user.user_id)
@@ -246,25 +198,14 @@ class UserManager:
 # ==============================================================================
 # MÓDULO 5: MOTOR DE PERSONA Y LÓGICA DE IA
 # ==============================================================================
-# Este es el cerebro de MateAI. Aquí se toma el perfil del usuario,
-# el contexto actual y el mensaje para generar una respuesta coherente,
-# empática y personalizada.
-# ==============================================================================
-
 class PersonaEngine:
     """Orquesta la lógica de IA para generar respuestas y gestionar la interacción."""
-    
     def __init__(self, user: User):
         self.user = user
 
     async def analyze_sentiment(self, text: str) -> Dict[str, float]:
-        """Analiza el sentimiento del texto del usuario."""
-        if not sentiment_analyzer:
-            # Fallback si el modelo no cargó.
-            return {"label": "NEU", "score": 1.0}
-        
+        if not sentiment_analyzer: return {"label": "NEU", "score": 1.0}
         try:
-            # Ejecutamos el análisis en un hilo separado para no bloquear la app.
             analysis = await asyncio.to_thread(sentiment_analyzer.predict, text)
             return {"label": analysis.output, "score": analysis.probas[analysis.output]}
         except Exception as e:
@@ -272,13 +213,10 @@ class PersonaEngine:
             return {"label": "NEU", "score": 1.0}
 
     def _get_greeting(self) -> str:
-        """Genera un saludo personalizado basado en la hora y el perfil."""
         hour = datetime.now().hour
         if 5 <= hour < 12: time_greeting = "Buen día"
         elif 12 <= hour < 19: time_greeting = "Buenas tardes"
         else: time_greeting = "Buenas noches"
-
-        # Personalización del saludo
         if self.user.psych_profile['extraversion'] > 0.5:
             return f"¡{time_greeting}, {self.user.name}! ¡Qué bueno verte! ¿En qué andamos hoy?"
         elif self.user.psych_profile['neuroticism'] > 0.4:
@@ -287,73 +225,41 @@ class PersonaEngine:
             return f"{time_greeting}, {self.user.name}. Un gusto conectar de nuevo."
 
     async def generate_proactive_checkin(self) -> Optional[str]:
-        """Genera un mensaje proactivo si ha pasado suficiente tiempo."""
         now = datetime.now()
-        if self.user.last_proactive_checkin:
-            if now - self.user.last_proactive_checkin < timedelta(hours=Config.PROACTIVE_CHECKIN_HOURS):
-                return None # Aún no es tiempo.
-
-        # Lógica de check-in
+        if self.user.last_proactive_checkin and (now - self.user.last_proactive_checkin < timedelta(hours=Config.PROACTIVE_CHECKIN_HOURS)):
+            return None
         self.user.last_proactive_checkin = now
         await UserManager.save_user(self.user)
-        
-        # Ejemplo de check-in personalizado
         if self.user.psych_profile['conscientiousness'] > 0.5 and self.user.goals:
             pending_goals = [g['name'] for g in self.user.goals if not g.get('completed')]
             if pending_goals:
                 return f"¡Hola {self.user.name}! Solo pasaba a saludar y recordarte que tenés metas increíbles como '{pending_goals[0]}' en marcha. ¡Cualquier pasito cuenta!"
-        
         return self._get_greeting() + " Solo pasaba a ver cómo estabas."
         
     async def generate_response(self, message: str) -> str:
-        """El método principal que genera la respuesta de MateAI a un mensaje."""
-        # 1. Analizar el sentimiento del mensaje del usuario
         sentiment = await self.analyze_sentiment(message)
-        
-        # 2. Registrar el mensaje en la memoria del usuario
         self.user.add_memory(content=message, memory_type="chat", sentiment=sentiment)
-
-        # 3. Lógica de respuesta basada en triggers y perfil
-        # TODO: Implementar un sistema de comandos más robusto (ej. /metas, /perfil)
-        
-        # 3.1 Manejo de respuestas empáticas a sentimientos fuertes
         if sentiment['label'] == 'NEG' and sentiment['score'] > 0.7:
              return f"Noto que lo que decís tiene una carga fuerte, {self.user.name}. Si querés hablar de ello, acá estoy para escucharte sin juzgar."
-
-        # 3.2 Lógica de preguntas para construir el perfil (si aún es genérico)
-        # Esta es la parte de "tricky psychological questions"
-        if abs(sum(self.user.psych_profile.values())) < 0.1: # Perfil casi virgen
+        if abs(sum(self.user.psych_profile.values())) < 0.1:
             return await self._ask_profiling_question()
-            
-        # 3.3 Respuesta por defecto (placeholder para lógica más compleja)
-        # Aquí se integraría con un LLM si lo tuviéramos.
-        # Por ahora, una respuesta reflexiva basada en el perfil.
-        
         response = self._craft_default_response(sentiment)
-        
-        # 4. Guardar el estado actualizado del usuario
         await UserManager.save_user(self.user)
-        
         return response
 
     def _craft_default_response(self, sentiment: Dict[str, float]) -> str:
-        """Crea una respuesta genérica pero personalizada."""
         responses = [
             f"Interesante lo que mencionás, {self.user.name}. Me hace pensar en...",
             f"Entiendo tu punto, {self.user.name}. ¿Cómo se conecta eso con tus metas actuales?",
-            f"Gracias por compartir eso. Cada charla nos ayuda a entendernos mejor.",
+            "Gracias por compartir eso. Cada charla nos ayuda a entendernos mejor.",
         ]
-        
         if self.user.psych_profile['openness'] > 0.5:
-            responses.append(f"Eso abre una puerta a una idea nueva. ¿Qué pasaría si lo miramos desde otro ángulo?")
+            responses.append("Eso abre una puerta a una idea nueva. ¿Qué pasaría si lo miramos desde otro ángulo?")
         if sentiment['label'] == 'POS':
             responses.append(f"¡Me encanta esa energía, {self.user.name}! Es genial verte así.")
-            
         return random.choice(responses)
 
     async def _ask_profiling_question(self) -> str:
-        """Selecciona y hace una pregunta sutil para definir el perfil psicológico."""
-        # Ejemplo de pregunta para medir "Apertura a la experiencia" vs "Consciencia"
         question = (
             f"Una pregunta curiosa, {self.user.name}: si tuvieras una tarde libre inesperada, "
             "¿qué te tienta más? \n"
@@ -365,10 +271,8 @@ class PersonaEngine:
         return question
 
     def process_profiling_answer(self, answer: str):
-        """Procesa la respuesta a una pregunta de perfilado y actualiza el psych_profile."""
         question_type = self.user.short_term_context.get('last_question')
         if not question_type: return
-
         answer_lower = answer.lower()
         if question_type == "openness_vs_conscientiousness":
             if 'a' in answer_lower or 'improvisar' in answer_lower:
@@ -377,27 +281,14 @@ class PersonaEngine:
             elif 'b' in answer_lower or 'organizar' in answer_lower:
                 self.user.psych_profile['conscientiousness'] += 0.3
                 self.user.psych_profile['openness'] -= 0.1
-        
-        # Limpiamos el contexto para no procesar de nuevo.
         del self.user.short_term_context['last_question']
-        
-        # Añadimos puntos por la introspección
         self.user.connection_points += Config.POINTS_PER_INSIGHT
         logging.info(f"Perfil de {self.user.name} actualizado. Puntos: {self.user.connection_points}")
 
-
 # ==============================================================================
 # MÓDULO 6: LÓGICA Y ESTRUCTURA DE LA INTERFAZ DE USUARIO (GRADIO)
 # ==============================================================================
-# Aquí se conectan todos los módulos anteriores con la interfaz gráfica.
-# Las funciones aquí son "controladores" que reciben eventos de la UI
-# y orquestan las acciones de los motores de backend.
-# ==============================================================================
-
-# --- Funciones de Lógica de la Interfaz ---
-
 async def handle_login_or_creation(action: str, name: str, user_id: str) -> tuple:
-    """Controlador para los botones de login y creación."""
     if action == "create":
         if not name:
             gr.Warning("Para crear un perfil, necesito que me digas tu nombre.")
@@ -411,10 +302,8 @@ async def handle_login_or_creation(action: str, name: str, user_id: str) -> tupl
         msg = f"¡Hola de nuevo, {user.name}! Perfil cargado." if user else "ID de usuario no encontrado. Verificá que esté bien escrito."
     else:
         return None, "Acción desconocida.", gr.update(visible=True), gr.update(visible=False)
-
     if user:
         gr.Success(msg)
-        # Al loguearse, ocultamos el panel de login y mostramos el de chat.
         initial_greeting = PersonaEngine(user)._get_greeting()
         chat_history = [{"role": "assistant", "content": initial_greeting}]
         return user, chat_history, gr.update(visible=False), gr.update(visible=True)
@@ -423,70 +312,47 @@ async def handle_login_or_creation(action: str, name: str, user_id: str) -> tupl
         return None, gr.update(), gr.update(visible=True), gr.update(visible=False)
 
 async def handle_chat_message(user_state: User, message: str, chat_history: List[Dict]) -> tuple:
-    """Controlador principal para cada mensaje enviado por el usuario."""
     if not user_state:
         gr.Warning("¡Para empezar, creá un perfil o iniciá sesión!")
         return user_state, chat_history, ""
-
-    # Agregamos el mensaje del usuario a la UI inmediatamente para dar feedback visual.
     chat_history.append({"role": "user", "content": message})
-    
-    # Creamos una instancia del motor de persona con el estado actual del usuario.
     engine = PersonaEngine(user_state)
-
-    # Verificamos si la respuesta es a una pregunta de perfilado.
     if user_state.short_term_context.get('last_question'):
         engine.process_profiling_answer(message)
         response = "¡Bárbaro! Gracias por compartirlo. Lo tengo en cuenta para que nos entendamos mejor."
     else:
-        # Si no, generamos una respuesta normal.
         response = await engine.generate_response(message)
-    
-    # Agregamos la respuesta de MateAI al historial.
     chat_history.append({"role": "assistant", "content": response})
-    
-    # El estado del usuario (user_state) ha sido modificado por el engine,
-    # así que lo devolvemos para actualizar el gr.State
-    return user_state, chat_history, "" # Limpiamos el textbox de input
+    return user_state, chat_history, ""
 
 def render_profile_info(user: Optional[User]) -> str:
-    """Genera un texto Markdown con la información del perfil del usuario."""
-    if not user:
-        return "Cargá un perfil para ver tu información."
-        
+    if not user: return "Cargá un perfil para ver tu información."
     profile_md = f"### Perfil de {user.name}\n"
     profile_md += f"**ID de Usuario:** `{user.user_id}`\n"
     profile_md += f"**Puntos de Conexión:** {user.connection_points} 💠\n\n"
     profile_md += "#### Modelo de Personalidad (inferido):\n"
     for trait, value in user.psych_profile.items():
-        # Visualización simple del rasgo
-        bar = "■" * int((value + 1) * 5)  # Escala de 0 a 10
+        bar = "■" * int((value + 1) * 5)
         profile_md += f"- **{trait.capitalize()}:** `{f'{value:.2f}'}` {bar}\n"
-    
     return profile_md
 
 # --- Construcción de la Interfaz con Gradio Blocks ---
-
 with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="amber"), css="footer {display: none !important}") as demo:
-    
-    # Estado de la aplicación: el objeto User se mantiene aquí durante toda la sesión.
     current_user = gr.State(None)
-    
     gr.Markdown(f"# 🧉 {Config.APP_NAME}")
     gr.Markdown(f"*{Config.APP_VERSION}* - Tu compañero de IA para la introspección y el crecimiento.")
 
     with gr.Row():
-        # Columna de la izquierda: Chat y Perfil
         with gr.Column(scale=2):
-            # Panel de Chat (inicialmente oculto)
-            with gr.Box(visible=False) as chat_panel:
+            # Panel de Chat - Usando gr.Group en lugar de gr.Box para compatibilidad
+            with gr.Group(visible=False) as chat_panel:
                 chatbot = gr.Chatbot(label="Conversación con MateAI", height=600, type="messages")
                 with gr.Row():
                     chat_input = gr.Textbox(show_label=False, placeholder="Escribí acá con confianza...", scale=4)
                     send_button = gr.Button("Enviar", variant="primary", scale=1)
 
-            # Panel de Login (inicialmente visible)
-            with gr.Box(visible=True) as login_panel:
+            # Panel de Login - Usando gr.Group en lugar de gr.Box para compatibilidad
+            with gr.Group(visible=True) as login_panel:
                 gr.Markdown("### 🌟 Para empezar...")
                 with gr.Tabs():
                     with gr.TabItem("Crear Perfil Nuevo"):
@@ -496,47 +362,20 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="amber"),
                         userid_input = gr.Textbox(label="Tu ID de Usuario")
                         login_button = gr.Button("Cargar Perfil")
         
-        # Columna de la derecha: Información de contexto
         with gr.Column(scale=1):
-            with gr.Box():
+            # Panel de Perfil - Usando gr.Group en lugar de gr.Box para compatibilidad
+            with gr.Group():
                 gr.Markdown("### 🧠 Tu Perfil")
                 profile_display = gr.Markdown("Cargá un perfil para ver tu información.")
 
     # --- Lógica de Eventos de la Interfaz ---
-
-    # Acciones de Login y Creación
-    login_button.click(
-        fn=handle_login_or_creation, 
-        inputs=[gr.State("login"), username_input, userid_input], 
-        outputs=[current_user, chatbot, login_panel, chat_panel]
-    )
-    create_button.click(
-        fn=handle_login_or_creation, 
-        inputs=[gr.State("create"), username_input, userid_input], 
-        outputs=[current_user, chatbot, login_panel, chat_panel]
-    )
+    login_button.click(fn=handle_login_or_creation, inputs=[gr.State("login"), username_input, userid_input], outputs=[current_user, chatbot, login_panel, chat_panel])
+    create_button.click(fn=handle_login_or_creation, inputs=[gr.State("create"), username_input, userid_input], outputs=[current_user, chatbot, login_panel, chat_panel])
     
-    # Acción de enviar mensaje en el chat
-    chat_submit_action = send_button.click if send_button else chat_input.submit
-    chat_submit_action(
-        fn=handle_chat_message,
-        inputs=[current_user, chat_input, chatbot],
-        outputs=[current_user, chatbot, chat_input]
-    )
-    chat_input.submit(
-        fn=handle_chat_message,
-        inputs=[current_user, chat_input, chatbot],
-        outputs=[current_user, chatbot, chat_input]
-    )
+    chat_input.submit(fn=handle_chat_message, inputs=[current_user, chat_input, chatbot], outputs=[current_user, chatbot, chat_input])
+    send_button.click(fn=handle_chat_message, inputs=[current_user, chat_input, chatbot], outputs=[current_user, chatbot, chat_input])
 
-    # Actualización dinámica del panel de perfil cuando cambia el estado del usuario
-    current_user.change(
-        fn=render_profile_info,
-        inputs=[current_user],
-        outputs=[profile_display]
-    )
+    current_user.change(fn=render_profile_info, inputs=[current_user], outputs=[profile_display])
 
 if __name__ == "__main__":
-    # Para lanzar la aplicación
-    # En un entorno de producción como Hugging Face Spaces, no es necesario debug=True
     demo.launch(debug=True)