Update app.py

app.py

@@ -1,59 +1,139 @@
+# Importações necessárias.
+# flask: Para criar o servidor web e as rotas.
+# gTTS: Para gerar o áudio TTS gratuitamente (requer internet, mas não chave API).
+# os: Para gerenciar arquivos temporários.
+# google.genai: Para a contextualização e tradução da IA (requer GEMINI_API_KEY).
+
+from flask import Flask, request, jsonify, send_file
+from gtts import gTTS
+from google import genai
+from google.genai import types
 import os
-import json
-import base64
 import io
-from gtts import gTTS
-from flask import Flask, request, jsonify, send_file
-import tempfile
+import json
 
-# Flask setup
-app = Flask(__name__, static_folder=".")
+# Inicializa o Flask
+app = Flask(__name__, static_folder='.', static_url_path='')
 
-# The language code 'en' for English
-TTS_LANG = 'en'
+# Configuração da API Key (Deve ser lida do secret GEMINI_API_KEY no Hugging Face)
+# O código abaixo tenta ler a chave da variável de ambiente.
+# Se a chave não estiver configurada no Secret, o endpoint /explain-proxy falhará,
+# mas o /tts-proxy (gTTS) ainda funcionará.
+try:
+    API_KEY = os.environ.get("GEMINI_API_KEY")
+    if API_KEY:
+        client = genai.Client(api_key=API_KEY)
+    else:
+        print("AVISO: GEMINI_API_KEY não configurada. A funcionalidade de Tradução/Explicação (IA) não funcionará.")
+except Exception as e:
+    print(f"Erro ao inicializar o cliente Gemini: {e}")
+    client = None
 
+
+# Rota para servir o arquivo HTML principal (Frontend)
+@app.route('/')
+def serve_index():
+    """Serve o arquivo index.html, que contém a interface do usuário."""
+    # Garante que o index.html seja servido como a página inicial
+    return app.send_static_file('index.html')
+
+
+# --- ROTA 1: TEXT-TO-SPEECH (TTS) - Usando gTTS ---
 @app.route('/tts-proxy', methods=['POST'])
 def tts_proxy():
-    """
-    Recebe o texto do frontend e usa gTTS para gerar áudio MP3.
-    O áudio é retornado como um arquivo para o cliente.
-    """
+    """Gera áudio MP3 a partir do texto usando a biblioteca gTTS."""
     try:
-        data = request.json
-        prompt = data.get('prompt')
-        # gTTS does not support changing voice/accent like Gemini, so we ignore it.
-        # It defaults to a neutral female voice.
-
-        if not prompt:
-            return jsonify({"error": "Parâmetro 'prompt' ausente. Cole o texto para gerar o áudio."}), 400
+        data = request.get_json()
+        text = data.get('text', '').strip()
         
-        # 1. Geração do áudio usando gTTS (requer internet)
-        # Usamos tld='us' para um sotaque americano padrão (US English).
-        tts = gTTS(text=prompt, lang=TTS_LANG, slow=False, tld='us')
+        if not text:
+            return jsonify({"error": "Texto não fornecido."}), 400
+
+        # O gTTS não suporta chunks longos, por isso ele é chamado diretamente.
+        # Ele faz a requisição à internet por conta própria.
+        tts = gTTS(text=text, lang='en', tld='us') 
         
-        # 2. Salva o áudio em um buffer de memória
+        # Salva o áudio em um buffer de bytes na memória (mais rápido que salvar em disco)
         mp3_fp = io.BytesIO()
         tts.write_to_fp(mp3_fp)
         mp3_fp.seek(0)
-        
-        # 3. Retorna o arquivo MP3 diretamente como uma resposta do Flask
-        # O navegador tratará isso como um arquivo de áudio.
+
+        # Retorna o arquivo MP3 como uma resposta de streaming
         return send_file(
             mp3_fp,
             mimetype='audio/mp3',
-            as_attachment=False,
-            download_name='generated_audio.mp3'
+            as_attachment=True,
+            download_name='audio.mp3'
         )
 
     except Exception as e:
