Update app.py

app.py

@@ -2,20 +2,14 @@
 import os
 import io
 import json
-import uuid
-import tempfile
-import requests
 
 from flask import Flask, request, jsonify, send_file
 from gtts import gTTS
-# Importa Groq e Google GenAI
 from groq import Groq
-from google import genai
-from google.genai import types
+# CORREÇÃO: A importação correta para a biblioteca do Google Generative AI
+import google.generativeai as genai
 
 # --- CONFIGURAÇÃO INICIAL ---
-
-# Inicializa o Flask
 app = Flask(__name__)
 
 # --- CONFIGURAÇÃO DAS APIS LLM ---
@@ -24,10 +18,8 @@ groq_client = None
 
 # 1. Configuração Gemini
 try:
-    # Use os Secrets do Hugging Face para armazenar suas chaves
     GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
     if GEMINI_API_KEY:
-        # Apenas inicializa o cliente se a chave existir
         genai.configure(api_key=GEMINI_API_KEY)
         genai_client = genai
     else:
@@ -49,98 +41,56 @@ except Exception as e:
 
 
 # --- ROTA 1: TEXT-TO-SPEECH (TTS) - USANDO gTTS GRATUITO ---
-
 @app.route('/tts-proxy', methods=['POST'])
 def tts_proxy():
