Update src/components/learning_paths.py

src/components/learning_paths.py

@@ -1,89 +1,333 @@
+import streamlit as st 
+import json
 from datetime import datetime
-from typing import Dict, List, Optional
-import streamlit as st
-from src.services.learning_service import LearningService
-from src.utils.session import get_user_progress
+import os
+from huggingface_hub import HfApi, Repository
+from pathlib import Path
+import tempfile
+import anthropic
 
 class LearningPaths:
     def __init__(self):
-        self.service = LearningService()
+        self.initialize_storage()
+        self.initialize_llm()
+        self.load_curriculum()
 
-    @staticmethod
-    def display():
-        paths = LearningPaths()
-        paths.display_interface()
+    def initialize_storage(self):
+        """Initialize HuggingFace storage connection"""
+        try:
+            self.hf_token = os.getenv('HF_TOKEN')
+            self.repo_id = os.getenv('HF_REPO_ID', 'default-eduai-content')
+            self.api = HfApi(token=self.hf_token)
+        except Exception as e:
+            st.error(f"Error initializing storage: {e}")
 
-    def display_interface(self):
-        """Display the learning paths interface"""
+    def initialize_llm(self):
+        """Initialize Anthropic/Claude client"""
+        try:
+            self.client = anthropic.Anthropic(
+                api_key=os.getenv('ANTHROPIC_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
+
+        # 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']:
+                if m['id'] == module_id:
+                    module = m
+                    break
+            if module:
+                break
+
+        if not module:
+            return None
+
+        try:
+            # Generate content using Claude
+            message = self.client.messages.create(
+                model="claude-3-opus-20240229",
+                max_tokens=1024,
+                temperature=0.7,
+                system="You are an expert curriculum designer and educator. Create detailed, engaging learning content with clear examples and practice exercises.",
+                messages=[{
+                    "role": "user",
+                    "content": f"""Create comprehensive learning content for: {module['name']}
+                    
+                    Include:
+                    1. A clear introduction
+                    2. Key concepts: {', '.join(module['concepts'])}
+                    3. Detailed explanations with examples
+                    4. Practice exercises
+                    5. A 5-question multiple choice quiz
+                    
+                    Target difficulty level: {module['difficulty']}
+                    Format the response as JSON with the following structure:
+                    {{
+                        "introduction": "text",
+                        "sections": [
+                            {{"title": "string", "content": "text", "examples": []}}
+                        ],
+                        "exercises": [
+                            {{"title": "string", "description": "text", "solution": "text"}}
+                        ],
+                        "quiz": {{
+                            "questions": [
+                                {{"question": "text", "options": ["A", "B", "C", "D"], "correct": 0}}
+                            ]
+                        }}
+                    }}"""
+                }]
+            )
+
+            content = json.loads(message.content[0].text)
+            
+            # Save generated content
+            content_path = f"content/{module_id}.json"
+            self.save_to_storage(content, content_path)
+
+            return content
+
+        except Exception as e:
+            st.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
+        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 HuggingFace"""
+        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 storage: {e}")
+
+    def load_from_storage(self, path: str) -> dict:
+        """Load content from HuggingFace"""
+        try:
+            content = self.api.download_file(
+                repo_id=self.repo_id,
+                filename=path,
+                repo_type="dataset"
+            )
+            return json.loads(content)
+        except Exception:
+            return None
+
+    def display(self):
+        """Display learning paths interface"""
         st.header("Learning Paths")
         
-        # Path selection
+        # Topic selection
         selected_path = st.selectbox(
             "Select Learning Path",
-            options=list(self.service.curriculum.keys()),
-            format_func=lambda x: self.service.curriculum[x]['name'],
-            key="path_selector"
+            options=list(self.curriculum.keys()),
+            format_func=lambda x: self.curriculum[x]['name']
         )
 
-        # Display selected path details
         if selected_path:
-            self.display_path_details(selected_path)
+            self.display_path_content(selected_path)
 
-    def display_path_details(self, path_id: str):
-        """Display detailed view of a learning path"""
-        path = self.service.curriculum[path_id]
+    def display_path_content(self, path_id: str):
+        """Display content for selected path"""
+        path = self.curriculum[path_id]
         
-        # Path header and description
+        # Path header
         st.subheader(path['name'])
         st.write(path['description'])
         
-        # Prerequisites check
+        # Check prerequisites
         if path['prerequisites']:
-            prereq_met = self.service.check_prerequisites(path['prerequisites'])
-            if not prereq_met:
+            prereqs_met = self.check_prerequisites(path['prerequisites'])
+            if not prereqs_met:
                 st.warning("⚠️ Please complete the prerequisite paths first: " + 
-                         ", ".join([self.service.curriculum[p]['name'] for p in path['prerequisites']]))
+                         ", ".join([self.curriculum[p]['name'] for p in path['prerequisites']]))
                 return
 
         # Progress overview
-        total_modules = len(path['modules'])
-        progress = self.service.get_path_progress(path_id)
-        st.progress(progress, 
-                   f"Progress: {int(progress * total_modules)}/{total_modules} modules completed")
+        progress = self.get_path_progress(path_id)
+        st.progress(progress, f"Progress: {int(progress * 100)}%")
 
         # Display modules
         for module in path['modules']:
-            self.display_module(module, path_id)
+            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
+                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(
+                                "Select your answer:",
+                                q['options'],
+                                key=f"quiz_{module['id']}_{i}"
+                            )
+                            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:
+                                st.success(f"🎉 Congratulations! Score: {score*100:.0f}%")
+                                self.complete_module(module['id'], path_id)
+                            else:
+                                st.warning(f"Score: {score*100:.0f}%. You need 80% to complete the module.")
+                else:
+                    st.error("Error loading module content")
 
-    def display_module(self, module: Dict, path_id: str):
-        """Display individual module with its details and status"""
-        completed = self.service.is_module_completed(module['id'])
+    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 = []
         
-        with st.expander(
-            f"{'✅' if completed else '📝'} {module['name']} "
-            f"({module['difficulty']} • {module['estimated_hours']}h)",
-            expanded=not completed
-        ):
-            # Module description and concepts
-            st.write("**Key Concepts:**")
-            for concept in module['concepts']:
-                mastery = self.service.get_concept_mastery(concept)
-                st.write(f"- {concept.replace('_', ' ').title()}: {self.service.format_mastery(mastery)}")
-
-            # Module actions
-            cols = st.columns([1, 1, 1])
+        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)):
+                return False
+        return True
+
+    def get_path_progress(self, path_id: str) -> float:
+        """Calculate progress percentage for a path"""
+        if 'completed_modules' not in st.session_state:
+            st.session_state.completed_modules = []
             
-            with cols[0]:
-                if st.button("Start Learning", key=f"start_{module['id']}", disabled=completed):
-                    self.service.start_module(module['id'], path_id)
-                    st.rerun()
+        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)
+
+    def is_module_complete(self, module_id: str) -> bool:
+        """Check if a module is completed"""
+        if 'completed_modules' not in st.session_state:
+            st.session_state.completed_modules = []
             
-            with cols[1]:
-                if st.button("Take Quiz", key=f"quiz_{module['id']}"):
-                    self.service.launch_quiz(module['id'])
-                    st.rerun()
+        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 = []
             
-            with cols[2]:
-                if st.button("Mark Complete", key=f"complete_{module['id']}", disabled=completed):
-                    self.service.complete_module(module['id'], path_id)
-                    st.rerun()
+        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)
+
+    def load_user_progress(self, username: str):
+        """Load user progress from storage"""
+        progress_path = f"progress/{username}.json"
+        progress = self.load_from_storage(progress_path)
+        if progress:
+            st.session_state.completed_modules = progress.get('completed_modules', [])