Update app.py

app.py

@@ -44,13 +44,12 @@ except Exception as e:
 # --- ROTA 1: TEXT-TO-SPEECH (TTS) ---
 @app.route('/tts-proxy', methods=['POST'])
 def tts_proxy():
-    # ... (código existente sem alterações) ...
     data = request.get_json()
     text = data.get('text', '')
     if not text:
         return jsonify({"error": "No text provided"}), 400
     try:
-        tts = gTTS(text=text, lang='en', tld='us')
+        tts = gTTS(text=text, lang='en', tld='co.uk') # Sotaque britânico para variedade
         mp3_fp = io.BytesIO()
         tts.write_to_fp(mp3_fp)
         mp3_fp.seek(0)
@@ -66,144 +65,113 @@ def explain_proxy():
     # ... (código existente sem alterações) ...
     data = request.get_json()
     model_provider, model_name = data.get('model', 'gemini:gemini-1.5-flash-latest').split(':', 1)
-    word = data.get('word', '').strip()
-    context = data.get('context', '')
-    for_flashcard = data.get('for_flashcard', False)
-    context_focus = data.get('context_focus', 'General/Social')
+    word, context = data.get('word', '').strip(), data.get('context', '')
+    for_flashcard, context_focus = data.get('for_flashcard', False), data.get('context_focus', 'General/Social')
     custom_prompt = data.get('custom_prompt', None)
 
-    if (model_provider == 'gemini' and not genai_client) or \
-       (model_provider == 'groq' and not groq_client):
+    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."
-
+    
+    system_instruction_base = f"You are a professional English tutor focused on the context '{context_focus}'."
     try:
         if custom_prompt:
-            text_response = get_ai_text_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
-
+            return jsonify({"explanation": get_ai_text_response(model_provider, model_name, system_instruction_base, custom_prompt)})
+        if not word: return jsonify({"error": "No word selected."}), 400
         if for_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}' in the sentence: '{context}'. Generate a JSON object following the schema. The 'gapped_sentence' must replace '{word}' with '______________'."
-            card_data = get_ai_text_response(model_provider, model_name, system_instruction, user_prompt, json_schema=flashcard_schema)
-            return jsonify(card_data)
-                
+            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"]}
+            prompt = f"Analyze '{word}' in context: '{context}'. Generate a JSON for a flashcard. The 'gapped_sentence' must replace '{word}' with '______________'."
+            return jsonify(get_ai_text_response(model_provider, model_name, system_instruction_base, prompt, json_schema=schema))
         else:
-            system_instruction = system_instruction_base
-            user_prompt = f"Analyze '{word}' in context: '{context}'. Provide a one-sentence English explanation, then '---', then the Portuguese translation."
-            text_response = get_ai_text_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})
-
+            prompt = f"Analyze '{word}' in context: '{context}'. Provide a one-sentence English explanation, then '---', then the Portuguese translation."
+            parts = get_ai_text_response(model_provider, model_name, system_instruction_base, prompt).split('---', 1)
+            return jsonify({"explanation": parts[0].strip(), "translation": parts[1].strip() if len(parts) > 1 else 'N/A'})
     except Exception as e:
-        print(f"Erro na análise de IA: {e}")
         return jsonify({"error": f"AI analysis failed: {e}"}), 500
 
 # --- ROTA 3: ANÁLISE DE IMAGEM ---
 @app.route('/analyze-image', methods=['POST'])
 def analyze_image():
     # ... (código existente sem alterações) ...
-    if not genai_client:
-        return jsonify({"error": "GEMINI_API_KEY not configured for image analysis."}), 503
-        
-    data = request.get_json()
-    base64_image = data.get('image')
-    if not base64_image:
-        return jsonify({"error": "No image data provided."}), 400
-
+    if not genai_client: return jsonify({"error": "GEMINI_API_KEY not configured."}), 503
+    data, base64_image = request.get_json(), data.get('image')
+    if not base64_image: return jsonify({"error": "No image data."}), 400
     try:
-        image_data = base64.b64decode(base64_image.split(',')[1])
-        image = Image.open(io.BytesIO(image_data))
+        image = Image.open(io.BytesIO(base64.b64decode(base64_image.split(',')[1])))
         model = genai_client.GenerativeModel('gemini-1.5-flash-latest')
-
-        vocabulary_schema = { "type": "object", "properties": { "vocabulary": { "type": "array", "items": { "type": "object", "properties": { "term": {"type": "string"}, "definition": {"type": "string"} }, "required": ["term", "definition"] } } }, "required": ["vocabulary"] }
-        prompt = [ "You are an English teacher. Look at this image and identify 5 to 7 key objects or concepts. For each item, provide its English name and a simple one-sentence definition. Return the result as a single JSON object that conforms to the provided schema.", image ]
-        
-        response = model.generate_content( prompt, generation_config={ "response_mime_type": "application/json", "response_schema": vocabulary_schema } )
-        json_response = json.loads(response.text)
-        return jsonify(json_response['vocabulary'])
-
+        schema = { "type": "object", "properties": { "vocabulary": { "type": "array", "items": { "type": "object", "properties": { "term": {"type": "string"}, "definition": {"type": "string"} }, "required": ["term", "definition"] } } }, "required": ["vocabulary"] }
+        prompt = [ "Identify 5-7 key objects/concepts in this image. For each, provide its English name and a simple definition. Return a single JSON object conforming to the schema.", image ]
+        response = model.generate_content(prompt, generation_config={"response_mime_type": "application/json", "response_schema": schema})
+        return jsonify(json.loads(response.text)['vocabulary'])
     except Exception as e:
-        print(f"Erro na análise de imagem: {e}")
         return jsonify({"error": f"Image analysis failed: {e}"}), 500
 
-
-# --- ROTA 4: CHAT COM IA (NOVO - IDEAL PARA GROQ) ---
+# --- ROTA 4: CHAT COM IA ---
 @app.route('/chat-with-ai', methods=['POST'])
 def chat_with_ai():
-    if not groq_client:
-        return jsonify({"error": "GROQ_API_KEY not configured for the chat feature."}), 503
-        
+    # ... (código existente sem alterações) ...
+    if not groq_client: return jsonify({"error": "GROQ_API_KEY not configured."}), 503
     data = request.get_json()
-    history = data.get('history', [])
-    user_message = data.get('message', '')
+    history, user_message = data.get('history', []), data.get('message', '')
+    if not user_message: return jsonify({"error": "No message."}), 400
+    try:
+        system = "You are 'Groq Chat', a friendly English tutor. Keep responses concise (1-2 sentences). If the user makes a grammar mistake, gently correct it. Ask questions to keep the conversation flowing. Always respond in English."
+        messages = [{"role": "system", "content": system}] + history + [{"role": "user", "content": user_message}]
+        response = groq_client.chat.completions.create(model="llama-3.1-8b-instant", messages=messages, temperature=0.7)
+        return jsonify({"response": response.choices[0].message.content.strip()})
+    except Exception as e:
+        return jsonify({"error": f"AI chat failed: {e}"}), 500
+
+# --- ROTA 5: ANÁLISE DE PRONÚNCIA (NOVO) ---
+@app.route('/pronunciation-feedback', methods=['POST'])
+def pronunciation_feedback():
+    if not groq_client:
+        return jsonify({"error": "GROQ_API_KEY not configured for pronunciation analysis."}), 503
     
-    if not user_message:
-        return jsonify({"error": "No message provided."}), 400
+    data = request.get_json()
+    target_text = data.get('target_text')
+    user_text = data.get('user_text') # Texto transcrito do áudio do usuário
 
+    if not target_text or not user_text:
+        return jsonify({"error": "Target and user text are required."}), 400
+    
     try:
-        # Instrução de sistema para o tutor de IA
-        system_instruction = "You are a friendly and encouraging English tutor named 'Groq Chat'. Your goal is to help the user practice their English conversation skills. Keep your responses concise (1-2 sentences). If the user makes a grammar mistake, gently correct it and explain briefly. Ask questions to keep the conversation flowing. Always respond in English."
-
-        # Monta o histórico de mensagens para a API
-        messages = [{"role": "system", "content": system_instruction}]
-        messages.extend(history)
-        messages.append({"role": "user", "content": user_message})
+        system_instruction = "You are an expert American English pronunciation coach. The user tried to say a target sentence, and their speech was transcribed. Based on the likely pronunciation differences between the target and the transcription, provide brief, friendly, and actionable feedback in Portuguese. Focus on 1-2 key points. If the transcription is very close to the target, praise the user."
+        
+        user_prompt = f"Frase-alvo: \"{target_text}\"\nTranscrição do usuário: \"{user_text}\"\n\nPor favor, forneça o feedback de pronúncia."
+        
+        messages = [
+            {"role": "system", "content": system_instruction},
+            {"role": "user", "content": user_prompt}
+        ]
         
-        # Chama a API da Groq
         response = groq_client.chat.completions.create(
-            # Usando um modelo rápido, ideal para chat
-            model="llama-3.1-8b-instant",
+            model="llama-3.1-8b-instant", # Modelo rápido para feedback instantâneo
             messages=messages,
-            temperature=0.7
+            temperature=0.5
         )
         
-        ai_response = response.choices[0].message.content.strip()
-        return jsonify({"response": ai_response})
-
+        feedback = response.choices[0].message.content.strip()
+        return jsonify({"feedback": feedback})
+        
     except Exception as e:
-        print(f"Erro no chat com IA: {e}")
-        return jsonify({"error": f"AI chat failed: {e}"}), 500
+        print(f"Erro na análise de pronúncia: {e}")
+        return jsonify({"error": f"Pronunciation analysis failed: {e}"}), 500
 
-
-# --- FUNÇÃO AUXILIAR PARA CHAMADAS DE IA (APENAS TEXTO) ---
+# --- FUNÇÃO AUXILIAR E ROTA RAIZ ---
 def get_ai_text_response(provider, model_name, system_instruction, user_prompt, json_schema=None):
     # ... (código existente sem alterações) ...
     if provider == 'gemini':
-        if not genai_client:
-            raise Exception("Gemini client not initialized.")
         model = genai_client.GenerativeModel(model_name)
-        generation_config = {"response_mime_type": "application/json", "response_schema": json_schema} if json_schema else None
-        response = model.generate_content(user_prompt, generation_config=generation_config)
-        return json.loads(response.candidates[0].content.parts[0].text.strip()) if json_schema else response.text.strip()
-
+        config = {"response_mime_type": "application/json", "response_schema": json_schema} if json_schema else None
+        response = model.generate_content(user_prompt, generation_config=config)
+        return json.loads(response.text) if json_schema else response.text
     elif provider == 'groq':
-        if not groq_client:
-            raise Exception("Groq client not initialized.")
         messages = [{"role": "system", "content": system_instruction}, {"role": "user", "content": user_prompt}]
-        config_params = {'response_format': {"type": "json_object"}} if json_schema else {}
-        response = groq_client.chat.completions.create(model=model_name, messages=messages, **config_params)
-        text_response = response.choices[0].message.content.strip()
-        return json.loads(text_response) if json_schema else text_response
-            
-    else:
-        raise Exception(f"Unsupported provider: {provider}")
-
+        config = {'response_format': {"type": "json_object"}} if json_schema else {}
+        response = groq_client.chat.completions.create(model=model_name, messages=messages, **config)
+        return json.loads(response.choices[0].message.content) if json_schema else response.choices[0].message.content
+    raise Exception(f"Unsupported provider: {provider}")
 
-# --- ROTA DE INICIALIZAÇÃO ---
 @app.route('/')
 def root():
     return send_file('index.html')