Update src/components/learning_paths.py

src/components/learning_paths.py

@@ -1,4 +1,4 @@
-import streamlit as st 
+import streamlit as st
 import json
 from datetime import datetime
 import os
@@ -6,17 +6,18 @@ from huggingface_hub import HfApi, Repository
 from pathlib import Path
 import tempfile
 import anthropic
+import time
 
 class LearningPaths:
     def __init__(self):
         self.initialize_storage()
         self.initialize_llm()
         self.load_curriculum()
+        self.content_generation_cache = {}
 
     def initialize_storage(self):
         """Initialize HuggingFace storage connection and create repository if needed"""
         try:
-            # Try to get token from Streamlit secrets first, then environment variables
             self.hf_token = st.secrets.get("HF_TOKEN") or os.getenv('HF_TOKEN')
             if not self.hf_token:
                 st.error("HF_TOKEN not found in secrets or environment variables. Using local storage instead.")
@@ -24,25 +25,22 @@ class LearningPaths:
                 return
 
             self.api = HfApi(token=self.hf_token)
-            # Try to get repo_id from secrets first, then environment variables, then default
-            self.repo_id = (st.secrets.get("HF_REPO_ID") or 
-                          os.getenv('HF_REPO_ID') or 
+            self.repo_id = (st.secrets.get("HF_REPO_ID") or
+                          os.getenv('HF_REPO_ID') or
                           f'{self.api.whoami()["name"]}/eduai-content')
-            
-            # Check if repository exists
+
             try:
                 self.api.repo_info(repo_id=self.repo_id, repo_type="dataset")
             except Exception:
-                # Repository doesn't exist, create it
                 st.info(f"Creating new HuggingFace dataset repository: {self.repo_id}")
                 self.api.create_repo(
                     repo_id=self.repo_id,
                     repo_type="dataset",
                     private=True
                 )
-            
+
             self.use_local_storage = False
-            
+
         except Exception as e:
             st.error(f"Error initializing HuggingFace storage: {e}")
             st.info("Falling back to local storage")
@@ -51,76 +49,20 @@ class LearningPaths:
     def initialize_llm(self):
         """Initialize Anthropic/Claude client"""
         try:
-            # Try to get API key from secrets first, then environment variables
             api_key = st.secrets.get("ANTHROPIC_API_KEY") or os.getenv('ANTHROPIC_API_KEY')
             if not api_key:
                 st.error("ANTHROPIC_API_KEY not found in secrets or environment variables")
                 return
-                
+
             self.client = anthropic.Anthropic(api_key=api_key)
         except Exception as e:
             st.error(f"Error initializing LLM: {e}")
 
-    def load_curriculum(self):
-        """Load or initialize curriculum structure"""
-        # Try loading from HuggingFace
-        curriculum = self.load_from_storage("curriculum.json")
-        if curriculum:
-            self.curriculum = curriculum
-            return
+    def generate_module_content_async(self, module_id: str):
+        """Asynchronous content generation with caching"""
+        if module_id in self.content_generation_cache:
+            return self.content_generation_cache[module_id]
 
-        # Initialize default curriculum
-        self.curriculum = {
-            'python_basics': {
-                'name': 'Python Programming Basics',
-                'description': 'Master the fundamental concepts of Python programming.',
-                'prerequisites': [],
-                'modules': [
-                    {
-                        'id': 'intro_python',
-                        'name': 'Introduction to Python',
-                        'concepts': ['programming_basics', 'python_environment', 'basic_syntax'],
-                        'difficulty': 'beginner',
-                        'estimated_hours': 2
-                    },
-                    {
-                        'id': 'variables_types',
-                        'name': 'Variables and Data Types',
-                        'concepts': ['variables', 'numbers', 'strings', 'type_conversion'],
-                        'difficulty': 'beginner',
-                        'estimated_hours': 3
-                    }
-                ]
-            },
-            'data_structures': {
-                'name': 'Data Structures',
-                'description': 'Learn essential Python data structures and their operations.',
-                'prerequisites': ['python_basics'],
-                'modules': [
-                    {
-                        'id': 'lists_tuples',
-                        'name': 'Lists and Tuples',
-                        'concepts': ['list_operations', 'tuple_basics', 'sequence_types'],
-                        'difficulty': 'intermediate',
-                        'estimated_hours': 4
-                    },
-                    {
-                        'id': 'dictionaries',
-                        'name': 'Dictionaries',
-                        'concepts': ['dict_operations', 'key_value_pairs', 'dict_methods'],
-                        'difficulty': 'intermediate',
-                        'estimated_hours': 3
-                    }
-                ]
-            }
-        }
-
-        # Save initial curriculum
-        self.save_to_storage(self.curriculum, "curriculum.json")
-
-    def generate_module_content(self, module_id: str) -> dict:
-        """Generate content for a module using Claude"""
-        # Find module details
         module = None
         for path in self.curriculum.values():
             for m in path['modules']:
@@ -133,8 +75,10 @@ class LearningPaths:
         if not module:
             return None
 
+        placeholder = st.empty()
+        placeholder.info("🔄 Generating learning content...")
+
         try:
-            # Generate content using Claude
             message = self.client.messages.create(
                 model="claude-3-opus-20240229",
                 max_tokens=1024,
@@ -171,100 +115,35 @@ class LearningPaths:
             )
 
             content = json.loads(message.content[0].text)
-            
-            # Save generated content
             content_path = f"content/{module_id}.json"
             self.save_to_storage(content, content_path)
 
+            placeholder.empty()
+            self.content_generation_cache[module_id] = content
             return content
 
         except Exception as e:
-            st.error(f"Error generating content: {e}")
+            placeholder.error(f"Error generating content: {e}")
             return None
 
     def get_module_content(self, module_id: str) -> dict:
         """Get or generate module content"""
-        # Try loading existing content
+        if module_id in self.content_generation_cache:
+            return self.content_generation_cache[module_id]
+
         content_path = f"content/{module_id}.json"
         content = self.load_from_storage(content_path)
-        
-        if not content:
-            # Generate if doesn't exist
-            content = self.generate_module_content(module_id)
-            
-        return content
-
-    def save_to_storage(self, content: dict, path: str):
-        """Save content to storage (HuggingFace or local)"""
-        if self.use_local_storage:
-            return self.save_locally(content, path)
-            
-        try:
-            with tempfile.NamedTemporaryFile(mode='w', delete=False) as tmp:
-                json.dump(content, tmp, indent=2)
-                tmp.flush()
-                self.api.upload_file(
-                    path_or_fileobj=tmp.name,
-                    path_in_repo=path,
-                    repo_id=self.repo_id,
-                    repo_type="dataset"
-                )
-        except Exception as e:
-            st.error(f"Error saving to HuggingFace: {e}")
-            # Fallback to local storage
-            return self.save_locally(content, path)
 
-    def load_from_storage(self, path: str) -> dict:
-        """Load content from storage (HuggingFace or local)"""
-        if self.use_local_storage:
-            return self.load_locally(path)
-            
-        try:
-            content = self.api.download_file(
-                repo_id=self.repo_id,
-                filename=path,
-                repo_type="dataset"
-            )
-            return json.loads(content)
-        except Exception:
-            # Try loading from local storage as fallback
-            return self.load_locally(path)
-
-    def save_locally(self, content: dict, path: str):
-        """Save content to local storage"""
-        try:
-            # Create data directory if it doesn't exist
-            local_dir = Path("data")
-            local_dir.mkdir(exist_ok=True)
-            
-            # Create subdirectories if needed
-            file_path = local_dir / path
-            file_path.parent.mkdir(parents=True, exist_ok=True)
-            
-            # Save the content
-            with open(file_path, 'w') as f:
-                json.dump(content, f, indent=2)
-                
-        except Exception as e:
-            st.error(f"Error saving locally: {e}")
-
-    def load_locally(self, path: str) -> dict:
-        """Load content from local storage"""
-        try:
-            file_path = Path("data") / path
-            if not file_path.exists():
-                return None
-                
-            with open(file_path, 'r') as f:
-                return json.load(f)
-        except Exception:
+        if not content:
             return None
 
+        self.content_generation_cache[module_id] = content
+        return content
+
     def display(self):
         """Display learning paths interface"""
         st.header("Learning Paths")
-        
-        # Topic selection
+
         selected_path = st.selectbox(
             "Select Learning Path",
             options=list(self.curriculum.keys()),
@@ -277,59 +156,54 @@ class LearningPaths:
     def display_path_content(self, path_id: str):
         """Display content for selected path"""
         path = self.curriculum[path_id]
-        
-        # Path header
+
         st.subheader(path['name'])
         st.write(path['description'])
-        
-        # Check prerequisites
+
         if path['prerequisites']:
             prereqs_met = self.check_prerequisites(path['prerequisites'])
             if not prereqs_met:
-                st.warning("⚠️ Please complete the prerequisite paths first: " + 
+                st.warning("⚠️ Please complete the prerequisite paths first: " +
                          ", ".join([self.curriculum[p]['name'] for p in path['prerequisites']]))
                 return
 
-        # Progress overview
         progress = self.get_path_progress(path_id)
         st.progress(progress, f"Progress: {int(progress * 100)}%")
 
-        # Display modules
         for module in path['modules']:
             with st.expander(f"📚 {module['name']} ({module['difficulty']})"):
                 completed = self.is_module_complete(module['id'])
-                
+
                 if completed:
                     st.success("✅ Module completed!")
-                
-                # Get or generate content
+
+                if st.button(f"Generate Content for {module['name']}", key=f"generate_{module['id']}"):
+                    content = self.generate_module_content_async(module['id'])
+                    st.experimental_rerun()
+
                 content = self.get_module_content(module['id'])
                 if content:
-                    # Display introduction
                     st.write(content['introduction'])
-                    
-                    # Display sections
+
                     for section in content['sections']:
                         st.markdown(f"### {section['title']}")
                         st.write(section['content'])
                         if 'examples' in section:
                             for example in section['examples']:
                                 st.code(example)
-                    
-                    # Display exercises
+
                     st.markdown("### Practice Exercises")
                     for exercise in content['exercises']:
                         with st.expander(exercise['title']):
                             st.write(exercise['description'])
                             if st.button("Show Solution", key=f"sol_{module['id']}_{exercise['title']}"):
                                 st.code(exercise['solution'])
-                    
-                    # Display quiz
+
                     if not completed:
                         st.markdown("### Quiz")
                         correct_answers = 0
                         total_questions = len(content['quiz']['questions'])
-                        
+
                         for i, q in enumerate(content['quiz']['questions']):
                             st.write(f"\n**Question {i+1}:** {q['question']}")
                             answer = st.radio(
@@ -339,7 +213,7 @@ class LearningPaths:
                             )
                             if answer == q['options'][q['correct']]:
                                 correct_answers += 1
-                        
+
                         if st.button("Submit Quiz", key=f"submit_{module['id']}"):
                             score = correct_answers / total_questions
                             if score >= 0.8:
@@ -348,13 +222,127 @@ class LearningPaths:
                             else:
                                 st.warning(f"Score: {score*100:.0f}%. You need 80% to complete the module.")
                 else:
-                    st.error("Error loading module content")
+                    st.info("Content not generated. Click 'Generate Content' to create learning materials.")
+
+    def load_curriculum(self):
+        """Load or initialize curriculum structure"""
+        curriculum = self.load_from_storage("curriculum.json")
+        if curriculum:
+            self.curriculum = curriculum
+            return
+
+        self.curriculum = {
+            'python_basics': {
+                'name': 'Python Programming Basics',
+                'description': 'Master the fundamental concepts of Python programming.',
+                'prerequisites': [],
+                'modules': [
+                    {
+                        'id': 'intro_python',
+                        'name': 'Introduction to Python',
+                        'concepts': ['programming_basics', 'python_environment', 'basic_syntax'],
+                        'difficulty': 'beginner',
+                        'estimated_hours': 2
+                    },
+                    {
+                        'id': 'variables_types',
+                        'name': 'Variables and Data Types',
+                        'concepts': ['variables', 'numbers', 'strings', 'type_conversion'],
+                        'difficulty': 'beginner',
+                        'estimated_hours': 3
+                    }
+                ]
+            },
+            'data_structures': {
+                'name': 'Data Structures',
+                'description': 'Learn essential Python data structures and their operations.',
+                'prerequisites': ['python_basics'],
+                'modules': [
+                    {
+                        'id': 'lists_tuples',
+                        'name': 'Lists and Tuples',
+                        'concepts': ['list_operations', 'tuple_basics', 'sequence_types'],
+                        'difficulty': 'intermediate',
+                        'estimated_hours': 4
+                    },
+                    {
+                        'id': 'dictionaries',
+                        'name': 'Dictionaries',
+                        'concepts': ['dict_operations', 'key_value_pairs', 'dict_methods'],
+                        'difficulty': 'intermediate',
+                        'estimated_hours': 3
+                    }
+                ]
+            }
+        }
+
+        self.save_to_storage(self.curriculum, "curriculum.json")
+
+    def save_to_storage(self, content: dict, path: str):
+        """Save content to storage (HuggingFace or local)"""
+        if self.use_local_storage:
+            return self.save_locally(content, path)
+
+        try:
+            with tempfile.NamedTemporaryFile(mode='w', delete=False) as tmp:
+                json.dump(content, tmp, indent=2)
+                tmp.flush()
+                self.api.upload_file(
+                    path_or_fileobj=tmp.name,
+                    path_in_repo=path,
+                    repo_id=self.repo_id,
+                    repo_type="dataset"
+                )
+        except Exception as e:
+            st.error(f"Error saving to HuggingFace: {e}")
+            return self.save_locally(content, path)
+
+    def load_from_storage(self, path: str) -> dict:
+        """Load content from storage (HuggingFace or local)"""
+        if self.use_local_storage:
+            return self.load_locally(path)
+
+        try:
+            content = self.api.download_file(
+                repo_id=self.repo_id,
+                filename=path,
+                repo_type="dataset"
+            )
+            return json.loads(content)
+        except Exception:
+            return self.load_locally(path)
+
+    def save_locally(self, content: dict, path: str):
+        """Save content to local storage"""
+        try:
+            local_dir = Path("data")
+            local_dir.mkdir(exist_ok=True)
+
+            file_path = local_dir / path
+            file_path.parent.mkdir(parents=True, exist_ok=True)
+
+            with open(file_path, 'w') as f:
+                json.dump(content, f, indent=2)
+        except Exception as e:
+            st.error(f"Error saving locally: {e}")
+
+    def load_locally(self, path: str) -> dict:
+        """Load content from local storage"""
+        try:
+            file_path = Path("data") / path
+            if not file_path.exists():
+                return None
+
+            with open(file_path, 'r') as f:
+                return json.load(f)
+        except Exception:
+            return None
 
     def check_prerequisites(self, prerequisites: list) -> bool:
         """Check if prerequisites are met"""
         if 'completed_modules' not in st.session_state:
             st.session_state.completed_modules = []
-        
+
         for prereq in prerequisites:
             prereq_modules = {m['id'] for m in self.curriculum[prereq]['modules']}
             if not prereq_modules.issubset(set(st.session_state.completed_modules)):
@@ -365,7 +353,7 @@ class LearningPaths:
         """Calculate progress percentage for a path"""
         if 'completed_modules' not in st.session_state:
             st.session_state.completed_modules = []
-            
+
         path_modules = {m['id'] for m in self.curriculum[path_id]['modules']}
         completed = path_modules.intersection(set(st.session_state.completed_modules))
         return len(completed) / len(path_modules)
@@ -374,25 +362,23 @@ class LearningPaths:
         """Check if a module is completed"""
         if 'completed_modules' not in st.session_state:
             st.session_state.completed_modules = []
-            
+
         return module_id in st.session_state.completed_modules
 
     def complete_module(self, module_id: str, path_id: str):
         """Mark a module as complete and update progress"""
         if 'completed_modules' not in st.session_state:
             st.session_state.completed_modules = []
-            
+
         if module_id not in st.session_state.completed_modules:
             st.session_state.completed_modules.append(module_id)
-            
-        # Save progress
-        if 'username' in st.session_state:
-            progress = {
-                'completed_modules': st.session_state.completed_modules,
-                'last_active': datetime.now().isoformat()
-            }
-            progress_path = f"progress/{st.session_state.username}.json"
-            self.save_to_storage(progress, progress_path)
+
+        progress = {
+            'completed_modules': st.session_state.completed_modules,
+            'last_active': datetime.now().isoformat()
+        }
+        progress_path = f"progress/{st.session_state.username}.json"
+        self.save_to_storage(progress, progress_path)
 
     def load_user_progress(self, username: str):
         """Load user progress from storage"""