Update app.py

app.py

@@ -1,138 +1,55 @@
-import os
-from flask import Flask, request, jsonify
+# gtts_server.py
+#
+# Requisitos:
+# pip install Flask gTTS Flask-Cors
+#
+# Cómo ejecutar:
+# python gtts_server.py
+#
+# El servidor se ejecutará en http://localhost:5000
+
+from flask import Flask, request, jsonify, send_file
 from flask_cors import CORS
-import requests
-import sys # Import sys for flush
+from gtts import gTTS
+from io import BytesIO
 
+# Inicializar la aplicación Flask
 app = Flask(__name__)
-CORS(app)
-
-# Obtener la API key de las variables de entorno de Hugging Face
-# Asegúrate de que el secret/variable en Hugging Face se llama GEMINI_API_KEY
-GEMINI_API_KEY = os.getenv("GEMINI_API_KEY")
-
-if not GEMINI_API_KEY:
-    print("WARNING: GEMINI_API_KEY environment variable is NOT configured. Google API calls will fail.", file=sys.stderr, flush=True)
-else:
-    print("INFO: GEMINI_API_KEY successfully loaded from environment.", flush=True)
-
-@app.route('/')
-def home():
-    """Serves the main page (index.html)."""
-    # In a Hugging Face Space, index.html is usually served automatically
-    print("INFO: Received request for root path. Serving placeholder text.", flush=True)
-    return "Flask backend is running. Access /index.html if it does not load automatically."
-
-@app.route('/generate_image', methods=['POST'])
-def generate_image():
-    """Endpoint para generar imágenes usando Google Imagen."""
-    print("INFO: Received /generate_image POST request.", flush=True)
-    data = request.get_json()
-    prompt = data.get('prompt')
-
-    if not prompt:
-        print("ERROR: No prompt provided for image generation.", file=sys.stderr, flush=True)
-        return jsonify({"error": "No se proporcionó un prompt para la imagen."}), 400
-
-    if not GEMINI_API_KEY:
-        print("ERROR: API Key is not configured for image generation.", file=sys.stderr, flush=True)
-        return jsonify({"error": "La clave API no está configurada en el backend."}), 500
-
-    url = f"https://generativelanguage.googleapis.com/v1beta/models/imagen-3.0-generate-002:predict?key={GEMINI_API_KEY}"
-    headers = {'Content-Type': 'application/json'}
-    payload = {
-        "instances": {"prompt": prompt},
-        "parameters": {"sampleCount": 1}
-    }
-
-    try:
-        print(f"INFO: Calling Imagen API with prompt: '{prompt[:50]}...'", flush=True)
-        response = requests.post(url, headers=headers, json=payload, timeout=60) # Added timeout
-        response.raise_for_status() # Raise an exception for HTTP 4xx or 5xx errors
-        result = response.json()
-        print("INFO: Successfully received response from Imagen API.", flush=True)
 
-        if result.get('predictions') and len(result['predictions']) > 0 and result['predictions'][0].get('bytesBase64Encoded'):
-            image_base64 = result['predictions'][0]['bytesBase64Encoded']
-            image_url = f"data:image/png;base64,{image_base64}"
-            print("INFO: Image base64 extracted successfully.", flush=True)
-            return jsonify({"imageUrl": image_url})
-        else:
-            print(f"ERROR: No valid image data found in Imagen API response: {result}", file=sys.stderr, flush=True)
-            return jsonify({"error": "No se recibió una imagen válida de la API de Google Imagen."}), 500
-
-    except requests.exceptions.HTTPError as http_err:
-        print(f"ERROR: HTTP error from Imagen API: {http_err.response.status_code} - {http_err.response.text}", file=sys.stderr, flush=True)
-        return jsonify({"error": f"Error de la API de Imagen ({http_err.response.status_code}): {http_err.response.text}"}), 500
-    except requests.exceptions.ConnectionError as conn_err:
-        print(f"ERROR: Connection error to Imagen API: {conn_err}", file=sys.stderr, flush=True)
-        return jsonify({"error": f"Error de conexión con la API de Imagen: {conn_err}"}), 500
-    except requests.exceptions.Timeout as timeout_err:
-        print(f"ERROR: Timeout error with Imagen API: {timeout_err}", file=sys.stderr, flush=True)
-        return jsonify({"error": f"La solicitud a la API de Imagen tardó demasiado (timeout): {timeout_err}"}), 500
-    except requests.exceptions.RequestException as req_err:
-        print(f"ERROR: General request error with Imagen API: {req_err}", file=sys.stderr, flush=True)
-        return jsonify({"error": f"Error al comunicarse con la API de generación de imágenes: {req_err}"}), 500
-    except Exception as e:
-        print(f"CRITICAL ERROR: Unexpected error generating image: {e}", file=sys.stderr, exc_info=True, flush=True) # exc_info for traceback
-        return jsonify({"error": f"Error inesperado al generar imagen: {e}"}), 500
-
-
-@app.route('/generate_text', methods=['POST'])
-def generate_text():
-    """Endpoint para generar texto usando Google Gemini-Flash."""
-    print("INFO: Received /generate_text POST request.", flush=True)
-    data = request.get_json()
-    prompt = data.get('prompt')
-
-    if not prompt:
-        print("ERROR: No prompt provided for text generation.", file=sys.stderr, flush=True)
-        return jsonify({"error": "No se proporcionó un prompt para el texto."}), 400
-
-    if not GEMINI_API_KEY:
-        print("ERROR: API Key is not configured for text generation.", file=sys.stderr, flush=True)
-        return jsonify({"error": "La clave API no está configurada en el backend."}), 500
-
-    url = f"https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent?key={GEMINI_API_KEY}"
-    headers = {'Content-Type': 'application/json'}
-    payload = {
-        "contents": [{"role": "user", "parts": [{"text": prompt}]}]
-    }
+# Habilitar CORS para permitir peticiones desde el navegador (frontend)
+CORS(app)
 