-        print(f"Erro geral no proxy TTS: {e}")
-        return jsonify({"error": f"Erro interno durante a geração de áudio: {e}"}), 500
+        print(f"Erro no TTS gTTS: {e}")
+        return jsonify({"error": f"Erro interno ao gerar áudio: {e}"}), 500
+
+
+# --- ROTA 2: EXPLICAÇÃO E TRADUÇÃO DA IA - Usando google-genai ---
+@app.route('/explain-proxy', methods=['POST'])
+def explain_proxy():
+    """Usa a IA Gemini para obter explicação em EN e tradução em PT de uma palavra."""
+    if not client:
+        return jsonify({
+            "explanation": "Funcionalidade desativada. A chave GEMINI_API_KEY não foi configurada no Hugging Face Secrets.",
+            "translation": "Funcionalidade desativada. Por favor, configure a chave API para usar este recurso."
+        }), 503
+
+    try:
+        data = request.get_json()
+        word = data.get('word', '').strip()
+        context = data.get('context', '').strip()
+
+        if not word:
+            return jsonify({"error": "Palavra não fornecida para análise."}), 400
+
+        # Prompt de IA estruturado para garantir a resposta em formato JSON
+        system_prompt = (
+            "Você é um tutor de inglês especializado em vocabulário e contexto. Sua tarefa é analisar uma "
+            "palavra e fornecer uma explicação em inglês e uma tradução em português baseada no contexto. "
+            "Sua resposta DEVE ser um objeto JSON com as chaves 'explanation' e 'translation'."
+        )
+
+        user_prompt = (
+            f"Analise a palavra: '{word}'. "
+            f"O contexto em que ela foi encontrada é: \"{context}\". "
+            "Forneça uma explicação concisa em inglês de como a palavra é usada e a melhor tradução para o português DENTRO DESSE CONTEXTO. "
+            "Responda APENAS com o objeto JSON."
+        )
+
+        response = client.models.generate_content(
+            model='gemini-2.5-flash',
+            contents=user_prompt,
+            config=types.GenerateContentConfig(
+                system_instruction=system_prompt,
+                response_mime_type="application/json",
+                response_schema={
+                    "type": "OBJECT",
+                    "properties": {
+                        "explanation": {"type": "STRING", "description": "Explicação concisa em inglês sobre o uso e significado da palavra no contexto fornecido."},
+                        "translation": {"type": "STRING", "description": "Tradução para o português da palavra ou frase no contexto fornecido."}
+                    },
+                    "propertyOrdering": ["explanation", "translation"]
+                }
+            )
+        )
+        
+        # O modelo retorna uma string JSON, precisamos fazer o parse
+        json_content = response.candidates[0].content.parts[0].text
+        ai_result = json.loads(json_content)
+
+        return jsonify(ai_result)
+
+    except genai.errors.APIError as e:
+        print(f"Erro na API Gemini: {e}")
+        return jsonify({"explanation": "Erro ao conectar à API Gemini. Chave inválida ou limite excedido.", "translation": "Erro na conexão da IA."}), 500
+    except Exception as e:
+        print(f"Erro no explain-proxy: {e}")
+        return jsonify({"explanation": "Erro interno do servidor ao processar a solicitação.", "translation": "Erro interno do servidor."}), 500
 
-@app.route('/')
-def index_route():
-    return app.send_static_file('index.html')
 
 if __name__ == '__main__':
-    # Quando implantado no HF Spaces, a porta é gerenciada pelo ambiente
-    port = int(os.environ.get('PORT', 7860)) 
-    app.run(host='0.0.0.0', port=port)
+    # Define o host para 0.0.0.0 para ser acessível dentro do ambiente Hugging Face
+    app.run(host='0.0.0.0', port=int(os.environ.get('PORT', 7860)))