Update src/components/ai_tutor.py

src/components/ai_tutor.py

@@ -1,46 +1,153 @@
 import streamlit as st
-from src.services.ai_service import AITutorService
-from src.utils.session import get_tutor_context
-from datetime import datetime
 import platform
 import base64
-from openai import OpenAI
-import tempfile
 import os
+import tempfile
+import threading
+from datetime import datetime
+
+# Optional third-party imports with error handling
+try:
+    import pyttsx3
+    PYTTSX3_AVAILABLE = True
+except ImportError:
+    PYTTSX3_AVAILABLE = False
+
+try:
+    from openai import OpenAI
+    OPENAI_AVAILABLE = True
+except ImportError:
+    OPENAI_AVAILABLE = False
+
+class AITutorService:
+    def __init__(self):
+        """Initialize the AI Tutor Service"""
+        self.topics = {
+            'Physics': self._generate_physics_response,
+            'Mathematics': self._generate_math_response,
+            'Computer Science': self._generate_cs_response,
+            'Artificial Intelligence': self._generate_ai_response
+        }
+
+    def display_avatar(self, state='neutral'):
+        """
+        Display avatar with fallback text descriptions
+        
+        Args:
+            state (str): Avatar state (neutral, happy, thinking)
+        """
+        try:
+            # Placeholder for actual avatar image rendering
+            avatar_paths = {
+                'neutral': 'path/to/neutral_avatar.png',
+                'happy': 'path/to/happy_avatar.png',
+                'thinking': 'path/to/thinking_avatar.png'
+            }
+            
+            # If image path exists and is valid, render image
+            if state in avatar_paths:
+                st.image(avatar_paths[state], width=200)
+            else:
+                # Fallback text descriptions
+                avatar_descriptions = {
+                    'neutral': 'AI Tutor is listening',
+                    'happy': 'AI Tutor looks excited',
+                    'thinking': 'AI Tutor is pondering'
+                }
+                st.write(avatar_descriptions.get(state, 'AI Tutor'))
+        
+        except Exception as e:
+            st.warning(f"Could not render avatar: {e}")
+            st.write("AI Tutor is here to help!")
+
+    def generate_response(self, user_input, topic=None):
+        """
+        Generate a response based on user input and selected topic
+        
+        Args:
+            user_input (str): User's question or message
+            topic (str, optional): Selected learning topic
+        
+        Returns:
+            str: Generated response
+        """
+        try:
+            # If no specific topic, use a general response generator
+            if not topic or topic not in self.topics:
+                return self._generate_general_response(user_input)
+            
+            # Use topic-specific response generator
+            return self.topics[topic](user_input)
+        
+        except Exception as e:
+            return f"I apologize, but I'm having trouble generating a response. Error: {e}"
+
+    def _generate_general_response(self, user_input):
+        """General response generation method"""
+        return f"Thank you for your message: '{user_input}'. How can I help you learn today?"
+
+    def _generate_physics_response(self, user_input):
+        """Physics-specific response generator"""
+        return "Let's explore physics together! What specific physics concept interests you?"
+
+    def _generate_math_response(self, user_input):
+        """Mathematics-specific response generator"""
+        return "Mathematics is fascinating! What mathematical topic would you like to discuss?"
+
+    def _generate_cs_response(self, user_input):
+        """Computer Science-specific response generator"""
+        return "Computer Science is an exciting field! What programming or tech area would you like to learn about?"
+
+    def _generate_ai_response(self, user_input):
+        """AI-specific response generator"""
+        return "Artificial Intelligence is a rapidly evolving field. What aspect of AI intrigues you?"
 
 class AITutor:
     def __init__(self):
-        self.service = AITutorService()
-        self.voice_enabled = False
-        self.tts_mode = None  # 'local' or 'openai'
-        self.openai_enabled = False  # Initialize the flag
-        self.initialize_openai()  # Initialize OpenAI first
-        self.initialize_speech_components()  # Then initialize speech components
+        """Initialize AI Tutor with fallback mechanisms"""
+        self.fallback_mode = False
+        
+        try:
+            self.service = AITutorService()
+            self.voice_enabled = False
+            self.tts_mode = None
+            self.openai_enabled = False
+            
+            # Initialize components
+            self.initialize_openai()
+            self.initialize_speech_components()
+        
+        except Exception as e:
+            st.error(f"Could not initialize AI Tutor: {e}")
+            self.fallback_mode = True
 
     def initialize_openai(self):
-        """Initialize OpenAI client"""
+        """Initialize OpenAI client with error handling"""
+        if not OPENAI_AVAILABLE:
+            st.warning("OpenAI library not installed. Voice features will be limited.")
+            return
+
         try:
