Update app.py

app.py

@@ -1,139 +1,181 @@
-# 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).
+import os
+import io
+import json
+import uuid
+import tempfile
+import requests
 
 from flask import Flask, request, jsonify, send_file
 from gtts import gTTS
 from google import genai
 from google.genai import types
-import os
-import io
-import json
+
+# --- CONFIGURAÇÃO INICIAL ---
 
 # Inicializa o Flask
-app = Flask(__name__, static_folder='.', static_url_path='')
+app = Flask(__name__)
 
-# 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á.
+# --- CONFIGURAÇÃO DA API GEMINI ---
+# Tenta carregar a chave API da Gemini das variáveis de ambiente (Secrets do Hugging Face).
+# Se a chave não for encontrada, o cliente Gemini não será inicializado e o endpoint de tradução falhará.
 try:
-    API_KEY = os.environ.get("GEMINI_API_KEY")
-    if API_KEY:
-        client = genai.Client(api_key=API_KEY)
+    GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
+    if GEMINI_API_KEY:
+        genai_client = genai.Client(api_key=GEMINI_API_KEY)
     else:
-        print("AVISO: GEMINI_API_KEY não configurada. A funcionalidade de Tradução/Explicação (IA) não funcionará.")
+        genai_client = None
+        print("AVISO: GEMINI_API_KEY não configurada. A funcionalidade de Tradução/Contexto (clique duplo) será desativada.")
 except Exception as e:
-    print(f"Erro ao inicializar o cliente Gemini: {e}")
-    client = None
+    genai_client = None
+    print(f"ERRO ao inicializar o cliente Gemini: {e}. A funcionalidade de IA será desativada.")
 
+# Modelo para contextualização de texto e tradução
+GEMINI_MODEL = "gemini-2.5-flash"
 
-# 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 GRATUITO ---
 
-# --- ROTA 1: TEXT-TO-SPEECH (TTS) - Usando gTTS ---
 @app.route('/tts-proxy', methods=['POST'])
 def tts_proxy():
-    """Gera áudio MP3 a partir do texto usando a biblioteca gTTS."""
+    """
+    Gera áudio MP3 a partir de texto usando a biblioteca gTTS (gratuita)
+    e retorna o áudio como um arquivo.
+    """
+    data = request.get_json()
+    text = data.get('text', '')
+
+    if not text:
+        return jsonify({"error": "No text provided"}), 400
+
+    # O gTTS não suporta o controle de velocidade granular via API, mas é o melhor
+    # compromisso para um serviço gratuito.
+
     try:
-        data = request.get_json()
-        text = data.get('text', '').strip()
-        
-        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') 
-        
-        # Salva o áudio em um buffer de bytes na memória (mais rápido que salvar em disco)
+        # Cria um objeto gTTS
+        tts = gTTS(text=text, lang='en', tld='us') # TLD 'us' para sotaque Americano
+
+        # Salva o áudio em um buffer de bytes na memória (Melhor que salvar no disco)
         mp3_fp = io.BytesIO()
         tts.write_to_fp(mp3_fp)
         mp3_fp.seek(0)
 
-        # Retorna o arquivo MP3 como uma resposta de streaming
+        # Retorna o arquivo de áudio MP3
         return send_file(
             mp3_fp,
-            mimetype='audio/mp3',
+            mimetype='audio/mpeg',
             as_attachment=True,
             download_name='audio.mp3'
         )
 
     except Exception as e:
-        print(f"Erro no TTS gTTS: {e}")
-        return jsonify({"error": f"Erro interno ao gerar áudio: {e}"}), 500
+        print(f"Erro no gTTS: {e}")
+        return jsonify({"error": f"Failed to generate audio via gTTS: {e}"}), 500
 
 
-# --- ROTA 2: EXPLICAÇÃO E TRADUÇÃO DA IA - Usando google-genai ---
+# --- ROTA 2: TRADUÇÃO RÁPIDA E CONTEXTO (IA) - USANDO GEMINI (REQUER CHAVE) ---
+
 @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