-    """
-    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
-
     try:
-        # Cria um objeto gTTS (sem controle de velocidade)
-        tts = gTTS(text=text, lang='en', tld='us') # TLD 'us' para sotaque Americano
-
-        # Salva o áudio em um buffer de bytes na memória
+        tts = gTTS(text=text, lang='en', tld='us')
         mp3_fp = io.BytesIO()
         tts.write_to_fp(mp3_fp)
         mp3_fp.seek(0)
-
-        # Retorna o arquivo de áudio MP3
-        return send_file(
-            mp3_fp,
-            mimetype='audio/mpeg',
-            as_attachment=True,
-            download_name='audio.mp3'
-        )
-
+        return send_file(mp3_fp, mimetype='audio/mpeg', as_attachment=True, download_name='audio.mp3')
     except Exception as e:
         print(f"Erro no gTTS: {e}")
         return jsonify({"error": f"Failed to generate audio via gTTS: {e}"}), 500
 
 
 # --- ROTA 2: TRADUÇÃO RÁPIDA E CONTEXTO (IA) - USANDO GEMINI OU GROQ ---
-
 def get_ai_response(provider, model_name, system_instruction, user_prompt, json_schema=None):
-    """Função auxiliar para rotear a requisição LLM para o provedor selecionado."""
-    
     if provider == 'gemini':
         if not genai_client:
             raise Exception("Gemini client not initialized. GEMINI_API_KEY is missing.")
-
         model = genai_client.GenerativeModel(model_name)
         
-        # Configuração para resposta JSON estruturada
+        # CORREÇÃO: A configuração de geração para JSON agora é um dicionário simples
         generation_config = None
         if json_schema:
-             generation_config = genai.GenerationConfig(
-                response_mime_type="application/json",
-                response_schema=json_schema
-            )
+             generation_config = {
+                "response_mime_type": "application/json",
+                "response_schema": json_schema
+            }
         
-        response = model.generate_content(
-            user_prompt,
-            generation_config=generation_config
-        )
+        response = model.generate_content(user_prompt, generation_config=generation_config)
         
         if json_schema:
-            if response.candidates and response.candidates[0].content and response.candidates[0].content.parts:
-                json_text = response.candidates[0].content.parts[0].text.strip()
-                return json.loads(json_text)
-            else:
-                 raise Exception("Gemini returned empty or invalid JSON content.")
+            json_text = response.candidates[0].content.parts[0].text.strip()
+            return json.loads(json_text)
         else:
             return response.text.strip()
 
     elif provider == 'groq':
         if not groq_client:
             raise Exception("Groq client not initialized. GROQ_API_KEY is missing.")
-
-        messages = [
-            {"role": "system", "content": system_instruction},
-            {"role": "user", "content": user_prompt}
-        ]
-        
+        messages = [{"role": "system", "content": system_instruction}, {"role": "user", "content": user_prompt}]
         config_params = {}
         if json_schema:
             config_params['response_format'] = {"type": "json_object"}
-
-        response = groq_client.chat.completions.create(
-            model=model_name,
-            messages=messages,
-            **config_params
-        )
+        response = groq_client.chat.completions.create(model=model_name, messages=messages, **config_params)
         text_response = response.choices[0].message.content.strip()
-
-        if json_schema:
-            return json.loads(text_response)
-        else:
-            return text_response
+        return json.loads(text_response) if json_schema else text_response
             
     else:
         raise Exception(f"Unsupported provider: {provider}")
@@ -156,79 +106,42 @@ def explain_proxy():
     context_focus = data.get('context_focus', 'General/Social')
     custom_prompt = data.get('custom_prompt', None)
 
-    if model_provider == 'gemini' and not genai_client:
-        return jsonify({"error": "GEMINI_API_KEY not configured."}), 503
-    if model_provider == 'groq' and not groq_client:
-        return jsonify({"error": "GROQ_API_KEY not configured."}), 503
+    if (model_provider == 'gemini' and not genai_client) or \
+       (model_provider == 'groq' and not groq_client):
+        return jsonify({"error": f"{model_provider.upper()}_API_KEY not configured."}), 503
 
     system_instruction_base = f"You are a professional English tutor focused on the context '{context_focus}'. All responses must be accurate and relevant to language learning."
 
-    if custom_prompt:
-        try:
-            text_response = get_ai_response(
-                model_provider, model_name, 
-                system_instruction=system_instruction_base, 
-                user_prompt=custom_prompt,
-                json_schema=None
-            )
-            return jsonify({
-                "explanation": text_response,
-                "translation": "Activity Generated."
-            })
-        except Exception as e:
-            print(f"Erro na geração de atividade: {e}")
-            return jsonify({"error": f"AI activity generation failed: {e}"}), 500
-
-    if not word:
-        return jsonify({"error": "No word or phrase selected."}), 400
-
-    # Schema JSON aprimorado para o Flashcard Inteligente
-    flashcard_schema = {
-        "type": "object",
-        "properties": {
-            "term": {"type": "string", "description": "The selected English word or phrase."},
-            "translation": {"type": "string", "description": "The accurate Portuguese translation to be used as a hint."},
-            "context_sentence": {"type": "string", "description": "The original, complete English sentence from the context."},
-            "gapped_sentence": {"type": "string", "description": "The context sentence with the term replaced by '______________'."},
-            "definition": {"type": "string", "description": "A concise, clear English definition of the term."},
-        },
-        "required": ["term", "translation", "context_sentence", "gapped_sentence", "definition"]
-    }
-
     try:
+        if custom_prompt:
+            text_response = get_ai_response(model_provider, model_name, system_instruction_base, custom_prompt)
+            return jsonify({"explanation": text_response, "translation": "Activity Generated."})
+
+        if not word:
+            return jsonify({"error": "No word or phrase selected."}), 400
+
         if for_flashcard:
-            # Prompt detalhado para gerar o flashcard
+            flashcard_schema = {
+                "type": "object",
+                "properties": {
+                    "term": {"type": "string"}, "translation": {"type": "string"},
+                    "context_sentence": {"type": "string"}, "gapped_sentence": {"type": "string"},
+                    "definition": {"type": "string"},
+                },
+                "required": ["term", "translation", "context_sentence", "gapped_sentence", "definition"]
+            }
             system_instruction = system_instruction_base + " Your task is to generate a JSON object for an 'intelligent flashcard'."
-            user_prompt = f"""
-            Analyze the term '{word}' found in the following sentence: '{context}'.
-            Based on this, generate a JSON object that follows the required schema.
-            - 'term' should be the exact word/phrase '{word}'.
-            - 'translation' must be its most accurate Portuguese translation in this context.
-            - 'context_sentence' is the full original sentence.
-            - 'gapped_sentence' is the original sentence, but replacing '{word}' with '______________'.
-            - 'definition' is a clear, single-sentence definition in English.
-            """
-            
-            card_data = get_ai_response(
-                model_provider, model_name, 
-                system_instruction, user_prompt,
-                json_schema=flashcard_schema
-            )
+            user_prompt = f"Analyze the term '{word}' in the sentence: '{context}'. Generate a JSON object following the schema. The 'gapped_sentence' must replace '{word}' with '______________'."
+            card_data = get_ai_response(model_provider, model_name, system_instruction, user_prompt, json_schema=flashcard_schema)
             return jsonify(card_data)
                 
-        else: # Requisição para o Modal (Clique Duplo)
+        else:
             system_instruction = system_instruction_base
-            user_prompt = f"Analyze the term '{word}' in context: '{context}'. Provide a clear, one-sentence English explanation, followed by its Portuguese translation, separated by '---'."
-            
-            text_response = get_ai_response(
-                model_provider, model_name, 
-                system_instruction, user_prompt,
-                json_schema=None
-            )
+            user_prompt = f"Analyze '{word}' in context: '{context}'. Provide a one-sentence English explanation, then '---', then the Portuguese translation."
+            text_response = get_ai_response(model_provider, model_name, system_instruction, user_prompt)
             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({"explanation": explanation, "translation": translation})
 
     except Exception as e:
@@ -236,10 +149,10 @@ def explain_proxy():
         return jsonify({"error": f"AI analysis failed: {e}"}), 500
 
 # --- ROTA DE INICIALIZAÇÃO E ARQUIVOS ESTÁTICOS ---
-
 @app.route('/')
 def root():
     return send_file('index.html')
 
 if __name__ == '__main__':
     app.run(host='0.0.0.0', port=7860)
+