-            # Get API key from environment variable
             api_key = os.getenv('OPENAI_API_KEY')
             if not api_key:
-                st.warning("OpenAI API key not found in environment variables. Voice features will be limited.")
-                self.openai_enabled = False
+                st.warning("OpenAI API key not found. Voice features will be limited.")
                 return
 
             self.openai_client = OpenAI(api_key=api_key)
             self.openai_enabled = True
-            
+        
         except Exception as e:
-            st.warning("Error initializing OpenAI client. Voice features will be limited.")
-            self.openai_enabled = False
+            st.warning(f"Error initializing OpenAI client: {e}")
 
     def initialize_speech_components(self):
-        """Initialize text-to-speech with fallback options"""
-        if 'tts_engine' not in st.session_state:
-            try:
-                import pyttsx3
-                
-                # Try local TTS first
+        """Initialize text-to-speech with comprehensive fallback options"""
+        if not PYTTSX3_AVAILABLE and not self.openai_enabled:
+            st.info("No TTS engines available. Voice output disabled.")
+            return
+
+        try:
+            if PYTTSX3_AVAILABLE:
+                # Local TTS initialization
                 system = platform.system()
                 if system == "Windows":
                     st.session_state.tts_engine = pyttsx3.init(driverName='sapi5')
@@ -58,88 +165,88 @@ class AITutor:
                     female_voice = next((voice for voice in voices if 'female' in voice.name.lower()), voices[0])
                     st.session_state.tts_engine.setProperty('voice', female_voice.id)
                 except Exception:
-                    pass  # Use default voice if female voice setting fails
+                    pass  # Use default voice
                 
                 self.voice_enabled = True
                 self.tts_mode = 'local'
-            except Exception as e:
-                st.info("Local text-to-speech unavailable. Falling back to OpenAI TTS.")
-                st.session_state.tts_engine = None
-                if self.openai_enabled:
-                    self.voice_enabled = True
-                    self.tts_mode = 'openai'
-                else:
-                    self.voice_enabled = False
-                    self.tts_mode = None
+            
+            elif self.openai_enabled:
+                # Fallback to OpenAI TTS
+                self.voice_enabled = True
+                self.tts_mode = 'openai'
+        
+        except Exception as e:
+            st.info(f"Speech initialization error: {e}")
+            self.voice_enabled = False
+            self.tts_mode = None
 
     def speak_with_openai(self, text: str):
-        """Generate speech using OpenAI's TTS"""
+        """Generate speech using OpenAI's TTS with error handling"""
+        if not self.openai_enabled:
+            st.warning("OpenAI TTS not available.")
+            return
+
         try:
-            # Generate speech using OpenAI
             response = self.openai_client.audio.speech.create(
                 model="tts-1",
-                voice="alloy",  # or "nova", "shimmer", "echo", "fable"
+                voice="alloy",
                 input=text
             )
 
-            # Create a temporary file to store the audio
             with tempfile.NamedTemporaryFile(delete=False, suffix='.mp3') as tmp_file:
                 response.stream_to_file(tmp_file.name)
                 
-                # Create audio player in Streamlit
                 audio_file = open(tmp_file.name, 'rb')
                 audio_bytes = audio_file.read()
                 st.audio(audio_bytes, format='audio/mp3')
                 
-                # Clean up
                 audio_file.close()
                 os.unlink(tmp_file.name)
 
         except Exception as e:
-            st.error(f"Error during OpenAI speech synthesis: {e}")
+            st.error(f"OpenAI speech synthesis error: {e}")
 
     def speak(self, text: str):
-        """Make the AI tutor speak using available TTS method"""
+        """Speak text using available TTS method"""
         if not self.voice_enabled:
+            st.info("Voice output is currently disabled.")
             return
 
-        if self.tts_mode == 'local':
-            try:
-                import threading
+        try:
+            if self.tts_mode == 'local':
                 def speak_text():
                     st.session_state.tts_engine.say(text)
                     st.session_state.tts_engine.runAndWait()
 
                 thread = threading.Thread(target=speak_text)
                 thread.start()
-            except Exception as e:
-                st.error(f"Error during local speech synthesis: {e}")
-                if self.openai_enabled:
-                    st.info("Falling back to OpenAI TTS...")
-                    self.speak_with_openai(text)
+            
+            elif self.tts_mode == 'openai':
+                self.speak_with_openai(text)
         
-        elif self.tts_mode == 'openai':
-            self.speak_with_openai(text)
+        except Exception as e:
+            st.error(f"Speech error: {e}")
 
     def display_chat_interface(self):
