Spaces:
Running
Running
| """ | |
| French Conversation Tutor - Main Application | |
| Practice French through natural conversation with Mr. Mistral! | |
| """ | |
| import gradio as gr | |
| import numpy as np | |
| import os | |
| import io | |
| import wave | |
| import tempfile | |
| import time | |
| from datetime import datetime | |
| from typing import List, Dict, Tuple | |
| import re | |
| import random | |
| import shutil | |
| from dotenv import load_dotenv | |
| import soundfile as sf # Added missing import | |
| # Load environment variables | |
| load_dotenv() | |
| # Model imports | |
| from mistralai import Mistral | |
| import google.generativeai as genai | |
| from groq import Groq | |
| import openai | |
| # Load API keys | |
| mistral_api_key = os.environ.get("MISTRAL_API_KEY") | |
| gemini_api_key = os.environ.get("GEMINI_API_KEY") | |
| groq_api_key = os.environ.get("GROQ_API_KEY") | |
| openai_api_key = os.environ.get("OPENAI_API_KEY") | |
| # Debug: Check if keys are loaded | |
| print(f"Mistral API key loaded: {'Yes' if mistral_api_key else 'No'}") | |
| print(f"Gemini API key loaded: {'Yes' if gemini_api_key else 'No'}") | |
| print(f"Groq API key loaded: {'Yes' if groq_api_key else 'No'}") | |
| print(f"OpenAI API key loaded: {'Yes' if openai_api_key else 'No'}") | |
| # Initialize clients | |
| mistral_client = None | |
| if mistral_api_key: | |
| mistral_client = Mistral(api_key=mistral_api_key) | |
| current_llm = "Mistral AI" | |
| elif gemini_api_key: | |
| genai.configure(api_key=gemini_api_key) | |
| current_llm = "Google Gemini (Fallback)" | |
| else: | |
| raise ValueError("Neither MISTRAL_API_KEY nor GEMINI_API_KEY found in environment variables.") | |
| # Initialize Gemini for fallback even if Mistral is primary | |
| if gemini_api_key and mistral_api_key: | |
| genai.configure(api_key=gemini_api_key) | |
| if not groq_api_key: | |
| raise ValueError("GROQ_API_KEY not found in environment variables.") | |
| groq_client = Groq(api_key=groq_api_key) | |
| # Global list to track temp files (to prevent deletion before serving) | |
| temp_audio_files = [] | |
| current_llm = "Unknown" # Track which LLM is being used | |
| def cleanup_old_audio_files(): | |
| global temp_audio_files | |
| # Keep more files and add delay to avoid deleting files being served | |
| if len(temp_audio_files) > 20: # Increased from 10 to 20 | |
| old_files = temp_audio_files[:-20] | |
| for file_path in old_files: | |
| try: | |
| # Check if file is older than 60 seconds before deleting | |
| if os.path.exists(file_path): | |
| file_age = datetime.now().timestamp() - os.path.getmtime(file_path) | |
| if file_age > 60: # Only delete files older than 60 seconds | |
| os.remove(file_path) | |
| temp_audio_files.remove(file_path) | |
| except: | |
| pass | |
| def get_system_prompt(): | |
| return """You are Mr. Mistral, a French tutor having a conversation with ONE student. | |
| CRITICAL: You are ONLY the tutor. The student will speak to you, and you respond ONLY to what they actually said. | |
| NEVER: | |
| - Create dialogue for the student | |
| - Imagine what the student might say | |
| - Write "You:" or "Student:" or any dialogue | |
| - Continue the conversation by yourself | |
| ALWAYS: | |
| - Wait for the student's actual input | |
| - Respond with ONE French sentence only | |
| - Use exactly 3 lines: | |
| French sentence | |
| (pronunciation) | |
| [translation] | |
| Example - if student says "Bonjour": | |
| Bonjour! Comment allez-vous? | |
| (bohn-ZHOOR! koh-mahn tah-lay VOO?) | |
| [Hello! How are you?] | |
| ONE sentence response only. NO additional dialogue.""" | |
| def validate_response_format(response: str) -> Tuple[bool, str]: | |
| lines = response.strip().split('\n') | |
| cleaned_lines = [] | |
| for line in lines: | |
| line = line.strip() | |
| if any(marker in line.lower() for marker in ['you:', 'user:', 'student:', 'me:', 'moi:']): | |
| continue | |
| if 'what do you' in line.lower() or "qu'est-ce que" in line.lower(): | |
| continue | |
| if line: | |
| cleaned_lines.append(line) | |
| french_line = None | |
| pronunciation_line = None | |
| translation_line = None | |
| for i, line in enumerate(cleaned_lines): | |
| if '(' in line and ')' in line and not pronunciation_line: | |
| pronunciation_line = line | |
| if i > 0 and not french_line: | |
| french_line = cleaned_lines[i-1] | |
| elif '[' in line and ']' in line and not translation_line: | |
| translation_line = line | |
| if not french_line: | |
| for line in cleaned_lines: | |
| if line and not any(c in line for c in ['(', ')', '[', ']', '*']): | |
| french_line = line | |
| break | |
| if french_line: | |
| if not pronunciation_line: | |
| pronunciation_line = "(pronunciation guide not available)" | |
| if not translation_line: | |
| translation_line = "[translation not available]" | |
| return True, f"{french_line}\n{pronunciation_line}\n{translation_line}" | |
| return False, response | |
| def generate_scenario(): | |
| """Generate initial scenario and hints""" | |
| try: | |
| # List of diverse topics | |
| topics = [ | |
| { | |
| "name": "Daily Routine", | |
| "phrases": [ | |
| "Je me réveille à... (zhuh muh ray-vay ah) [I wake up at...]", | |
| "Je prends le petit déjeuner (zhuh prahn luh puh-tee day-zhuh-nay) [I have breakfast]", | |
| "Je travaille de... à... (zhuh trah-vay duh... ah) [I work from... to...]", | |
| "Le soir, je... (luh swahr, zhuh) [In the evening, I...]" | |
| ], | |
| "opening": "À quelle heure vous levez-vous le matin?\n(ah kel uhr voo luh-vay voo luh mah-tahn?)\n[What time do you get up in the morning?]" | |
| }, | |
| { | |
| "name": "Favorite Foods", | |
| "phrases": [ | |
| "Mon plat préféré est... (mohn plah pray-fay-ray ay) [My favorite dish is...]", | |
| "J'adore... (zhah-dohr) [I love...]", | |
| "Je n'aime pas... (zhuh nehm pah) [I don't like...]", | |
| "C'est délicieux! (say day-lee-see-uh) [It's delicious!]" | |
| ], | |
| "opening": "Quel est votre plat préféré?\n(kel ay voh-truh plah pray-fay-ray?)\n[What is your favorite dish?]" | |
| }, | |
| { | |
| "name": "Work and Career", | |
| "phrases": [ | |
| "Je travaille comme... (zhuh trah-vay kohm) [I work as...]", | |
| "Mon bureau est... (mohn bew-roh ay) [My office is...]", | |
| "J'aime mon travail (zhehm mohn trah-vay) [I like my job]", | |
| "Mes collègues sont... (may koh-lehg sohn) [My colleagues are...]" | |
| ], | |
| "opening": "Qu'est-ce que vous faites comme travail?\n(kess-kuh voo feht kohm trah-vay?)\n[What do you do for work?]" | |
| }, | |
| { | |
| "name": "Music and Hobbies", | |
| "phrases": [ | |
| "J'écoute... (zhay-koot) [I listen to...]", | |
| "Mon chanteur préféré est... (mohn shahn-tuhr pray-fay-ray ay) [My favorite singer is...]", | |
| "Je joue de... (zhuh zhoo duh) [I play (instrument)...]", | |
| "Dans mon temps libre... (dahn mohn tahn lee-bruh) [In my free time...]" | |
| ], | |
| "opening": "Quel type de musique aimez-vous?\n(kel teep duh mew-zeek ay-may voo?)\n[What type of music do you like?]" | |
| }, | |
| { | |
| "name": "Weekend Plans", | |
| "phrases": [ | |
| "Ce weekend, je vais... (suh wee-kehnd, zhuh vay) [This weekend, I'm going to...]", | |
| "J'aimerais... (zheh-muh-ray) [I would like to...]", | |
| "Avec mes amis... (ah-vek may zah-mee) [With my friends...]", | |
| "Ça sera amusant! (sah suh-rah ah-mew-zahn) [It will be fun!]" | |
| ], | |
| "opening": "Qu'est-ce que vous faites ce weekend?\n(kess-kuh voo feht suh wee-kehnd?)\n[What are you doing this weekend?]" | |
| }, | |
| { | |
| "name": "Family and Friends", | |
| "phrases": [ | |
| "Ma famille habite... (mah fah-mee ah-beet) [My family lives...]", | |
| "J'ai... frères/soeurs (zhay... frehr/suhr) [I have... brothers/sisters]", | |
| "Mon meilleur ami... (mohn may-yuhr ah-mee) [My best friend...]", | |
| "Nous aimons... ensemble (noo zeh-mohn... ahn-sahm-bluh) [We like to... together]" | |
| ], | |
| "opening": "Parlez-moi de votre famille!\n(pahr-lay mwah duh voh-truh fah-mee!)\n[Tell me about your family!]" | |
| }, | |
| { | |
| "name": "Weather and Seasons", | |
| "phrases": [ | |
| "Il fait beau/mauvais (eel feh boh/moh-veh) [The weather is nice/bad]", | |
| "J'aime l'été/l'hiver (zhehm lay-tay/lee-vehr) [I like summer/winter]", | |
| "Il pleut souvent (eel pluh soo-vahn) [It rains often]", | |
| "Ma saison préférée est... (mah seh-zohn pray-fay-ray ay) [My favorite season is...]" | |
| ], | |
| "opening": "Quel temps fait-il aujourd'hui?\n(kel tahn feh-teel oh-zhoor-dwee?)\n[What's the weather like today?]" | |
| }, | |
| { | |
| "name": "Travel and Vacations", | |
| "phrases": [ | |
| "J'ai visité... (zhay vee-zee-tay) [I visited...]", | |
| "Je voudrais aller à... (zhuh voo-dray ah-lay ah) [I would like to go to...]", | |
| "En vacances, je... (ahn vah-kahns, zhuh) [On vacation, I...]", | |
| "C'était magnifique! (say-teh mahn-yee-feek) [It was magnificent!]" | |
| ], | |
| "opening": "Où aimez-vous voyager?\n(oo ay-may voo vwah-yah-zhay?)\n[Where do you like to travel?]" | |
| } | |
| ] | |
| # Select a random topic | |
| selected_topic = random.choice(topics) | |
| # Format the scenario directly without using LLM | |
| scenario = f"""**Topic: {selected_topic['name']}** | |
| **Helpful phrases:** | |
| - {selected_topic['phrases'][0]} | |
| - {selected_topic['phrases'][1]} | |
| - {selected_topic['phrases'][2]} | |
| - {selected_topic['phrases'][3]} | |
| {selected_topic['opening']}""" | |
| return scenario | |
| except Exception as e: | |
| return f"Error generating scenario: {str(e)}" | |
| def extract_french_for_tts(text: str) -> str: | |
| """Extract only the French text (first line without parentheses/brackets)""" | |
| lines = text.strip().split('\n') | |
| for line in lines: | |
| line = line.strip() | |
| if line and '(' not in line and '[' not in line and '*' not in line and not line.startswith('**'): | |
| return line | |
| return "" | |
| def process_speech_to_text(audio_tuple) -> Tuple[str, bool]: | |
| """Convert audio to text using Groq Whisper""" | |
| if audio_tuple is None: | |
| return "No audio received", False | |
| try: | |
| sample_rate, audio_data = audio_tuple | |
| wav_buffer = io.BytesIO() | |
| sf.write(wav_buffer, audio_data, sample_rate, format='WAV') | |
| wav_buffer.seek(0) | |
| transcription = groq_client.audio.transcriptions.create( | |
| file=("audio.wav", wav_buffer), | |
| model="whisper-large-v3-turbo", | |
| language="fr" | |
| ) | |
| return transcription.text, True | |
| except Exception as e: | |
| error_msg = str(e) | |
| if "401" in error_msg or "Invalid API Key" in error_msg: | |
| return "Error: Invalid Groq API key. Please check your GROQ_API_KEY.", False | |
| elif "quota" in error_msg.lower(): | |
| return "Error: Groq API quota exceeded. Please check your account.", False | |
| else: | |
| return f"Error in speech recognition: {error_msg}", False | |
| def generate_tutor_response(conversation_history: List[Dict], user_text: str) -> str: | |
| global current_llm | |
| # Try Mistral first | |
| if mistral_client: | |
| try: | |
| messages = [ | |
| {"role": "system", "content": get_system_prompt()} | |
| ] | |
| for msg in conversation_history: | |
| role = "user" if msg["role"] == "user" else "assistant" | |
| messages.append({"role": role, "content": msg["content"]}) | |
| messages.append({"role": "user", "content": user_text}) | |
| response = mistral_client.chat.complete( | |
| model="mistral-large-latest", | |
| messages=messages | |
| ) | |
| raw_response = response.choices[0].message.content | |
| current_llm = "Mistral AI" | |
| is_valid, cleaned_response = validate_response_format(raw_response) | |
| if not is_valid: | |
| french_text = extract_french_for_tts(raw_response) | |
| if french_text: | |
| cleaned_response = f"{french_text}\n(pronunciation not available)\n[translation not available]" | |
| return cleaned_response | |
| except Exception as e: | |
| print(f"Mistral error: {str(e)}, falling back to Gemini") | |
| if not gemini_api_key: | |
| return f"Error: Mistral failed and no Gemini fallback available: {str(e)}" | |
| # Fallback to Gemini | |
| if gemini_api_key: | |
| try: | |
| genai.configure(api_key=gemini_api_key) | |
| model = genai.GenerativeModel("models/gemini-1.5-flash-latest") | |
| messages = [ | |
| {"role": "user", "parts": [get_system_prompt()]} | |
| ] | |
| for msg in conversation_history: | |
| messages.append({"role": msg["role"], "parts": [msg["content"]]}) | |
| messages.append({"role": "user", "parts": [user_text]}) | |
| response = model.generate_content(messages) | |
| raw_response = response.text | |
| current_llm = "Google Gemini (Fallback)" | |
| is_valid, cleaned_response = validate_response_format(raw_response) | |
| if not is_valid: | |
| french_text = extract_french_for_tts(raw_response) | |
| if french_text: | |
| cleaned_response = f"{french_text}\n(pronunciation not available)\n[translation not available]" | |
| return cleaned_response | |
| except Exception as e: | |
| return f"Error: Both Mistral and Gemini failed: {str(e)}" | |
| return "Error: No LLM available" | |
| def text_to_speech(text: str) -> str: | |
| global temp_audio_files | |
| try: | |
| french_text = extract_french_for_tts(text) | |
| if not french_text: | |
| return None | |
| # Use Groq TTS | |
| tts_response = groq_client.audio.speech.create( | |
| model="tts-1", # or "tts-1-hd" for higher quality | |
| voice="alloy", # or another supported voice, e.g., "echo", "fable", "onyx", "nova" | |
| input=french_text | |
| ) | |
| temp_dir = tempfile.mkdtemp() | |
| temp_path = os.path.join(temp_dir, f"audio_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp3") | |
| with open(temp_path, "wb") as f: | |
| f.write(tts_response.content) | |
| temp_audio_files.append(temp_path) | |
| cleanup_old_audio_files() | |
| return temp_path | |
| except Exception as e: | |
| error_msg = str(e) | |
| if "401" in error_msg or "Invalid API Key" in error_msg: | |
| print(f"Groq TTS Error: Invalid API key, falling back to gTTS") | |
| else: | |
| print(f"Groq TTS Error: {error_msg}, falling back to gTTS") | |
| # Fallback to gTTS if Groq fails | |
| try: | |
| from gtts import gTTS | |
| tts = gTTS(text=french_text, lang='fr') | |
| temp_dir = tempfile.mkdtemp() | |
| temp_path = os.path.join(temp_dir, f"audio_{datetime.now().strftime('%Y%m%d_%H%M%S')}.mp3") | |
| tts.save(temp_path) | |
| temp_audio_files.append(temp_path) | |
| cleanup_old_audio_files() | |
| return temp_path | |
| except Exception as e2: | |
| print(f"gTTS Fallback Error: {str(e2)}") | |
| return None | |
| def analyze_conversation(full_transcript: List[Dict]) -> str: | |
| global current_llm | |
| transcript_text = "\n".join([ | |
| f"{msg['role']}: {msg['content']}" for msg in full_transcript | |
| ]) | |
| analysis_prompt = """Analyze this French conversation and provide:\n1. Grammar corrections with specific examples\n2. Pronunciation tips for common mistakes\n3. Vocabulary suggestions to improve fluency\n4. Overall assessment with encouragement\n\nBe specific, constructive, and encouraging. Format clearly with sections.""" | |
| # Try Mistral first | |
| if mistral_client: | |
| try: | |
| messages = [ | |
| {"role": "system", "content": analysis_prompt}, | |
| {"role": "user", "content": f"Analyze this conversation:\n{transcript_text}"} | |
| ] | |
| response = mistral_client.chat.complete( | |
| model="mistral-large-latest", | |
| messages=messages | |
| ) | |
| current_llm = "Mistral AI" | |
| return response.choices[0].message.content | |
| except Exception as e: | |
| print(f"Mistral error in analysis: {str(e)}, falling back to Gemini") | |
| # Fallback to Gemini | |
| if gemini_api_key: | |
| try: | |
| genai.configure(api_key=gemini_api_key) | |
| model = genai.GenerativeModel("models/gemini-1.5-flash-latest") | |
| messages = [ | |
| {"role": "user", "parts": [analysis_prompt]}, | |
| {"role": "user", "parts": [f"Analyze this conversation:\n{transcript_text}"]} | |
| ] | |
| response = model.generate_content(messages) | |
| current_llm = "Google Gemini (Fallback)" | |
| return response.text | |
| except Exception as e: | |
| return f"Error generating analysis: {str(e)}" | |
| return "Error: No LLM available for analysis" | |
| def create_app(): | |
| with gr.Blocks(title="French Tutor", theme=gr.themes.Soft()) as app: | |
| # State management | |
| conversation_state = gr.State([]) | |
| exchange_count = gr.State(0) | |
| full_transcript = gr.State([]) | |
| current_scenario = gr.State("") | |
| gr.Markdown("# 🇫🇷 French Conversation Tutor") | |
| gr.Markdown("Practice French through natural conversation! (3 exchanges per session)") | |
| # Model info banner | |
| with gr.Row(): | |
| model_info = gr.Markdown( | |
| f"**🤖 Models:** LLM: {current_llm} | STT: Groq Whisper | TTS: gTTS", | |
| elem_id="model-info" | |
| ) | |
| # Main layout with two columns | |
| with gr.Row(): | |
| # Left sidebar (30% width) | |
| with gr.Column(scale=3): | |
| gr.Markdown("## 📚 Control Panel") | |
| # Start/New Topic buttons | |
| start_btn = gr.Button("Start New Conversation", variant="primary", size="lg") | |
| new_topic_btn = gr.Button("🎲 Generate New Topic & Restart", variant="secondary", visible=False) | |
| # Topic display in sidebar | |
| with gr.Group(): | |
| gr.Markdown("### Current Topic") | |
| sidebar_scenario = gr.Markdown("Click 'Start' to begin", elem_id="sidebar-scenario") | |
| # Analysis section in sidebar | |
| with gr.Group(visible=False) as analysis_group: | |
| gr.Markdown("### 📊 Your Analysis") | |
| analysis_box = gr.Markdown() | |
| restart_btn = gr.Button("🔄 Start Another Conversation", variant="secondary", size="lg") | |
| # Status in sidebar | |
| status_text = gr.Textbox( | |
| label="System Status", | |
| value="Ready to start", | |
| interactive=False | |
| ) | |
| # Right main content (70% width) | |
| with gr.Column(scale=7): | |
| # Conversation interface | |
| with gr.Column(visible=False) as conversation_ui: | |
| gr.Markdown("## 💬 Conversation") | |
| # Chat display - always visible | |
| chat_display = gr.Markdown(value="", elem_id="chat-display") | |
| # Progress indicator | |
| progress_text = gr.Textbox( | |
| label="Progress", | |
| value="Ready to start", | |
| interactive=False | |
| ) | |
| # Audio interface | |
| with gr.Row(): | |
| audio_input = gr.Audio( | |
| sources=["microphone"], | |
| type="numpy", | |
| label="🎤 Record your response in French" | |
| ) | |
| record_btn = gr.Button("Send Response", variant="primary") | |
| # Tutor's audio response | |
| audio_output = gr.Audio( | |
| label="🔊 Tutor's Response", | |
| type="filepath", | |
| autoplay=True | |
| ) | |
| def reset_conversation_states(): | |
| """Helper to reset all conversation states""" | |
| return [], 0, [], "", gr.update(value=None) | |
| def start_conversation(scenario_text=None): | |
| """Initialize a new conversation""" | |
| # Reset global state | |
| global current_llm | |
| print("Starting new conversation...") | |
| # Generate scenario if not provided | |
| if scenario_text is None: | |
| scenario = generate_scenario() | |
| else: | |
| scenario = scenario_text | |
| # Extract the tutor's first message for audio | |
| audio_path = text_to_speech(scenario) | |
| if audio_path is None: | |
| audio_path = gr.update() # No change to audio output | |
| # Format the scenario for display | |
| scenario_display = scenario.strip() | |
| # Create fresh empty states | |
| new_conversation_state = [] | |
| new_full_transcript = [] | |
| new_exchange_count = 0 | |
| print(f"Reset states - Exchange count: {new_exchange_count}, History length: {len(new_conversation_state)}") | |
| return ( | |
| gr.update(visible=True), # conversation_ui | |
| scenario_display, # sidebar_scenario | |
| scenario, # current_scenario state | |
| "", # clear chat_display | |
| new_exchange_count, # reset exchange_count | |
| new_conversation_state, # reset conversation_state | |
| new_full_transcript, # reset full_transcript | |
| audio_path, # play initial audio | |
| "Ready to start - 3 exchanges to go", # progress | |
| gr.update(visible=False), # hide analysis_group | |
| gr.update(visible=False), # hide start_btn | |
| gr.update(visible=True), # show new_topic_btn | |
| gr.update(value=None), # clear audio input | |
| gr.update(interactive=True), # enable record button | |
| "Ready to start" # status text | |
| ) | |
| def generate_new_topic_and_start(): | |
| """Generate a new topic and start the conversation""" | |
| scenario = generate_scenario() | |
| # Return all the values that start_conversation returns | |
| result = start_conversation(scenario) | |
| # Update the progress text | |
| result_list = list(result) | |
| result_list[8] = "New topic generated! Ready to start - 3 exchanges to go" # Update progress text | |
| return tuple(result_list) | |
| def process_user_audio(audio, chat_text, exchanges, history, transcript, scenario): | |
| """Process user's audio input and generate response""" | |
| global current_llm | |
| print(f"Processing audio - Exchange count: {exchanges}, History length: {len(history) if history else 0}") | |
| # Ensure exchange count is an integer | |
| if exchanges is None: | |
| exchanges = 0 | |
| # Check if conversation is complete | |
| if exchanges >= 3: | |
| return ( | |
| chat_text, exchanges, history, transcript, | |
| "Conversation complete! Check your analysis in the sidebar.", | |
| f"Exchange {exchanges} of 3 - Complete!", | |
| gr.update(), gr.update(value=None), | |
| gr.update() # no change to model_info | |
| ) | |
| # Ensure states are properly initialized | |
| if history is None: | |
| history = [] | |
| if transcript is None: | |
| transcript = [] | |
| if chat_text is None: | |
| chat_text = "" | |
| # Check for audio | |
| if audio is None: | |
| return ( | |
| chat_text, exchanges, history, transcript, | |
| "Please record audio first", | |
| f"Exchange {exchanges} of 3", | |
| gr.update(), gr.update(value=None), | |
| gr.update() # no change to model_info | |
| ) | |
| # Transcribe user's speech | |
| user_text, success = process_speech_to_text(audio) | |
| if not success: | |
| return ( | |
| chat_text, exchanges, history, transcript, | |
| user_text, # Error message | |
| f"Exchange {exchanges} of 3", | |
| gr.update(), gr.update(value=None), | |
| gr.update() # no change to model_info | |
| ) | |
| # Update chat display with user's message | |
| if chat_text: | |
| chat_text += f"\n\n**You:** {user_text}" | |
| else: | |
| # First message - include scenario context | |
| chat_text = f"{scenario}\n\n---\n\n**You:** {user_text}" | |
| # Get tutor's response | |
| tutor_response = generate_tutor_response(history, user_text) | |
| # Generate audio for tutor's response | |
| audio_path = text_to_speech(tutor_response) | |
| if audio_path is None: | |
| audio_path = gr.update() # No change to audio output | |
| # Update chat display with tutor's response | |
| chat_text += f"\n\n**Mr. Mistral:**\n{tutor_response}" | |
| # Update conversation history (for context) | |
| history.append({"role": "user", "content": user_text}) | |
| history.append({"role": "assistant", "content": tutor_response}) | |
| # Update transcript (for analysis) | |
| transcript.extend([ | |
| {"role": "user", "content": user_text}, | |
| {"role": "assistant", "content": tutor_response} | |
| ]) | |
| # Increment exchange counter | |
| exchanges += 1 | |
| # Check if this was the last exchange | |
| if exchanges >= 3: | |
| progress_msg = "Exchange 3 of 3 - Complete! Analysis ready." | |
| else: | |
| progress_msg = f"Exchange {exchanges} of 3 - Keep going!" | |
| # Update model info | |
| model_info_text = f"**🤖 Models:** LLM: {current_llm} | STT: Groq Whisper | TTS: gTTS" | |
| # Return updated state | |
| return ( | |
| chat_text, | |
| exchanges, | |
| history, | |
| transcript, | |
| f"Great! {progress_msg}", | |
| progress_msg, | |
| audio_path, | |
| gr.update(value=None), # Clear audio input properly | |
| gr.update(value=model_info_text) # Update model info | |
| ) | |
| def show_analysis_if_complete(exchanges, transcript): | |
| """Show analysis in sidebar if conversation is complete""" | |
| if exchanges >= 3: | |
| analysis = analyze_conversation(transcript) | |
| return ( | |
| gr.update(visible=True, value=analysis), # analysis_box with content | |
| gr.update(visible=True), # analysis_group | |
| gr.update(interactive=False), # disable record button | |
| gr.update(visible=False) # hide new topic button | |
| ) | |
| return ( | |
| gr.update(), # no change to analysis_box | |
| gr.update(), # no change to analysis_group | |
| gr.update(interactive=True), # keep record button enabled | |
| gr.update() # no change to new topic button | |
| ) | |
| # Initialize API on load | |
| def check_initialization(): | |
| status_msgs = [] | |
| if mistral_client: | |
| status_msgs.append("✓ Mistral AI ready") | |
| if gemini_api_key: | |
| status_msgs.append("✓ Gemini fallback ready") | |
| if groq_client: | |
| status_msgs.append("✓ Groq STT ready") | |
| status_msgs.append("✓ gTTS ready") | |
| if not status_msgs: | |
| return "❌ No APIs initialized!" | |
| return " | ".join(status_msgs) | |
| app.load( | |
| fn=check_initialization, | |
| outputs=status_text | |
| ) | |
| # Start conversation | |
| start_btn.click( | |
| fn=start_conversation, | |
| outputs=[ | |
| conversation_ui, sidebar_scenario, current_scenario, | |
| chat_display, exchange_count, conversation_state, | |
| full_transcript, audio_output, progress_text, | |
| analysis_group, start_btn, new_topic_btn, | |
| audio_input, record_btn, status_text | |
| ] | |
| ) | |
| # Generate new topic and start conversation | |
| new_topic_btn.click( | |
| fn=generate_new_topic_and_start, | |
| outputs=[ | |
| conversation_ui, sidebar_scenario, current_scenario, | |
| chat_display, exchange_count, conversation_state, | |
| full_transcript, audio_output, progress_text, | |
| analysis_group, start_btn, new_topic_btn, | |
| audio_input, record_btn, status_text | |
| ] | |
| ) | |
| # Process user audio | |
| record_btn.click( | |
| fn=process_user_audio, | |
| inputs=[ | |
| audio_input, chat_display, exchange_count, | |
| conversation_state, full_transcript, current_scenario | |
| ], | |
| outputs=[ | |
| chat_display, exchange_count, conversation_state, | |
| full_transcript, status_text, progress_text, | |
| audio_output, audio_input, model_info | |
| ], | |
| queue=False # Disable queueing to avoid state issues | |
| ).then( | |
| fn=show_analysis_if_complete, | |
| inputs=[exchange_count, full_transcript], | |
| outputs=[analysis_box, analysis_group, record_btn, new_topic_btn], | |
| queue=False # Disable queueing to avoid state issues | |
| ) | |
| # Restart conversation | |
| restart_btn.click( | |
| fn=start_conversation, | |
| outputs=[ | |
| conversation_ui, sidebar_scenario, current_scenario, | |
| chat_display, exchange_count, conversation_state, | |
| full_transcript, audio_output, progress_text, | |
| analysis_group, start_btn, new_topic_btn, | |
| audio_input, record_btn, status_text | |
| ] | |
| ) | |
| return app | |
| # Launch the app | |
| if __name__ == "__main__": | |
| try: | |
| app = create_app() | |
| app.launch() | |
| except Exception as e: | |
| print(f"Failed to start app: {e}") |