Update app.py

app.py

@@ -1,316 +1,404 @@
 import streamlit as st
 import torch
+import logging
 import numpy as np
-import re
-from transformers import (
-    AutoModelForCausalLM, 
-    AutoTokenizer, 
-    AutoModelForSpeechSeq2Seq,
-    AutoProcessor
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import whisper
+from TTS.api import TTS
+from streamlit_webrtc import webrtc_streamer, WebRtcMode, AudioProcessorBase
+import av
+
+# Configure logging
+logging.basicConfig(
+    level=logging.INFO,
+    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
+    handlers=[
+        logging.FileHandler("language_companion.log"),
+        logging.StreamHandler()
+    ]
 )
-import streamlit.components.v1 as components
+logger = logging.getLogger(__name__)
 
-# Avatar Personas (same as previous implementation)
+# Comprehensive Avatar Personas
 AVATAR_PERSONAS = {
     "Rat": {
-        "image": "rat.png",
         "name": "Puzzle Master Rat",
-        "description": "Clever and resourceful. Loves puzzles and word games.",
-        "sample": "Let's solve a riddle together!",
-        "teaching_style": "Analytical and game-based learning",
-        "learning_tips": [
-            "Break complex ideas into smaller puzzles",
-            "Use word games to learn vocabulary",
-            "Think critically about language patterns"
+        "description": "Clever linguistic detective specializing in language mysteries",
+        "teaching_style": "Analytical, puzzle-driven language learning",
+        "learning_approach": """
+        Transform language learning into an intellectual adventure.
+        Break complex linguistic concepts into engaging, logical puzzles.
+        Encourage critical thinking and systematic problem-solving.
+        """,
+        "motivation_techniques": [
+            "Convert grammar rules into exciting challenges",
+            "Reward innovative language problem-solving",
+            "Create intricate linguistic treasure hunts"
         ]
     },
     "Ox": {
-        "image": "ox.png",
-        "name": "Professor Ox",
-        "description": "Strong and dependable. Very patient when explaining concepts.",
-        "sample": "I will guide you step by step.",
-        "teaching_style": "Structured and systematic approach",
-        "learning_tips": [
-            "Learn grammar rules systematically",
-            "Practice one concept at a time",
-            "Build a strong foundation"
+        "name": "Professor Steady Ox",
+        "description": "Methodical language foundation builder",
+        "teaching_style": "Structured, step-by-step comprehensive learning",
+        "learning_approach": """
+        Construct language skills like building a robust architectural design.
+        Provide clear, systematic explanations of grammatical structures.
+        Emphasize consistent, patient progression in linguistic development.
+        """,
+        "motivation_techniques": [
+            "Break down complex language concepts into manageable segments",
+            "Celebrate incremental learning achievements",
+            "Provide consistent, encouraging feedback"
         ]
     },
     "Tiger": {
-        "image": "tiger.png",
         "name": "Adventure Coach Tiger",
-        "description": "Brave and energetic. Loves exciting challenges.",
-        "sample": "Let's make learning an adventure!",
-        "teaching_style": "High-energy and challenge-driven",
-        "learning_tips": [
-            "Turn learning into a fun challenge",
-            "Set exciting language goals",
-            "Celebrate every bit of progress"
+        "description": "Dynamic linguistic expedition leader",
+        "teaching_style": "High-energy, challenge-driven language exploration",
+        "learning_approach": """
+        Transform language learning into an exhilarating global adventure.
+        Create competitive and motivational linguistic environments.
+        Encourage bold communication attempts and celebrate linguistic courage.
+        """,
+        "motivation_techniques": [
+            "Design exciting language learning challenges",
+            "Turn mistakes into heroic growth opportunities",
+            "Use passionate, motivational communication"
         ]
     },
     "Rabbit": {
-        "image": "rabbit.png",
         "name": "Storyteller Rabbit",
-        "description": "Gentle and kind. Encourages learning through storytelling.",
-        "sample": "I have a story to share with you!",
-        "teaching_style": "Narrative and empathetic learning",
-        "learning_tips": [
-            "Learn through engaging stories",
-            "Connect language to emotional experiences",
-            "Use imagination to remember vocabulary"
+        "description": "Gentle narrative-based language nurturer",
+        "teaching_style": "Empathetic, story-driven emotional learning",
+        "learning_approach": """
+        Teach language through compassionate, engaging storytelling.
+        Connect emotional experiences with linguistic development.
+        Create a safe, nurturing language learning sanctuary.
+        """,
+        "motivation_techniques": [
+            "Use storytelling to illustrate complex language concepts",
+            "Connect vocabulary to emotional narratives",
+            "Provide gentle, supportive linguistic guidance"
         ]
     },
     "Dragon": {
-        "image": "dragon.png",
         "name": "Scholar Dragon",
-        "description": "Confident and intelligent. Explains ideas clearly.",
-        "sample": "I will help you think like a scholar!",
-        "teaching_style": "Intellectual and precise instruction",
-        "learning_tips": [
-            "Understand the logic behind language rules",
-            "Analyze language structures",
-            "Develop a scholarly approach to learning"
+        "description": "Intellectual linguistic mentor",
+        "teaching_style": "Sophisticated, precision-focused academic learning",
+        "learning_approach": """
+        Develop a scholarly, analytical approach to language acquisition.
+        Explore linguistic structures with intellectual curiosity.
+        Encourage deep, critical engagement with communication.
+        """,
+        "motivation_techniques": [
+            "Explain intricate linguistic logic and patterns",
+            "Encourage sophisticated language analysis",
+            "Provide nuanced, intellectual explanations"
         ]
     },
     "Snake": {
-        "image": "snake.png",
-        "name": "Philosopher Snake",
-        "description": "Calm and analytical. Gives insightful explanations.",
-        "sample": "Let's break this down logically!",
-        "teaching_style": "Reflective and analytical learning",
-        "learning_tips": [
-            "Think deeply about language nuances",
-            "Understand the 'why' behind grammar rules",
-            "Develop critical thinking in language"
+        "name": "Philosophical Snake",
+        "description": "Contemplative language wisdom guide",
+        "teaching_style": "Reflective, meditative language exploration",
+        "learning_approach": """
+        Explore language as a profound means of human connection.
+        Encourage deep thinking about communication's subtle nuances.
+        Develop critical, mindful language comprehension skills.
+        """,
+        "motivation_techniques": [
+            "Discuss language as a cultural and philosophical expression",
+            "Encourage thoughtful, intentional communication",
+            "Explore linguistic subtleties and contextual meanings"
         ]
     },
     "Horse": {
-        "image": "horse.png",
         "name": "Energetic Coach Horse",
-        "description": "Cheerful and enthusiastic. Encourages active participation.",
-        "sample": "Come on, let's say it together!",
-        "teaching_style": "Interactive and participatory learning",
-        "learning_tips": [
-            "Practice speaking out loud",
-            "Engage actively in conversations",
-            "Build confidence through participation"
+        "description": "Dynamic, interactive language motivator",
+        "teaching_style": "Active, participatory communication training",
+        "learning_approach": """
+        Engage learners through vibrant, interactive language practice.
+        Encourage continuous speaking, listening, and communication.
+        Build confidence through enthusiastic participation.
+        """,
+        "motivation_techniques": [
+            "Create engaging, interactive speaking exercises",
+            "Provide immediate, energetic feedback",
+            "Celebrate every communication attempt"
         ]
     },
     "Goat": {
-        "image": "goat.png",
         "name": "Creative Mentor Goat",
-        "description": "Creative and friendly. Uses fun examples.",
-        "sample": "Let's use pictures to understand this!",
-        "teaching_style": "Visual and creative learning",
-        "learning_tips": [
-            "Use visual aids to learn vocabulary",
-            "Create mental images for new words",
-            "Learn through creative and fun methods"
+        "description": "Imaginative linguistic artist",
+        "teaching_style": "Creative, visual language exploration",
+        "learning_approach": """
+        Transform language learning into an artistic, imaginative journey.
+        Connect vocabulary and grammar to creative expression.
+        Make linguistic development a playful, visual experience.
+        """,
+        "motivation_techniques": [
+            "Use artistic and visual language learning techniques",
+            "Encourage creative linguistic representation",
+            "Turn grammar into artistic challenges"
         ]
     },
     "Monkey": {
-        "image": "monkey.png",
         "name": "Playful Genius Monkey",
-        "description": "Smart and playful. Makes learning fun.",
-        "sample": "I love word games! Do you?",
-        "teaching_style": "Playful and game-oriented learning",
-        "learning_tips": [
-            "Turn learning into a fun game",
-            "Use humor to remember language",
-            "Enjoy the process of learning"
+        "description": "Witty, intelligent language game master",
+        "teaching_style": "Humorous, game-oriented linguistic play",
+        "learning_approach": """
+        Transform language learning into an entertaining, witty adventure.
+        Use word games, linguistic puzzles, and clever challenges.
+        Make communication feel like an enjoyable, intellectual game.
+        """,
+        "motivation_techniques": [
+            "Create entertaining language learning games",
+            "Use humor to make learning memorable",
+            "Reward creative and playful language use"
         ]
     },
     "Rooster": {
-        "image": "rooster.png",
         "name": "Pronunciation Master Rooster",
-        "description": "Confident and vocal. Encourages clear pronunciation.",
-        "sample": "Let's practice speaking clearly!",
-        "teaching_style": "Phonetic and pronunciation-focused",
-        "learning_tips": [
-            "Focus on clear pronunciation",
-            "Practice accent and intonation",
-            "Listen carefully to native speakers"
+        "description": "Precise linguistic sound expert",
+        "teaching_style": "Phonetic, accent-perfection focused learning",
+        "learning_approach": """
+        Develop crystal-clear pronunciation and melodious intonation.
+        Focus on the musical rhythm and precise articulation of language.
+        Encourage confident, articulate communication.
+        """,
+        "motivation_techniques": [
+            "Practice pronunciation through engaging exercises",
+            "Provide detailed, constructive phonetic guidance",
+            "Celebrate clear, confident speaking"
         ]
     },
     "Dog": {
-        "image": "dog.png",
         "name": "Supportive Buddy Dog",
-        "description": "Loyal and encouraging. Builds confidence in learners.",
-        "sample": "You're doing a great job!",
-        "teaching_style": "Supportive and confidence-building",
-        "learning_tips": [
-            "Believe in your learning abilities",
-            "Don't fear making mistakes",
-            "Stay motivated and persistent"
+        "description": "Loyal, encouraging language learning companion",
+        "teaching_style": "Supportive, confidence-building linguistic nurturing",
+        "learning_approach": """
+        Create a safe, unconditionally supportive language learning environment.
+        Build learner confidence through patient, kind guidance.
+        Emphasize emotional well-being in communication development.
+        """,
+        "motivation_techniques": [
+            "Provide constant, positive linguistic reinforcement",
+            "Create a judgment-free learning space",
+            "Celebrate every communication milestone"
         ]
     },
     "Pig": {
-        "image": "pig.png",
         "name": "Relaxed Mentor Pig",
-        "description": "Easygoing and kind. Makes learning feel natural.",
-        "sample": "Let's take it step by step together!",
-        "teaching_style": "Relaxed and natural learning",
-        "learning_tips": [
-            "Learn at your own pace",
-            "Stay calm and enjoy the process",
-            "Make learning a comfortable experience"
+        "description": "Easygoing, kind language learning facilitator",
+        "teaching_style": "Calm, natural language absorption",
+        "learning_approach": """
+        Promote stress-free, organic language learning.
+        Allow learners to progress at their comfortable, natural pace.
+        Create a relaxed, enjoyable linguistic exploration environment.
+        """,
+        "motivation_techniques": [
+            "Reduce language learning anxiety",
+            "Encourage natural, pressure-free communication",
+            "Provide gentle, supportive linguistic guidance"
         ]
     }
 }
 
-class AdvancedLanguageLearningAssistant:
+class AudioProcessor(AudioProcessorBase):
+    def __init__(self, companion):
+        self.companion = companion
+        self.audio_buffer = []
+        self.sample_rate = 16000
+        self.recording_duration = 5  # 5 seconds of audio before processing
+
+    def recv(self, frame: av.AudioFrame) -> av.AudioFrame:
+        # Convert audio frame to numpy array
+        audio_input = frame.to_ndarray(format="f32")
+        
+        # Accumulate audio
+        if len(audio_input.shape) > 1:
+            audio_input = audio_input[:, 0]  # Take first channel if stereo
+        
+        self.audio_buffer.extend(audio_input)
+        
+        # Process when buffer reaches sufficient length
+        if len(self.audio_buffer) >= self.sample_rate * self.recording_duration:
+            try:
+                # Convert buffer to wav file
+                audio_array = np.array(self.audio_buffer[:self.sample_rate * self.recording_duration])
+                sf.write('temp_recording.wav', audio_array, self.sample_rate)
+                
+                # Transcribe
+                transcription = self.companion.transcribe_audio('temp_recording.wav')
+                
+                # Generate response
+                if transcription:
+                    response = self.companion.generate_response(transcription)
+                    
+                    # Text to Speech
+                    if response:
+                        audio_response = self.companion.text_to_speech(response)
+                        
+                        # Display results
+                        st.session_state.transcription = transcription
+                        st.session_state.response = response
+                
+                # Clear buffer
+                self.audio_buffer = []
+            
+            except Exception as e:
+                logging.error(f"Audio processing error: {e}")
+                st.error("Error processing audio")
+                self.audio_buffer = []
+        
+        return frame
+
+def main():
+    st.title("Language Learning Companion")
+    
+    # Initialize session state for storing conversation
+    if 'transcription' not in st.session_state:
+        st.session_state.transcription = ""
+    if 'response' not in st.session_state:
+        st.session_state.response = ""
+    
+    # Avatar Selection
+    avatar_selection = st.selectbox(
+        "Choose Your Learning Buddy", 
+        list(AVATAR_PERSONAS.keys())
+    )
+    
+    # Initialize Companion
+    companion = LanguageLearningCompanion(avatar_selection)
+    
+    # WebRTC Audio Capture with Custom Processor
+    ctx = webrtc_streamer(
+        key="language-learning",
+        mode=WebRtcMode.SENDRECV,
+        audio_processor_factory=lambda: AudioProcessor(companion),
+        media_stream_constraints={
+            "audio": True,
+            "video": False
+        }
+    )
+    
+    # Display Conversation
+    if st.session_state.transcription:
+        st.subheader("Your Speech")
+        st.write(st.session_state.transcription)
+    
+    if st.session_state.response:
+        st.subheader("Companion's Response")
+        st.write(st.session_state.response)
+    
+    # Optional: Play response audio
+    if os.path.exists('response.wav'):
+        st.audio('response.wav', format='audio/wav')
+
+if __name__ == "__main__":
+    main()
+    
+class LanguageLearningCompanion:
     def __init__(self, avatar_name):
-        # Existing implementation from previous version
-        self.avatar = AVATAR_PERSONAS[avatar_name]
+        try:
+            # Model Initialization with Quantization
+            self.model = AutoModelForCausalLM.from_pretrained(
+                "mistralai/Mistral-7B-Instruct-v0.1",
+                load_in_8bit=True,
+                device_map="auto"
+            )
+            self.tokenizer = AutoTokenizer.from_pretrained("mistralai/Mistral-7B-Instruct-v0.1")
+            
+            # Speech Models
+            self.whisper_model = whisper.load_model("base")
+            self.tts_model = TTS(model_name="tts_models/multilingual/multi-dataset/your_tts")
+            
+            # Avatar Selection
+            self.avatar = AVATAR_PERSONAS.get(avatar_name, AVATAR_PERSONAS["Rat"])
+            
+            logger.info(f"Initialized Language Learning Companion with {avatar_name}")
         
-        # Simplified model loading for Hugging Face Spaces
+        except Exception as e:
+            logger.error(f"Model initialization error: {e}")
+            st.error("Error loading models. Please try again later.")
+
+    def transcribe_audio(self, audio_path):
+        """Transcribe audio using Whisper"""
         try:
-            self.llm_model = AutoModelForCausalLM.from_pretrained("microsoft/DialoGPT-small")
-            self.llm_tokenizer = AutoTokenizer.from_pretrained("microsoft/DialoGPT-small")
+            result = self.whisper_model.transcribe(audio_path)
+            logger.info(f"Successfully transcribed audio: {result['text']}")
+            return result['text']
         except Exception as e:
-            st.error(f"Model loading error: {e}")
-            self.llm_model = None
-            self.llm_tokenizer = None
+            logger.error(f"Transcription error: {e}")
+            st.error("Error transcribing audio.")
+            return None
 
     def generate_response(self, user_input):
-        if not self.llm_model:
-            return "Sorry, I'm having trouble generating a response."
-
-        # Incorporate avatar's unique personality
-        prompt = f"""
-        Avatar: {self.avatar['name']}
-        Teaching Style: {self.avatar['teaching_style']}
-        User Input: {user_input}
-        
-        Generate a response that:
-        1. Reflects the avatar's unique personality
-        2. Provides encouraging language learning support
-        3. Maintains an engaging tone
-        """
-
+        """Generate educational response using Mistral"""
         try:
-            inputs = self.llm_tokenizer.encode(prompt, return_tensors='pt')
-            outputs = self.llm_model.generate(
-                inputs, 
-                max_length=150, 
-                temperature=0.7
-            )
+            prompt = f"""
+            Avatar: {self.avatar['name']}
+            Teaching Style: {self.avatar['teaching_style']}
+            Learning Approach: {self.avatar['learning_approach']}
+            
+            User Input: {user_input}
+            
+            Generate an encouraging, educational response that:
+            1. Addresses the user's input
+            2. Provides gentle language learning guidance
+            3. Maintains an engaging, child-friendly tone
+            """
+            
+            inputs = self.tokenizer(prompt, return_tensors="pt")
+            outputs = self.model.generate(**inputs, max_length=200)
+            response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
             
-            response = self.llm_tokenizer.decode(outputs[0], skip_special_tokens=True)
+            logger.info(f"Generated response for input: {user_input}")
             return response
+        
         except Exception as e:
-            return f"Sorry, I'm having trouble generating a response. Error: {e}"
-
-def avatar_selection_page():
-    """
-    First stage: Avatar Selection
-    """
-    st.title("Choose Your Learning Companion")
-    
-    # Custom CSS for avatar selection
-    st.markdown("""
-    <style>
-    .avatar-grid {
-        display: grid;
-        grid-template-columns: repeat(3, 1fr);
-        gap: 20px;
-        padding: 20px;
-    }
-    .avatar-card {
-        border: 2px solid #f0f0f0;
-        border-radius: 10px;
-        padding: 15px;
-        text-align: center;
-        transition: all 0.3s ease;
-    }
-    .avatar-card:hover {
-        transform: scale(1.05);
-        border-color: #4CAF50;
-    }
-    .avatar-image {
-        width: 200px;
-        height: 200px;
-        object-fit: cover;
-        border-radius: 50%;
-    }
-    </style>
-    """, unsafe_allow_html=True)
+            logger.error(f"Response generation error: {e}")
+            st.error("Error generating response.")
+            return None
 
-    # Avatar Selection Grid
-    st.markdown('<div class="avatar-grid">', unsafe_allow_html=True)
-    
-    for avatar_key, avatar_info in AVATAR_PERSONAS.items():
-        st.markdown(f'''
-        <div class="avatar-card">
-            <img src="images/{avatar_info['image']}" class="avatar-image" alt="{avatar_info['name']}">
-            <h3>{avatar_info['name']}</h3>
-            <p>{avatar_info['description']}</p>
-            <button onclick="selectAvatar('{avatar_key}')">Select {avatar_info['name']}</button>
-        </div>
-        ''', unsafe_allow_html=True)
-    
-    st.markdown('</div>', unsafe_allow_html=True)
-
-    # JavaScript to handle avatar selection
-    st.markdown("""
-    <script>
-    function selectAvatar(avatarKey) {
-        window.parent.postMessage({type: 'avatarSelected', avatarKey: avatarKey}, '*');
-    }
-    </script>
-    """, unsafe_allow_html=True)
+    def text_to_speech(self, text):
+        """Convert text to speech"""
+        try:
+            self.tts_model.tts_to_file(text=text, file_path="response.wav")
+            logger.info("Successfully converted text to speech")
+            return "response.wav"
+        except Exception as e:
+            logger.error(f"Text-to-speech conversion error: {e}")
+            st.error("Error converting text to speech.")
+            return None
 
-def conversation_page(selected_avatar):
-    """
-    Second stage: Conversation Interface
-    """
-    st.title(f"Learning English with {AVATAR_PERSONAS[selected_avatar]['name']}")
+def main():
+    st.title("Language Learning Companion")
     
-    # Initialize Assistant
-    assistant = AdvancedLanguageLearningAssistant(selected_avatar)
+    # Avatar Selection
+    avatar_selection = st.selectbox(
+        "Choose Your Learning Buddy", 
+        list(AVATAR_PERSONAS.keys())
+    )
     
-    # Conversation Interface
-    user_input = st.text_input("Type your message in English:")
+    # Initialize Companion
+    companion = LanguageLearningCompanion(avatar_selection)
     
-    if st.button("Send"):
-        if user_input:
-            response = assistant.generate_response(user_input)
-            st.write(f"🤖 {response}")
-
-def main():
-    # Initialize session state for tracking app stage
-    if 'stage' not in st.session_state:
-        st.session_state.stage = 'avatar_selection'
-    if 'selected_avatar' not in st.session_state:
-        st.session_state.selected_avatar = None
-
-    # Handle avatar selection
-    components.html("""
-    <script>
-    window.addEventListener('message', function(event) {
-        if (event.data.type === 'avatarSelected') {
-            window.parent.postMessage({
-                type: 'streamlit:setComponentValue', 
-                key: 'selected_avatar', 
-                value: event.data.avatarKey
-            }, '*');
-        }
-    });
-    </script>
-    """, height=0)
-
-    # Retrieve selected avatar
-    selected_avatar = st.experimental_get_query_params().get('selected_avatar', [None])[0]
+    # WebRTC Audio Capture
+    webrtc_ctx = webrtc_streamer(
+        key="language-companion",
+        mode=WebRtcMode.SENDRECV,
+        media_stream_constraints={"audio": True, "video": False}
+    )
     
-    if selected_avatar:
-        st.session_state.selected_avatar = selected_avatar
-        st.session_state.stage = 'conversation'
-
-    # Render appropriate page based on stage
-    if st.session_state.stage == 'avatar_selection':
-        avatar_selection_page()
-    elif st.session_state.stage == 'conversation':
-        conversation_page(st.session_state.selected_avatar)
+    if st.button("Transcribe and Respond"):
+        if webrtc_ctx.audio_receiver:
+            try:
+                # Placeholder for audio processing
+                # In a real implementation, you'd capture and process the audio
+                st.warning("Audio processing not fully implemented in this version")
+            except Exception as e:
+                logger.error(f"WebRTC audio processing error: {e}")
+                st.error("Error processing audio.")
 
 if __name__ == "__main__":
     main()