Update app.py

app.py

@@ -2,9 +2,10 @@ import gradio as gr
 import os
 import json
 import requests
-from mega import Mega
 from datetime import datetime
 import tempfile
+import subprocess
+import sys
 
 GROQ_API_KEY = os.environ.get("GROQ_API_KEY")
 GROQ_API_URL = "https://api.groq.com/openai/v1/chat/completions"
@@ -17,79 +18,94 @@ TOP_P = 0.95
 # Credenciales de MEGA
 MEGA_EMAIL = os.environ.get("MEGA_EMAIL")
 MEGA_PASSWORD = os.environ.get("MEGA_PASSWORD")
-REMOTE_DESTINATION_FOLDER = "Conversations"  # Carpeta en MEGA donde se guardarán las conversaciones
+REMOTE_DESTINATION_FOLDER = "Conversations"
 
-def get_mega_client():
-    """Obtiene un cliente autenticado de MEGA"""
+def install_megapy():
+    """Instala megapy si no está disponible"""
     try:
-        if not MEGA_EMAIL or not MEGA_PASSWORD:
-            print("Error: Credenciales de MEGA no configuradas")
-            return None
-            
-        print(f"Intentando conectar a MEGA con email: {MEGA_EMAIL[:5]}...")
-        mega = Mega()
-        
-        # Intentar login con más información de debug
+        import megapy
+        return True
+    except ImportError:
+        try:
+            subprocess.check_call([sys.executable, "-m", "pip", "install", "megapy"])
+            import megapy
+            return True
+        except Exception as e:
+            print(f"No se pudo instalar megapy: {e}")
+            return False
+
+def get_mega_client_simple():
+    """Intenta conectar usando diferentes métodos"""
+    
+    # Método 1: Intentar mega.py
+    try:
+        from mega import Mega
+        print("Usando mega.py...")
+        mega = Mega({'verbose': False})
         m = mega.login(MEGA_EMAIL, MEGA_PASSWORD)
-        print("Conexión exitosa a MEGA")
-        return m
-        
+        print("Conexión exitosa con mega.py")
+        return m, "mega.py"
     except Exception as e:
-        print(f"Error al conectar con MEGA: {str(e)}")
-        print(f"Tipo de error: {type(e).__name__}")
-        
-        # Intentar con un enfoque alternativo
+        print(f"mega.py falló: {e}")
+    
+    # Método 2: Intentar megapy
+    if install_megapy():
         try:
-            print("Intentando conexión alternativa...")
-            mega = Mega({'verbose': False})
-            m = mega.login(MEGA_EMAIL, MEGA_PASSWORD)
-            print("Conexión alternativa exitosa")
-            return m
-        except Exception as e2:
-            print(f"Error en conexión alternativa: {str(e2)}")
-            return None
+            import megapy
+            print("Usando megapy...")
+            client = megapy.MegaApi()
+            # Aquí implementarías la lógica de megapy
+            print("megapy inicializado (requiere implementación adicional)")
+            return None, "megapy"
+        except Exception as e:
+            print(f"megapy falló: {e}")
+    
+    # Método 3: Usar megatools (si está disponible)
+    try:
+        result = subprocess.run(['which', 'megaput'], capture_output=True, text=True)
+        if result.returncode == 0:
+            print("Encontrado megatools, usando método de línea de comandos")
+            return "megatools", "megatools"
+    except Exception as e:
+        print(f"megatools no disponible: {e}")
+    
+    return None, None
 
-def ensure_conversations_folder(mega_client):
-    """Asegura que existe la carpeta de conversaciones en MEGA"""
+def upload_with_megatools(file_path, remote_path):
+    """Sube archivo usando megatools"""
     try:
-        files = mega_client.get_files()
-        
-        # Buscar si ya existe la carpeta
-        for file_id, file_info in files.items():
-            if file_info['a'] and file_info['a'].get('n') == REMOTE_DESTINATION_FOLDER:
-                return file_id
+        # Configurar credenciales
+        config_content = f"""[Login]
+Username = {MEGA_EMAIL}
+Password = {MEGA_PASSWORD}
+"""
+        config_path = "/tmp/.megarc"
+        with open(config_path, 'w') as f:
+            f.write(config_content)
         
-        # Si no existe, crear la carpeta
-        folder = mega_client.create_folder(REMOTE_DESTINATION_FOLDER)
-        print(f"Carpeta '{REMOTE_DESTINATION_FOLDER}' creada en MEGA")
-        return folder[0]  # Retorna el ID de la carpeta creada
+        # Subir archivo
+        cmd = ['megaput', '--config', config_path, '--path', f'/{REMOTE_DESTINATION_FOLDER}', file_path]
+        result = subprocess.run(cmd, capture_output=True, text=True)
         
