Upload app.py

app.py

@@ -17,150 +17,176 @@ try:
 except TypeError:
     api_key_found = False
 
-print("Loading Whisper model...")
-whisper_model = whisper.load_model("base", device="cpu")
+print("Loading Whisper for transcription...")
+# Usamos el modelo 'base' que es un buen compromiso entre velocidad y precisión
+whisper_model = whisper.load_model("base", device="cpu") 
 print("Whisper model loaded.")
 
-# --- NUEVO: Lista de Trabalenguas ---
-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."
-]
-
-# --- PROMPT DEL EXAMINADOR EXPERTO (Sin cambios) ---
-SYSTEM_PROMPT = """
-You are an expert English language examiner specializing in phonetics and accent reduction for ESL learners. 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:**
-You will be given a JSON object containing:
-1.  `reference_transcript`: The correct sentence the student was supposed to say.
-2.  `spoken_words`: A list of words detected by Whisper, each with:
-    - `word`: The word as transcribed by Whisper.
-    - `start`: The start time of the word in seconds.
-    - `end`: The end time of the word in seconds.
-    - `energy`: A numeric value (RMS) indicating the pronunciation's energy/loudness.
-
-**Your Analysis and Output:**
-Your entire response MUST be in English. You must return a single, valid JSON object with the following structure. Do not include any text outside of this JSON object.
-
-**JSON Output Structure:**
+
+# --- 1. DEFINICIÓN DE PROMPTS PARA LA IA ---
+
+# Prompt para mantener la conversación
+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.
+"""
+
+# Prompt para la evaluación final
+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:
 {
-  "overall_score_100": integer,
-  "cefr_level": "string (A1, A2, B1, B2, C1, or C2)",
-  "holistic_feedback": {
-    "strengths": "string (A paragraph in English summarizing the student's strong points in pronunciation, rhythm, and clarity.)",
-    "areas_for_improvement": "string (A paragraph in English detailing the main patterns of error and what to focus on.)"
+  "cefr_level": "string (e.g., A2, B1)",
+  "feedback_en": {
+    "strengths": "string (A paragraph summarizing the student's strong points in pronunciation, vocabulary, and fluency.)",
+    "areas_for_improvement": "string (A paragraph detailing the main patterns of error and what to focus on.)",
+    "word_by_word_feedback": [
+      {"word": "string", "feedback": "string (Specific phonetic or usage feedback.)"}
+    ]
   },
-  "word_by_word_analysis": [
-    {
-      "reference_word": "string (The word from the correct sentence)",
-      "spoken_word": "string (The word Whisper transcribed, or 'OMITTED')",
-      "word_score_100": integer,
-      "correct_ipa": "string (The correct IPA transcription)",
-      "feedback": "string (Specific phonetic feedback for this word. If correct, simply state 'Excellent pronunciation.')"
-    }
-  ]
+  "feedback_es": {
+    "fortalezas": "string (Un párrafo resumiendo los puntos fuertes del estudiante en pronunciación, vocabulario y fluidez.)",
+    "areas_a_mejorar": "string (Un párrafo detallando los patrones de error principales y en qué enfocarse.)",
+    "feedback_por_palabra": [
+      {"palabra": "string", "feedback": "string (Retroalimentación fonética o de uso específica.)"}
+    ]
+  }
 }
 """
 
-# --- 1. EXTRACCIÓN DE CARACTERÍSTICAS (Sin cambios) ---
-def extract_word_level_features(audio_path):
-    try:
-        y, sr = librosa.load(audio_path, sr=16000)
-        result = whisper_model.transcribe(audio_path, word_timestamps=True, fp16=False)
-        if not result["segments"] or 'words' not in result["segments"][0]:
-            return []
-        word_segments = result["segments"][0]["words"]
-        features_list = []
-        for segment in word_segments:
-            start_sample = int(segment['start'] * sr)
-            end_sample = int(segment['end'] * sr)
-            word_audio = y[start_sample:end_sample]
-            rms_energy = np.mean(librosa.feature.rms(y=word_audio)) if len(word_audio) > 0 else 0
-            features_list.append({"word": segment['word'].strip(), "start": round(segment['start'], 2), "end": round(segment['end'], 2), "energy": round(float(rms_energy), 4)})
-        return features_list
-    except Exception as e:
-        print(f"Error during feature extraction: {e}")
-        return []
-
-# --- 2. FUNCIÓN PRINCIPAL DE EVALUACIÓN (Sin cambios) ---
-def run_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.", None
 
+# --- 2. FUNCIONES LÓGICAS ---
+
+def transcribe_audio(audio_input):
+    """Transcribe el audio usando la API de Whisper de OpenAI."""
+    if audio_input is None:
+        return ""
     sr, y = audio_input
     temp_audio_path = "temp_audio.wav"
     sf.write(temp_audio_path, y, sr)
+    with open(temp_audio_path, "rb") as audio_file:
+        transcript = client.audio.transcriptions.create(
+            model="whisper-1", 
+            file=audio_file
+        ).text
+    return transcript
+
+def chat_interaction(audio_input, history_state):
+    """
+    Gestiona una vuelta de la conversación.
+    """
+    if not api_key_found: raise gr.Error("OpenAI API key not found.")
+    if audio_input is None: return history_state, history_state, "", ""
 
-    word_features = extract_word_level_features(temp_audio_path)
-    if not word_features:
-        return 0, "N/A", "Could not process the audio. Please try recording again.", None
-
-    prompt_data = {"reference_transcript": reference_transcript, "spoken_words": word_features}
+    # 1. Transcribir el audio del usuario
+    user_text = transcribe_audio(audio_input)
+    
+    # 2. Actualizar el historial con el mensaje del usuario
+    history_state.append({"role": "user", "content": user_text})
     
-    print("Sending detailed data to GPT-4o for analysis...")
-    response = client.chat.completions.create(
-        model="gpt-4o", response_format={"type": "json_object"},
-        messages=[{"role": "system", "content": 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"
-        holistic_feedback_md += f"### Areas for Improvement\n{result['holistic_feedback']['areas_for_improvement']}"
-        word_analysis_df = pd.DataFrame(result['word_by_word_analysis'])
+    # Formatear para el chatbot de Gradio
+    chat_display = []
+    for i, msg in enumerate(history_state):
+        if msg['role'] == 'user':
+            chat_display.append((msg['content'], None))
+        elif msg['role'] == 'assistant':
+            if chat_display and chat_display[-1][1] is None:
+                chat_display[-1] = (chat_display[-1][0], msg['content'])
+
+    # 3. Decidir si continuar la conversación o dar el reporte final
+    if len(history_state) < 9: # 1 system + 4 pares de user/assistant
+        # --- Continuar conversación ---
+        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 (result.get("overall_score_100", 0), result.get("cefr_level", "N/A"), holistic_feedback_md,
-                gr.DataFrame(value=word_analysis_df, headers=["Reference Word", "Spoken Word", "Score", "Correct IPA", "Feedback"], interactive=False))
-    except (json.JSONDecodeError, KeyError) as e:
-        print(f"Error processing API response: {e}")
-        error_msg = "The API response was not in the expected format. Please try again."
-        return 0, "Error", error_msg, None
-
-# --- 3. INTERFAZ DE GRADIO (Con las nuevas adecuaciones) ---
+        return chat_display, history_state, gr.Markdown(visible=False), gr.Markdown(visible=False)
+
+    else:
+        # --- Generar evaluación final ---
+        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)
+            
+            # Formatear el feedback en Inglés
+            fb_en = result.get('feedback_en', {})
+            md_en = f"## Final Report (CEFR Level: {result.get('cefr_level', 'N/A')})\n"
+            md_en += f"### Strengths\n{fb_en.get('strengths', '')}\n"
+            md_en += f"### Areas for Improvement\n{fb_en.get('areas_for_improvement', '')}\n"
+            md_en += "### Word-by-Word Feedback\n"
+            for item in fb_en.get('word_by_word_feedback', []):
+                md_en += f"- **{item['word']}**: {item['feedback']}\n"
+            
+            # Formatear el feedback en Español
+            fb_es = result.get('feedback_es', {})
+            md_es = f"## Reporte Final (Nivel MCERL: {result.get('cefr_level', 'N/A')})\n"
+            md_es += f"### Fortalezas\n{fb_es.get('fortalezas', '')}\n"
+            md_es += f"### Áreas a Mejorar\n{fb_es.get('areas_a_mejorar', '')}\n"
+            md_es += "### Retroalimentación por Palabra\n"
+            for item in fb_es.get('feedback_por_palabra', []):
+                md_es += f"- **{item['palabra']}**: {item['feedback']}\n"
+            
+            # Mensaje final para el chat
+            final_message = "Thank you for the conversation! Here is your final report."
+            chat_display[-1] = (chat_display[-1][0], final_message)
+            
+            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)
+
+# --- 3. INTERFAZ DE GRADIO ---
 with gr.Blocks(theme=gr.themes.Soft()) as demo:
-    gr.Markdown("# 🇬🇧 Expert Pronunciation Assessment")
-    gr.Markdown("Choose a tongue twister or write your own sentence. Record yourself, and our AI examiner will provide a detailed diagnostic report.")
-
-    # --- NUEVO: Selector de Trabalenguas ---
-    tongue_twister_selector = gr.Dropdown(
-        choices=TONGUE_TWISTERS,
-        label="Or Choose a Tongue Twister to Practice",
-        info="Selecting one will automatically fill the reference sentence below."
-    )
+    gr.Markdown("# 🇬🇧 AI English Speaking Practice & Assessment")
     
-    with gr.Row():
-        with gr.Column(scale=1):
-            audio_in = gr.Audio(sources=["microphone"], type="numpy", label="1. Record Your Voice")
-            text_in = gr.Textbox(lines=3, label="2. Reference Sentence", value=TONGUE_TWISTERS[0])
-            submit_btn = gr.Button("Get Assessment", variant="primary")
-        
-        with gr.Column(scale=2):
-            gr.Markdown("### Assessment Summary")
+    with gr.Tabs():
+        with gr.TabItem("Práctica Conversacional (Chat AI)"):
             with gr.Row():
-                score_out = gr.Number(label="Overall Score (0-100)", interactive=False)
-                level_out = gr.Textbox(label="Estimated CEFR Level", interactive=False)
+                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"
+                    )
+                    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)
+
+            # Estado para guardar el historial de la conversación
+            history = gr.State([]) 
             
-            holistic_feedback_out = gr.Markdown(label="Examiner's Feedback")
-    
-    gr.Markdown("--- \n ### Detailed Word-by-Word Analysis")
-    word_analysis_out = gr.DataFrame(headers=["Reference Word", "Spoken Word", "Score", "Correct IPA", "Feedback"], label="Phonetic Breakdown", wrap=True)
-
-    # --- NUEVO: Lógica de Interacción ---
-    # Cuando el dropdown cambia, actualiza el campo de texto.
-    def update_text(choice):
-        return gr.Textbox(value=choice)
-    tongue_twister_selector.change(fn=update_text, inputs=tongue_twister_selector, outputs=text_in)
-
-    submit_btn.click(
-        fn=run_evaluation,
-        inputs=[audio_in, text_in],
-        outputs=[score_out, level_out, holistic_feedback_out, word_analysis_out]
-    )
+            audio_in_chat.stop_recording(
+                fn=chat_interaction,
+                inputs=[audio_in_chat, history],
+                outputs=[chatbot, history, feedback_en_out, feedback_es_out]
+            )
+
+        with gr.TabItem("Evaluación por Frase"):
+            gr.Markdown("This is a placeholder for the original sentence evaluation tool.")
+            # Aquí pegarías la interfaz de la herramienta anterior si quisieras combinar ambas.
 
 if __name__ == "__main__":
     if not api_key_found: