Upload app.py

app.py

@@ -25,34 +25,15 @@ print("Whisper model loaded.")
 
 
 # --- 1. DEFINICIÓN DE PROMPTS PARA LA IA ---
-
-CONVERSATION_SYSTEM_PROMPT = """
-You are a friendly and encouraging English language tutor named Alex.
-A student will speak to you. Your task is to keep a natural, simple conversation going.
-1. Briefly analyze the user's previous response to estimate their CEFR level (A1, A2, B1, etc.).
-2. Formulate a simple, open-ended follow-up question that is appropriate for THAT estimated level.
-3. Your entire response must be a single, short paragraph in natural, conversational English. DO NOT use JSON.
-"""
-
-FINAL_EVALUATION_SYSTEM_PROMPT = """
-You are an expert English language examiner providing a final report. Analyze the entire conversation history provided.
-Your task is to return a single, valid JSON object with the following structure. Do not include any text outside this JSON object.
-JSON Output Structure:
-{
-  "cefr_level": "string (e.g., A2, B1)",
-  "feedback_en": { "strengths": "string", "areas_for_improvement": "string", "word_by_word_feedback": [{"word": "string", "feedback": "string"}] },
-  "feedback_es": { "fortalezas": "string", "areas_a_mejorar": "string", "feedback_por_palabra": [{"palabra": "string", "feedback": "string"}] }
-}
-"""
-
+# (Tus prompts completos van aquí...)
+CONVERSATION_SYSTEM_PROMPT = """..."""
+FINAL_EVALUATION_SYSTEM_PROMPT = """..."""
 SENTENCE_EVALUATION_SYSTEM_PROMPT = """
-You are an expert English language examiner specializing in phonetics. Your task is to provide a detailed, diagnostic assessment of a student's spoken English based on a reference sentence and detailed word-level audio analysis.
-Input You Will Receive: A JSON object with `reference_transcript` and a list of `spoken_words` with timestamps and energy.
-Your entire response MUST be a single, valid JSON object with the following structure. Do not include any text outside this JSON object.
+You are an expert English language examiner...
 JSON Output Structure:
 {
   "overall_score_100": integer,
-  "cefr_level": "string (A1, A2, B1, B2, C1, or C2)",
+  "cefr_level": "string",
   "holistic_feedback": { "strengths": "string", "areas_for_improvement": "string" },
   "word_by_word_analysis": [ { "reference_word": "string", "spoken_word": "string", "word_score_100": integer, "correct_ipa": "string", "feedback_en": "string", "feedback_es": "string" } ]
 }
@@ -77,84 +58,68 @@ def extract_word_level_features(audio_path):
         print(f"Error during feature extraction: {e}"); return []
 
 def chat_interaction(audio_input, history_state):
-    if not api_key_found: raise gr.Error("OpenAI API key not found.")
-    if audio_input is None: return history_state, history_state, gr.Markdown(visible=False), gr.Markdown(visible=False)
-    sr, y = audio_input; temp_audio_path = "temp_audio_chat.wav"; sf.write(temp_audio_path, y, sr)
-    user_text = client.audio.transcriptions.create(model="whisper-1", file=open(temp_audio_path, "rb")).text
-    if not history_state: history_state = []
-    history_state.append({"role": "user", "content": user_text})
-    chat_display = [(history_state[i]['content'], history_state[i+1]['content']) for i in range(0, len(history_state)-1, 2)]
-    chat_display.append((user_text, None))
-
-    if len(history_state) < 9:
-        messages_to_send = [{"role": "system", "content": CONVERSATION_SYSTEM_PROMPT}] + history_state
-        response = client.chat.completions.create(model="gpt-4o", messages=messages_to_send, temperature=0.7)
-        ai_response = response.choices[0].message.content
-        history_state.append({"role": "assistant", "content": ai_response})
-        chat_display[-1] = (chat_display[-1][0], ai_response)
-        return chat_display, history_state, gr.Markdown(visible=False), gr.Markdown(visible=False)
-    else:
-        print("Generating final evaluation..."); messages_to_send = [{"role": "system", "content": FINAL_EVALUATION_SYSTEM_PROMPT}] + history_state
-        response = client.chat.completions.create(model="gpt-4o", response_format={"type": "json_object"}, messages=messages_to_send)
-        try:
-            result = json.loads(response.choices[0].message.content)
-            fb_en = result.get('feedback_en', {}); md_en = f"## Final Report (CEFR Level: {result.get('cefr_level', 'N/A')})\n### Strengths\n{fb_en.get('strengths', '')}\n### Areas for Improvement\n{fb_en.get('areas_for_improvement', '')}\n### Word-by-Word Feedback\n"
-            for item in fb_en.get('word_by_word_feedback', []): md_en += f"- **{item['word']}**: {item['feedback']}\n"
-            fb_es = result.get('feedback_es', {}); md_es = f"## Reporte Final (Nivel MCERL: {result.get('cefr_level', 'N/A')})\n### Fortalezas\n{fb_es.get('fortalezas', '')}\n### Áreas a Mejorar\n{fb_es.get('areas_a_mejorar', '')}\n### Retroalimentación por Palabra\n"
-            for item in fb_es.get('feedback_por_palabra', []): md_es += f"- **{item['palabra']}**: {item['feedback']}\n"
-            chat_display[-1] = (chat_display[-1][0], "Thank you for the conversation! Here is your final report.")
-            return chat_display, history_state, gr.Markdown(value=md_en, visible=True), gr.Markdown(value=md_es, visible=True)
-        except (json.JSONDecodeError, KeyError) as e:
-            print(f"Error parsing final report: {e}"); return chat_display, history_state, gr.Markdown(value="Error generating report.", visible=True), gr.Markdown(visible=False)
+    # (Tu función de chat sin cambios va aquí...)
+    pass
 
+# --- CAMBIO: La función de evaluación de frase ahora devuelve MARKDOWN ---
 def run_sentence_evaluation(audio_input, reference_transcript):
     if not api_key_found: raise gr.Error("OpenAI API key not found.")
     if audio_input is None or not reference_transcript:
         return 0, "N/A", "Please provide both an audio file and the reference text.", ""
+
     sr, y = audio_input; temp_audio_path = "temp_audio_sentence.wav"; sf.write(temp_audio_path, y, sr)
     word_features = extract_word_level_features(temp_audio_path)
     if not word_features:
         return 0, "N/A", "Could not process the audio.", ""
     prompt_data = {"reference_transcript": reference_transcript, "spoken_words": word_features}
+    
     print("Sending detailed data to GPT-4o for sentence analysis...")
     response = client.chat.completions.create(model="gpt-4o", response_format={"type": "json_object"}, messages=[{"role": "system", "content": SENTENCE_EVALUATION_SYSTEM_PROMPT}, {"role": "user", "content": json.dumps(prompt_data)}])
+    
     try:
         result = json.loads(response.choices[0].message.content)
         holistic_feedback_md = f"### Strengths\n{result['holistic_feedback']['strengths']}\n\n### Areas for Improvement\n{result['holistic_feedback']['areas_for_improvement']}"
         word_analysis_list = result['word_by_word_analysis']
-        md_table = "| Reference Word | Spoken Word | Score | Feedback (EN) | Feedback (ES) | Reference Audio |\n| :--- | :--- | :---: | :--- | :--- | :---: |\n"
+        
+        # --- NUEVA LÓGICA: Construir una tabla en Markdown ---
+        md_table = "| Reference Word | Spoken Word | Score | Feedback (EN) | Feedback (ES) | Reference Audio |\n"
+        md_table += "| :--- | :--- | :---: | :--- | :--- | :---: |\n"
+        
         os.makedirs("reference_audio", exist_ok=True)
+        
         for index, item in enumerate(word_analysis_list):
-            word_to_speak = item['reference_word']; safe_filename = re.sub(r'\W+', '', word_to_speak.lower()); audio_path = f"reference_audio/{index}_{safe_filename}.mp3"
+            word_to_speak = item['reference_word']
+            safe_filename = re.sub(r'\W+', '', word_to_speak.lower())
+            audio_path = f"reference_audio/{index}_{safe_filename}.mp3"
+            
             try:
-                tts = gTTS(text=word_to_speak, lang='en'); tts.save(audio_path); audio_player = f'<audio src="file/{audio_path}" controls></audio>'
+                tts = gTTS(text=word_to_speak, lang='en'); tts.save(audio_path)
+                # Embeber el audio usando una etiqueta HTML <audio>
+                audio_player = f'<audio src="file/{audio_path}" controls></audio>'
             except Exception as e:
                 print(f"Error al generar TTS para '{word_to_speak}': {e}"); audio_player = "Error"
+
             md_table += (f"| **{item['reference_word']}** | {item['spoken_word']} | {item['word_score_100']} | {item['feedback_en']} | {item['feedback_es']} | {audio_player} |\n")
+
         return (result.get("overall_score_100", 0), result.get("cefr_level", "N/A"), holistic_feedback_md, md_table)
     except (json.JSONDecodeError, KeyError) as e:
         print(f"Error processing API response: {e}"); error_msg = "The API response was not in the expected format."
         return 0, "Error", error_msg, ""
 
-# --- 3. INTERFAZ DE GRADIO CON PESTAÑAS ---
+
+# --- 3. INTERFAZ DE GRADIO CON PESTAÑAS (Con salida Markdown) ---
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
     gr.Markdown("# 🇬🇧 AI English Speaking Practice & Assessment")
     with gr.Tabs():
-        # --- PESTAÑA 1: CHAT AI ---
+        # PESTAÑA 1: CHAT AI (sin cambios)
         with gr.TabItem("Práctica Conversacional (Chat AI)"):
-            with gr.Row():
-                with gr.Column(scale=2):
-                    chatbot = gr.Chatbot(value=[(None, "Hi there! I'm Alex. How are you doing today?")], label="Conversation with your AI Tutor", height=500)
-                    audio_in_chat = gr.Audio(sources=["microphone"], type="numpy", label="Record your response")
-                with gr.Column(scale=1):
-                    gr.Markdown("### Final Report"); feedback_en_out = gr.Markdown(label="English Feedback", visible=False); feedback_es_out = gr.Markdown(label="Retroalimentación en Español", visible=False)
-            history = gr.State([])
-            audio_in_chat.stop_recording(fn=chat_interaction, inputs=[audio_in_chat, history], outputs=[chatbot, history, feedback_en_out, feedback_es_out])
+            # ... (Aquí va toda la definición de la interfaz de tu chatbot, sin cambios)
+            pass
 
-        # --- PESTAÑA 2: EVALUACIÓN POR FRASE ---
+        # PESTAÑA 2: EVALUACIÓN POR FRASE
         with gr.TabItem("Evaluación por Frase"):
-            TONGUE_TWISTERS = ["Peter Piper picked a peck of pickled peppers.", "She sells seashells by the seashore.", "How much wood would a woodchuck chuck if a woodchuck could chuck wood?", "Betty Botter bought some butter but she said the butter’s bitter.", "A proper copper coffee pot."]
-            gr.Markdown("Choose a tongue twister or write your own sentence. Record yourself, and our AI examiner will provide a detailed diagnostic report.")
+            TONGUE_TWISTERS = ["Peter Piper picked a peck of pickled peppers.", "She sells seashells by the seashore.", "How much wood would a woodchuck chuck if a woodchuck could chuck wood?"]
+            gr.Markdown("Choose a tongue twister or write your own sentence...")
             tongue_twister_selector = gr.Dropdown(choices=TONGUE_TWISTERS, label="Or Choose a Tongue Twister to Practice")
             with gr.Row():
                 with gr.Column(scale=1):
@@ -163,16 +128,20 @@ with gr.Blocks(theme=gr.themes.Soft()) as demo:
                     submit_btn_sentence = gr.Button("Get Assessment", variant="primary")
                 with gr.Column(scale=2):
                     gr.Markdown("### Assessment Summary")
-                    with gr.Row():
+                    with gr.Row(): 
                         score_out_sentence = gr.Number(label="Overall Score (0-100)", interactive=False)
                         level_out_sentence = gr.Textbox(label="Estimated CEFR Level", interactive=False)
                     holistic_feedback_out_sentence = gr.Markdown(label="Examiner's Feedback")
+            
             gr.Markdown("--- \n ### Detailed Word-by-Word Analysis")
+            
+            # --- AJUSTE CLAVE: La salida ahora es un único componente Markdown ---
             word_analysis_out_sentence = gr.Markdown(label="Phonetic Breakdown")
+
             def update_text(choice): return gr.Textbox(value=choice)
             tongue_twister_selector.change(fn=update_text, inputs=tongue_twister_selector, outputs=text_in_sentence)
             submit_btn_sentence.click(fn=run_sentence_evaluation, inputs=[audio_in_sentence, text_in_sentence], outputs=[score_out_sentence, level_out_sentence, holistic_feedback_out_sentence, word_analysis_out_sentence])
 
 if __name__ == "__main__":
-    if not api_key_found: print("\nFATAL: OpenAI API key not found. Please set the OPENAI_API_KEY environment variable.")
+    if not api_key_found: print("\nFATAL: OpenAI API key not found.")
     else: demo.launch(debug=True)