Create app.py

app.py

@@ -0,0 +1,226 @@
+from flask import Flask, send_from_directory, request, jsonify, render_template
+from flask_cors import CORS
+import os
+from pathlib import Path
+from audio_utils import AudioUtils
+import logging
+import google.generativeai as genai
+import yaml
+from inference import InferenceManager
+from chat_log import ChatLogger
+
+# Configurar logging
+logging.basicConfig(level=logging.DEBUG)
+logger = logging.getLogger(__name__)
+
+app = Flask(__name__)
+CORS(app)
+
+# Cargar configuración
+with open('config.yaml', 'r') as file:
+    config = yaml.safe_load(file)
+
+# Inicializar componentes con mensajes
+try:
+    logger.info("Iniciando sistema...")
+    
+    logger.info("Configurando API de Google...")
+    genai.configure(api_key=config.get('GOOGLE_API_KEY', ''))
+    
+    logger.info("Inicializando sistema de inferencia...")
+    inference = InferenceManager(config)
+    
+    logger.info("Inicializando registro de chat...")
+    chat_logger = ChatLogger()
+    
+    logger.info("Inicializando sistema de audio...")
+    audio_utils = AudioUtils()
+    
+    logger.info("Sistema iniciado correctamente")
+except Exception as e:
+    logger.error(f"Error crítico inicializando el sistema: {e}")
+    raise e
+
+# Configurar el directorio de archivos temporales
+TEMP_AUDIO_DIR = Path("static/temp_audio")
+TEMP_AUDIO_DIR.mkdir(parents=True, exist_ok=True)
+
+@app.after_request
+def after_request(response):
+    # Agregar headers necesarios para ngrok
+    response.headers.add('Accept-Ranges', 'bytes')
+    response.headers.add('Access-Control-Allow-Origin', '*')
+    logger.debug(f"Response headers: {dict(response.headers)}")
+    return response
+
+@app.route('/temp_audio/<path:filename>')
+def serve_audio(filename):
+    try:
+        logger.info(f"Attempting to serve audio file: {filename}")
+        file_path = TEMP_AUDIO_DIR / filename
+        
+        if not file_path.exists():
+            logger.error(f"File not found: {file_path}")
+            return jsonify({'error': 'File not found'}), 404
+            
+        if not filename.endswith(('.wav', '.mp3')):
+            logger.error(f"Invalid file format: {filename}")
+            return jsonify({'error': 'Invalid file format'}), 400
+        
+        logger.info(f"Serving file from: {file_path}")
+        response = send_from_directory(str(TEMP_AUDIO_DIR), filename)
+        response.headers['Content-Type'] = 'audio/wav' if filename.endswith('.wav') else 'audio/mpeg'
+        response.headers['Cache-Control'] = 'no-cache'
+        return response
+        
+    except Exception as e:
+        logger.error(f"Error serving audio file: {e}", exc_info=True)
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/generate_audio', methods=['POST'])
+def generate_audio():
+    try:
+        text = request.json.get('text')
+        model = request.json.get('model', 'EDGE')  # EDGE como default
+        logger.info(f"Generando audio para texto: '{text}' usando modelo: {model}")
+        
+        if not text:
+            logger.error("No se proporcionó texto")
+            return jsonify({'error': 'No text provided'}), 400
+        
+        try:
+            temp_audio_utils = AudioUtils(model_name=model)
+            audio_file = temp_audio_utils.text_to_speech(text, return_file=True)
+            
+            if not audio_file:
+                logger.error(f"Fallo al generar audio con {model}, intentando con EDGE")
+                temp_audio_utils = AudioUtils(model_name='EDGE')
+                audio_file = temp_audio_utils.text_to_speech(text, return_file=True)
+        except Exception as e:
+            logger.error(f"Error con modelo {model}, usando EDGE: {e}")
+            temp_audio_utils = AudioUtils(model_name='EDGE')
+            audio_file = temp_audio_utils.text_to_speech(text, return_file=True)
+        
+        if audio_file:
+            audio_url = f'/temp_audio/{audio_file}'
+            logger.info(f"Audio generado: {audio_url}")
+            
+            file_path = TEMP_AUDIO_DIR / audio_file
+            if not file_path.exists():
+                logger.error(f"Archivo no encontrado: {file_path}")
+                return jsonify({
+                    'error': 'Generated file not found',
+                    'details': 'El archivo de audio no se generó correctamente'
+                }), 500
+                
+            return jsonify({
+                'audio_url': audio_url,
+                'model_used': temp_audio_utils.current_model
+            })
+        
+        return jsonify({
+            'error': 'Failed to generate audio',
+            'details': 'No se pudo generar el audio con ningún modelo'
+        }), 500
+        
+    except Exception as e:
+        logger.error(f"Error crítico generando audio: {e}", exc_info=True)
+        return jsonify({
+            'error': str(e),
+            'details': 'Error interno del servidor al generar audio'
+        }), 500
+
+@app.route('/static/<path:path>')
+def send_static(path):
+    logger.debug(f"Serving static file: {path}")
+    return send_from_directory('static', path)
+
+@app.route('/')
+def home():
+    # Agregar mensajes iniciales
+    initial_messages = [{
+        'role': 'assistant',
+        'content': 'Sistema iniciado. Todos los modelos cargados correctamente.'
+    }]
+    return render_template('chat.html', messages=initial_messages)
+
+@app.route('/chat', methods=['POST'])
+def chat():
+    try:
+        message = request.json.get('message')
+        mode = request.json.get('mode', 'seguros')  # Modo por defecto
+        
+        if not message:
+            return jsonify({'error': 'No message provided'}), 400
+            
+        # Registrar mensaje del usuario
+        chat_logger.log_message(message, is_user=True)
+        
+        # Obtener respuesta usando el sistema de inferencia
+        response = inference.get_response(message, mode)
+        
+        if response:
+            # Registrar respuesta del bot
+            chat_logger.log_message(response, is_user=False)
+            
+            return jsonify({
+                'response': response
+            })
+        
+        return jsonify({'error': 'No response generated'}), 500
+        
+    except Exception as e:
+        logger.error(f"Error in chat endpoint: {e}", exc_info=True)
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/change_mode', methods=['POST'])
+def change_mode():
+    try:
+        mode = request.json.get('mode')
+        if mode not in ['seguros', 'creditos', 'cobranza']:
+            return jsonify({'error': 'Invalid mode'}), 400
+            
+        # Actualizar modo en el sistema de inferencia
+        inference.mode = mode
+        
+        return jsonify({'success': True})
+    except Exception as e:
+        logger.error(f"Error changing mode: {e}")
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/change_model', methods=['POST'])
+def change_model():
+    try:
+        model = request.json.get('model')
+        if model not in ['Gemini 8b', 'Mixtral 7b']:
+            return jsonify({'error': 'Invalid model'}), 400
+            
+        inference.current_model = model
+        
+        return jsonify({'success': True})
+    except Exception as e:
+        logger.error(f"Error changing model: {e}")
+        return jsonify({'error': str(e)}), 500
+
+@app.route('/change_tts', methods=['POST'])
+def change_tts():
+    try:
+        model = request.json.get('model')
+        if model not in ['EDGE', 'VITS', 'gTTS']:
+            return jsonify({'error': 'Invalid TTS model'}), 400
+            
+        # Actualizar modelo TTS
+        audio_utils = AudioUtils(model_name=model)
+        
+        return jsonify({'success': True})
+    except Exception as e:
+        logger.error(f"Error changing TTS model: {e}")
+        return jsonify({'error': str(e)}), 500
+
+if __name__ == "__main__":
+    try:
+        logger.info("Iniciando servidor...")
+        # Cambiar para que funcione en Hugging Face Spaces
+        app.run(host='0.0.0.0', port=7860)  # Puerto estándar de Spaces
+    except Exception as e:
+        logger.error(f"Error al iniciar la aplicación: {e}", exc_info=True)