+    """
+    Usa o modelo Gemini para fornecer explicação em inglês e tradução em português
+    para uma palavra/frase em contexto.
+    Pode retornar em JSON simples para o modal ou em JSON estruturado para flashcards.
+    """
+    data = request.get_json()
+    word = data.get('word', '').strip()
+    context = data.get('context', '')
+    for_flashcard = data.get('for_flashcard', False) # True se for para criar um flashcard
+
+    if not genai_client:
+        return jsonify({"error": "GEMINI_API_KEY not configured. Cannot perform AI analysis."}), 503
+    
+    if not word:
+        return jsonify({"error": "No word or phrase selected."}), 400
+
+    # Define o System Instruction base
+    system_instruction_base = f"You are a professional English tutor and linguist. Your task is to analyze the user-provided English word or phrase: '{word}' in its context: '{context}'. All responses must be highly accurate and relevant to language learning. Only output the final JSON object."
 
     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"]
-                }
+        if for_flashcard:
+            # 1. Requisição para Flashcard (JSON Estruturado)
+            system_instruction = system_instruction_base + " You must generate a single, highly relevant example sentence using the word/phrase, and provide a clear, simple English definition. Translate the word/phrase accurately to Portuguese. The output MUST be a JSON object conforming to the provided schema."
+            
+            response = genai_client.models.generate_content(
+                model=GEMINI_MODEL,
+                contents=[system_instruction],
+                config=types.GenerateContentConfig(
+                    response_mime_type="application/json",
+                    response_schema={
+                        "type": "OBJECT",
+                        "properties": {
+                            "term": {"type": "STRING", "description": "The selected word or phrase."},
+                            "explanation": {"type": "STRING", "description": "A clear English definition or explanation."},
+                            "translation": {"type": "STRING", "description": "The accurate Portuguese translation of the term/phrase."},
+                            "example": {"type": "STRING", "description": "A new, helpful example sentence using the term/phrase."},
+                        },
+                        "required": ["term", "explanation", "translation", "example"]
+                    }
+                )
             )
-        )
-        
-        # 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)
+            
+            # O retorno do Gemini é uma string JSON, que precisamos analisar
+            if response.candidates and response.candidates[0].content and response.candidates[0].content.parts:
+                json_text = response.candidates[0].content.parts[0].text.strip()
+                # O cliente no frontend espera "term", "translation", "example"
+                # O campo "explanation" é a definição em inglês.
+                card_data = json.loads(json_text)
+                return jsonify(card_data)
+            else:
+                raise Exception("AI returned empty or invalid content for flashcard.")
+                
+        else:
+            # 2. Requisição para Modal (Explicação e Tradução Simples)
+            prompt = f"For the term '{word}' in the context: '{context}', provide a clear, one-sentence English explanation/definition, followed by an exact Portuguese translation, separated by a distinct marker like '---'.\nExample Format:\nDefinition in English.\n---\nTradução em Português."
+            
+            response = genai_client.models.generate_content(
+                model=GEMINI_MODEL,
+                contents=[prompt],
+                config=types.GenerateContentConfig()
+            )
+
+            text_response = response.text.strip()
+            parts = text_response.split('---', 1)
+            
+            explanation = parts[0].strip()
+            translation = parts[1].strip() if len(parts) > 1 else 'Tradução não disponível.'
 
-        return jsonify(ai_result)
+            return jsonify({
+                "explanation": explanation,
+                "translation": translation
+            })
 
-    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
+        print(f"Erro na análise de IA: {e}")
+        return jsonify({"error": f"AI analysis failed: {e}"}), 500
+
 
+# --- ROTA DE INICIALIZAÇÃO E ARQUIVOS ESTÁTICOS ---
 
+@app.route('/')
+def serve_index():
+    """
+    Serve o arquivo index.html principal.
+    Necessário para o Hugging Face Spaces que usa a arquitetura Flask.
+    """
+    try:
+        # Tenta servir o index.html, que é o frontend
+        return app.send_static_file('index.html')
+    except Exception:
+        # Se não encontrar index.html, serve uma mensagem de erro simples
+        return "Frontend file (index.html) not found. Please ensure index.html is in the same directory as app.py.", 500
+
+# Se estiver usando o Flask, ele procura por arquivos estáticos na pasta 'static'.
+# Como o Hugging Face coloca tudo na raiz do app, podemos configurá-lo para servir
+# a partir do diretório atual se necessário, mas para esta aplicação simples
+# e o index.html na raiz, o método 'serve_index' acima é o mais direto.
+
+# Inicializa o servidor Flask
 if __name__ == '__main__':
-    # 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)))
+    # Define o static_folder como o diretório atual para que o send_static_file funcione
+    app.static_folder = os.path.dirname(os.path.abspath(__file__))
+    app.run(host='0.0.0.0', port=7860)