-        """Display the enhanced chat interface with avatar"""
+        """Display enhanced chat interface with robust error handling"""
+        if self.fallback_mode:
+            st.warning("Running in text-only mode due to initialization errors.")
+            self._text_only_chat_interface()
+            return
+
         st.header("AI Tutor")
 
-        # Voice controls with TTS mode indicator
+        # Voice and TTS configuration
         col1, col2 = st.columns([3, 2])
         with col1:
-            if self.voice_enabled:
-                voice_active = st.toggle("Enable Voice", value=False, key="voice_active")
-            else:
-                voice_active = False
+            voice_active = st.toggle("Enable Voice", value=False, key="voice_active") if self.voice_enabled else False
         with col2:
             if self.tts_mode:
                 st.info(f"Using {self.tts_mode.upper()} TTS")
 
-        # Display avatar
+        # Avatar and topic selection
         self.service.display_avatar(state='neutral')
 
-        # Topic selection
         topics = [None, 'Physics', 'Mathematics', 'Computer Science', 'Artificial Intelligence']
         selected_topic = st.selectbox(
             "Select Topic",
@@ -148,17 +255,17 @@ class AITutor:
             key="topic_selector"
         )
 
-        context = get_tutor_context()
-        if selected_topic != context['current_topic']:
-            context['current_topic'] = selected_topic
-
-        # Display chat container
+        # Retrieve or initialize conversation context
+        if 'chat_history' not in st.session_state:
+            st.session_state.chat_history = []
+        
         chat_container = st.container()
         with chat_container:
-            # Display chat history with avatar states
-            for message in context['chat_history']:
+            # Display chat history
+            for message in st.session_state.chat_history:
                 with st.chat_message(message["role"]):
-                    st.write(message["content"])
+                    st.markdown(f"**{message['role'].capitalize()}:** {message['content']}")
+                    
                     if message["role"] == "assistant":
                         self.service.display_avatar(state='happy')
                         if voice_active and message.get('speak', True):
@@ -167,25 +274,38 @@ class AITutor:
 
         # Chat input
         if prompt := st.chat_input("Ask your question..."):
+            self.handle_user_input(prompt, selected_topic)
+
+    def _text_only_chat_interface(self):
+        """Fallback text-only chat interface"""
+        st.header("AI Tutor (Text Mode)")
+        st.write("Some features are currently unavailable.")
+
+        if 'chat_history' not in st.session_state:
+            st.session_state.chat_history = []
+
+        for message in st.session_state.chat_history:
+            st.write(f"{message['role'].capitalize()}: {message['content']}")
+
+        if prompt := st.text_input("Enter your message:"):
             self.handle_user_input(prompt)
 
-    def handle_user_input(self, user_input: str):
+    def handle_user_input(self, user_input: str, topic=None):
         """Process user input and generate response"""
         # Show thinking avatar
         self.service.display_avatar(state='thinking')
         
-        # Add user message
-        context = get_tutor_context()
-        context['chat_history'].append({
+        # Manage chat history
+        st.session_state.chat_history.append({
             "role": "user",
             "content": user_input
         })
         
         # Generate and display AI response
-        response = self.service.generate_response(user_input)
+        response = self.service.generate_response(user_input, topic)
         
         # Add AI response
-        context['chat_history'].append({
+        st.session_state.chat_history.append({
             "role": "assistant",
             "content": response,
             "speak": True
@@ -193,31 +313,14 @@ class AITutor:
         
         # Show happy avatar and rerun
         self.service.display_avatar(state='happy')
-        st.rerun()
+        st.experimental_rerun()
 
-    def display_learning_metrics(self):
-        """Display learning progress and engagement metrics"""
-        with st.sidebar:
-            st.subheader("Learning Metrics")
-            
-            context = get_tutor_context()
-            # Engagement score
-            metrics = context['engagement_metrics']
-            if metrics:
-                avg_sentiment = sum(m['sentiment_score'] for m in metrics) / len(metrics)
-                st.metric(
-                    "Engagement Score",
-                    f"{avg_sentiment:.2f}",
-                    delta="0.1" if avg_sentiment > 0.5 else "-0.1"
-                )
-            
-            # Interaction stats
-            if context['chat_history']:
-                st.metric(
-                    "Questions Asked",
-                    len([m for m in context['chat_history'] if m['role'] == 'user'])
-                )
-            
-            # Topic focus
-            if context['current_topic']:
-                st.info(f"Current focus: {context['current_topic']}")
+def main():
+    """Main Streamlit application entry point"""
+    st.set_page_config(page_title="AI Tutor", page_icon="🤖")
+    
+    tutor = AITutor()
+    tutor.display_chat_interface()
+
+if __name__ == "__main__":
+    main()