+        if result.returncode == 0:
+            print("Archivo subido exitosamente con megatools")
+            return True
+        else:
+            print(f"Error con megatools: {result.stderr}")
+            return False
+            
     except Exception as e:
-        print(f"Error al crear/verificar carpeta en MEGA: {e}")
-        return None
+        print(f"Error usando megatools: {e}")
+        return False
 
-def persist_data(session_data):
-    """Guarda los datos de la sesión en MEGA"""
+def persist_data_simple(session_data):
+    """Versión simplificada para guardar datos"""
     if not MEGA_EMAIL or not MEGA_PASSWORD:
         print("Warning: Credenciales de MEGA no configuradas.")
+        save_locally_as_backup(session_data)
         return
     
     try:
-        # Conectarse a MEGA
-        mega_client = get_mega_client()
-        if not mega_client:
-            print("No se pudo establecer conexión con MEGA. Guardando localmente como respaldo.")
-            # Guardar localmente como respaldo
-            save_locally_as_backup(session_data)
-            return
-        
-        # Asegurar que existe la carpeta de conversaciones
-        conversations_folder_id = ensure_conversations_folder(mega_client)
-        if not conversations_folder_id:
-            print("No se pudo crear/acceder a la carpeta de conversaciones")
-            save_locally_as_backup(session_data)
-            return
-        
         # Formatear el log de la conversación
         formatted_log = ""
         for user_msg, assistant_msg in session_data:
@@ -108,24 +124,57 @@ def persist_data(session_data):
             temp_file_path = temp_file.name
         
         try:
-            # Subir archivo a MEGA en la carpeta específica
-            uploaded_file = mega_client.upload(temp_file_path, conversations_folder_id)
-            
-            # Renombrar el archivo subido
-            mega_client.rename(uploaded_file, log_name)
-            
-            print(f"Log guardado exitosamente en MEGA: {log_name}")
+            # Intentar diferentes métodos de subida
+            mega_client, method = get_mega_client_simple()
             
+            if method == "mega.py" and mega_client:
+                # Método original con mega.py
+                try:
+                    files = mega_client.get_files()
+                    conversations_folder_id = None
+                    
+                    # Buscar carpeta Conversations
+                    for file_id, file_info in files.items():
+                        if file_info['a'] and file_info['a'].get('n') == REMOTE_DESTINATION_FOLDER:
+                            conversations_folder_id = file_id
+                            break
+                    
+                    # Crear carpeta si no existe
+                    if not conversations_folder_id:
+                        folder = mega_client.create_folder(REMOTE_DESTINATION_FOLDER)
+                        conversations_folder_id = folder[0]
+                    
+                    # Subir archivo
+                    uploaded_file = mega_client.upload(temp_file_path, conversations_folder_id)
+                    mega_client.rename(uploaded_file, log_name)
+                    print(f"Log guardado exitosamente en MEGA con mega.py: {log_name}")
+                    
+                except Exception as e:
+                    print(f"Error con mega.py: {e}")
+                    save_locally_as_backup(session_data)
+                    
+            elif method == "megatools":
+                # Usar megatools
+                if upload_with_megatools(temp_file_path, log_name):
+                    print(f"Log guardado con megatools: {log_name}")
+                else:
+                    save_locally_as_backup(session_data)
+            else:
+                # Fallback a guardado local
+                print("No se pudo conectar a MEGA, guardando localmente")
+                save_locally_as_backup(session_data)
+                
         finally:
             # Limpiar archivo temporal
-            os.unlink(temp_file_path)
+            if os.path.exists(temp_file_path):
+                os.unlink(temp_file_path)
             
     except Exception as e:
-        print(f"Error durante la persistencia de datos en MEGA: {e}")
+        print(f"Error durante la persistencia de datos: {e}")
         save_locally_as_backup(session_data)
 
 def save_locally_as_backup(session_data):
-    """Guarda las conversaciones localmente como respaldo cuando MEGA falla"""
+    """Guarda las conversaciones localmente como respaldo"""
     try:
         # Formatear el log de la conversación
         formatted_log = ""
@@ -210,7 +259,7 @@ def respond(message, history: list[tuple[str, str]]):
         yield "Lo siento, ocurrió un error al procesar tu solicitud."
     else:
         current_session = history + [(message, accumulated_response)]
-        persist_data(current_session)
+        persist_data_simple(current_session)
 
 demo = gr.ChatInterface(
     respond,