+@app.route('/api/tts', methods=['POST'])
+def text_to_speech():
+    """
+    Endpoint para convertir texto a voz.
+    Recibe un JSON con la clave "text" y devuelve un archivo de audio MP3.
+    """
     try:
-        print(f"INFO: Calling Gemini API with prompt: '{prompt[:50]}...'", flush=True)
-        response = requests.post(url, headers=headers, json=payload, timeout=60) # Added timeout
-        response.raise_for_status() # Raise an exception for HTTP 4xx or 5xx errors
-        result = response.json()
-        print("INFO: Successfully received response from Gemini API.", flush=True)
-
-        if result.get('candidates') and len(result['candidates']) > 0 and \
-           result['candidates'][0].get('content') and result['candidates'][0]['content'].get('parts') and \
-           len(result['candidates'][0]['content']['parts']) > 0:
-            generated_text = result['candidates'][0]['content']['parts'][0]['text']
-            print("INFO: Text extracted successfully from Gemini API response.", flush=True)
-            return jsonify({"text": generated_text})
-        else:
-            print(f"ERROR: No valid text data found in Gemini API response: {result}", file=sys.stderr, flush=True)
-            return jsonify({"error": "No se recibió texto válido de la API de Google Gemini."}), 500
+        data = request.get_json()
+        text_to_speak = data.get('text')
+
+        if not text_to_speak:
+            return jsonify({"error": "No se proporcionó texto (clave 'text')."}), 400
+
+        # Generar el audio con acento de México
+        tts = gTTS(text=text_to_speak, lang='es', tld='com.mx', slow=False)
+        
+        mp3_fp = BytesIO()
+        tts.write_to_fp(mp3_fp)
+        mp3_fp.seek(0)
+
+        return send_file(
+            mp3_fp,
+            mimetype='audio/mpeg',
+            as_attachment=False,
+            download_name='narration.mp3'
+        )
 
-    except requests.exceptions.HTTPError as http_err:
-        print(f"ERROR: HTTP error from Gemini API: {http_err.response.status_code} - {http_err.response.text}", file=sys.stderr, flush=True)
-        return jsonify({"error": f"Error de la API de Gemini ({http_err.response.status_code}): {http_err.response.text}"}), 500
-    except requests.exceptions.ConnectionError as conn_err:
-        print(f"ERROR: Connection error to Gemini API: {conn_err}", file=sys.stderr, flush=True)
-        return jsonify({"error": f"Error de conexión con la API de Gemini: {conn_err}"}), 500
-    except requests.exceptions.Timeout as timeout_err:
-        print(f"ERROR: Timeout error with Gemini API: {timeout_err}", file=sys.stderr, flush=True)
-        return jsonify({"error": f"La solicitud a la API de Gemini tardó demasiado (timeout): {timeout_err}"}), 500
-    except requests.exceptions.RequestException as req_err:
-        print(f"ERROR: General request error with Gemini API: {req_err}", file=sys.stderr, flush=True)
-        return jsonify({"error": f"Error al comunicarse con la API de generación de texto: {req_err}"}), 500
     except Exception as e:
-        print(f"CRITICAL ERROR: Unexpected error generating text: {e}", file=sys.stderr, exc_info=True, flush=True) # exc_info for traceback
-        return jsonify({"error": f"Error inesperado al generar texto: {e}"}), 500
+        print(f"Ha ocurrido un error: {e}")
+        return jsonify({"error": str(e)}), 500
 
 if __name__ == '__main__':
-    port = int(os.environ.get('PORT', 7860))
-    print(f"INFO: Starting Flask app on host 0.0.0.0, port {port}", flush=True)
-    app.run(host='0.0.0.0', port=port, debug=False)
+    print("Iniciando servidor de gTTS en http://localhost:5000")
+    app.run(host='0.0.0.0', port=5000, debug=True)