Upload 5 files

.env

@@ -0,0 +1 @@
+OPENAI_API_KEY=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

app.py

@@ -0,0 +1,949 @@
+import pandas as pd
+import numpy as np
+import json
+from typing import Dict, List, Optional, Union, Any
+import os
+import requests
+from dotenv import load_dotenv
+from rich.console import Console
+from rich.table import Table
+from rich.panel import Panel
+from rich.tree import Tree
+from rich import box
+import time
+from tqdm import tqdm
+import openai
+import gradio as gr
+from huggingface_hub import HfApi, HfFolder
+
+# Load environment variables from .env file
+load_dotenv()
+
+class BaseRecommender:
+    def __init__(self):
+        self.console = Console()
+        
+        # Initialize OpenAI client
+        api_key = os.getenv("OPENAI_API_KEY")
+        self.ai_enabled = bool(api_key)
+        if self.ai_enabled:
+            self.openai_client = openai.OpenAI(api_key=api_key)
+        else:
+            self.console.print("[yellow]Warning: OpenAI API key not found. AI-enhanced features will be disabled.[/yellow]")
+
+class CourseRecommender(BaseRecommender):
+    def __init__(self, dataframe: pd.DataFrame):
+        """
+        Initialize the course recommender with course data
+        """
+        super().__init__()
+        self.courses = dataframe.drop(columns=['Unnamed: 1', 'Unnamed: 5'], errors='ignore')
+        self._preprocess_data()
+
+    def _preprocess_data(self):
+        """
+        Preprocess the course data for better recommendations
+        """
+        # Convert text columns to lowercase
+        text_columns = ['Course Name', 'Description', 'Skills', 'Difficulty Level']
+        for col in text_columns:
+            if col in self.courses.columns:
+                self.courses[col] = self.courses[col].astype(str).str.lower()
+
+        # Handle numeric values
+        self.courses['Course Rating'] = pd.to_numeric(self.courses['Course Rating'], errors='coerce').fillna(0)
+        self.courses['keyword_match_score'] = 0
+
+        # Add course ID for easy reference
+        self.courses['Course ID'] = range(1, len(self.courses) + 1)
+
+    def recommend_courses(self, topic: Optional[str] = None, skill_level: Optional[str] = None,
+                          top_n: int = 5, personalized: bool = False, user_goals: Optional[str] = None) -> pd.DataFrame:
+        """
+        Recommend courses based on topic, skill level, and optional user goals
+        """
+        filtered_courses = self.courses.copy()
+
+        # Show processing indicator
+        with self.console.status("[bold green]Finding the best courses for you...", spinner="dots"):
+            time.sleep(1)  # Simulate processing time
+
+            # Filter by topic if provided
+            if topic:
+                topic = topic.lower()
+                # Calculate keyword match score
+                filtered_courses['keyword_match_score'] = (
+                    filtered_courses['Course Name'].str.contains(topic).astype(int) * 3 +
+                    filtered_courses['Description'].str.contains(topic).astype(int) * 2 +
+                    filtered_courses['Skills'].str.contains(topic).astype(int)
+                )
+                filtered_courses = filtered_courses[filtered_courses['keyword_match_score'] > 0]
+
+            # Filter by skill level if provided
+            if skill_level:
+                skill_level = skill_level.lower()
+                difficulty_map = {
+                    'beginner': ['beginner', 'intro', 'basic', 'level 1', 'fundamentals'],
+                    'intermediate': ['intermediate', 'mid-level', 'level 2', 'advanced beginner'],
+                    'advanced': ['advanced', 'expert', 'professional', 'level 3', 'master']
+                }
+                filtered_courses = filtered_courses[
+                    filtered_courses['Difficulty Level'].apply(
+                        lambda x: any(diff in str(x) for diff in difficulty_map.get(skill_level, [skill_level]))
+                    )
+                ]
+
+            # Add AI relevance scoring if enabled
+            filtered_courses['ai_relevance_score'] = 0
+            if personalized and user_goals and self.ai_enabled:
+                for idx, course in filtered_courses.iterrows():
+                    relevance_score = self._get_ai_relevance_score(course, topic, user_goals)
+                    filtered_courses.at[idx, 'ai_relevance_score'] = relevance_score
+
+            # Calculate final recommendation score
+            if not filtered_courses.empty:
+                filtered_courses['recommendation_score'] = (
+                    filtered_courses['Course Rating'] * 0.4 +
+                    filtered_courses['keyword_match_score'] * 0.3 +
+                    filtered_courses['ai_relevance_score'] * 0.2 +
+                    np.random.rand(len(filtered_courses)) * 0.1
+                )
+                filtered_courses = filtered_courses.sort_values('recommendation_score', ascending=False)
+
+        return filtered_courses.head(top_n)
+
+    def _get_ai_relevance_score(self, course: pd.Series, topic: str, user_goals: str) -> float:
+        """
+        Use AI to determine how relevant a course is to user's specific goals
+        """
+        if not self.ai_enabled:
+            return 0.5
+            
+        try:
+            prompt = f"""
+            Rate how relevant this course is to a learner with these goals on a scale of 0-10:
+
+            Topic of interest: {topic}
+            User's learning goals: {user_goals}
+
+            Course details:
+            - Name: {course['Course Name']}
+            - Description: {course['Description']}
+            - Skills taught: {course['Skills']}
+            - Difficulty: {course['Difficulty Level']}
+
+            Return only a number from 0-10.
+            """
+
+            response = self.openai_client.chat.completions.create(
+                model="gpt-3.5-turbo",
+                messages=[
+                    {"role": "system", "content": "You are an educational advisor helping match courses to learner goals."},
+                    {"role": "user", "content": prompt}
+                ],
+                max_tokens=10,
+                temperature=0.3
+            )
+
+            try:
+                score = float(response.choices[0].message.content.strip())
+                return min(max(score, 0), 10) / 10  # Normalize to 0-1 range
+            except ValueError:
+                return 0.5  # Default value if parsing fails
+
+        except Exception as e:
+            self.console.print(f"[red]Error getting AI relevance score: {e}[/red]")
+            return 0.5
+
+    def generate_roadmap(self, topic: str, skill_level: Optional[str] = None,
+                         user_goals: Optional[str] = None, detailed: bool = False) -> Dict:
+        """
+        Generate a personalized learning roadmap based on the topic and user goals
+        """
+        self.console.print(Panel(f"[bold cyan]Generating your personalized learning roadmap for [green]{topic}[/green]...[/bold cyan]"))
+
+        # Display a progress bar for visual effect
+        for _ in tqdm(range(5), desc="Processing roadmap data"):
+            time.sleep(0.3)
+
+        # Generate roadmap using AI if enabled and requested, otherwise use default
+        if detailed and self.ai_enabled and user_goals:
+            return self._generate_ai_roadmap(topic, skill_level, user_goals)
+        else:
+            return self._generate_default_roadmap(topic)
+
+    def _generate_ai_roadmap(self, topic: str, skill_level: str, user_goals: str) -> Dict:
+        """
+        Use AI to generate a personalized and detailed learning roadmap
+        """
+        try:
+            # Enhanced prompt with specific structure and guidance
+            prompt = f"""
+            Create a comprehensive learning roadmap for someone wanting to master {topic}.
+
+            Learner information:
+            - Current skill level: {skill_level}
+            - Learning goals: {user_goals}
+
+            The roadmap should be detailed, actionable, and specifically tailored to the learner's
+            skill level and goals. Provide a clear progression path that breaks down the journey 
+            into logical stages with specific concepts to learn at each stage.
+
+            Format the response as a JSON object with exactly this structure:
+            {{
+                "learningPath": [
+                    {{
+                        "step": "Step name (be specific)",
+                        "difficulty": "Beginner/Intermediate/Advanced",
+                        "description": "Detailed description of this learning stage (2-3 sentences)",
+                        "time_estimate": "Estimated completion time (weeks/months)",
+                        "key_concepts": ["Specific concept 1", "Specific concept 2", "Specific concept 3"],
+                        "milestones": ["Practical milestone 1", "Practical milestone 2"],
+                        "practice_activities": ["Activity 1", "Activity 2"]
+                    }},
+                    // 3-5 steps total, progressing from fundamentals to mastery
+                ],
+                "projectSuggestions": [
+                    {{
+                        "name": "Project name (be specific to {topic})",
+                        "description": "Detailed project description (2-3 sentences)",
+                        "complexity": "Low/Medium/High",
+                        "skills_practiced": ["Skill 1", "Skill 2", "Skill 3"],
+                        "resources": ["Specific resource 1", "Specific resource 2"],
+                        "estimated_time": "Project completion time estimate"
+                    }},
+                    // 3-4 projects of increasing complexity
+                ],
+                "resources": {{
+                    "books": ["Specific book title 1", "Specific book title 2", "Specific book title 3"],
+                    "online_courses": ["Specific course 1", "Specific course 2"],
+                    "communities": ["Specific community 1", "Specific community 2"],
+                    "tools": ["Specific tool 1", "Specific tool 2", "Specific tool 3"],
+                    "practice_platforms": ["Specific platform 1", "Specific platform 2"]
+                }},
+                "career_insights": [
+                    "Specific insight about {topic} career opportunities",
+                    "Skill demand information",
+                    "Industry application of {topic} skills"
+                ]
+            }}
+
+            Ensure all content is specific to {topic} (not generic) and appropriate for a {skill_level} 
+            with these goals: {user_goals}. Focus on practical, actionable advice.
+            """
+
+            response = self.openai_client.chat.completions.create(
+                model="gpt-4",
+                messages=[
+                    {"role": "system", "content": "You are an expert educational curriculum designer with deep knowledge across technical and non-technical subjects. You create detailed, actionable learning plans that are practical and tailored to individual needs."},
+                    {"role": "user", "content": prompt}
+                ],
+                max_tokens=2500,
+                temperature=0.5,
+                response_format={"type": "json_object"}  # Enforce JSON response
+            )
+
+            try:
+                roadmap_text = response.choices[0].message.content
+                return json.loads(roadmap_text)
+            except json.JSONDecodeError as e:
+                self.console.print(f"[yellow]Warning: Could not parse AI response as JSON: {e}. Using default roadmap.[/yellow]")
+                return self._generate_default_roadmap(topic)
+
+        except Exception as e:
+            self.console.print(f"[red]Error generating AI roadmap: {e}[/red]")
+            return self._generate_default_roadmap(topic)
+
+    def _generate_default_roadmap(self, topic: str) -> Dict:
+        """
+        Generate a default roadmap when AI generation fails or is not available
+        """
+        return {
+            "learningPath": [
+                {
+                    "step": f"Foundations of {topic}",
+                    "difficulty": "Beginner",
+                    "description": f"Build core knowledge and fundamental skills in {topic}. Focus on understanding basic principles and becoming familiar with essential tools.",
+                    "time_estimate": "4-6 weeks",
+                    "key_concepts": [f"{topic} basics", "Core principles", "Fundamental tools and techniques"],
+                    "milestones": [f"Complete first {topic} exercise", f"Build simple {topic} project"],
+                    "practice_activities": [f"Daily {topic} exercises", "Follow beginner tutorials"]
+                },
+                {
+                    "step": f"{topic} Skill Development",
+                    "difficulty": "Intermediate",
+                    "description": f"Deepen understanding of {topic} and apply more advanced concepts. Focus on building practical skills through hands-on projects and implementation.",
+                    "time_estimate": "8-12 weeks",
+                    "key_concepts": [f"Advanced {topic} techniques", "Applied projects", "Specialized tools"],
+                    "milestones": [f"Complete medium complexity {topic} project", "Solve real-world problems"],
+                    "practice_activities": ["Implement sample projects", "Participate in forums/discussions"]
+                },
+                {
+                    "step": f"{topic} Mastery & Specialization",
+                    "difficulty": "Advanced",
+                    "description": f"Develop expert-level skills in {topic} with focus on real-world application. Specialize in specific areas and build a professional portfolio.",
+                    "time_estimate": "12-16 weeks",
+                    "key_concepts": ["Industry best practices", "Complex problem-solving", "Portfolio development"],
+                    "milestones": ["Create capstone project", "Contribute to community"],
+                    "practice_activities": ["Build complex projects", "Mentor beginners"]
+                }
+            ],
+            "projectSuggestions": [
+                {
+                    "name": f"Beginner Project: {topic} Fundamentals Application",
+                    "description": f"Apply basic {topic} concepts in a simple project to practice fundamentals and gain confidence.",
+                    "complexity": "Low",
+                    "skills_practiced": [f"Basic {topic} principles", "Problem-solving", "Tool familiarity"],
+                    "resources": ["Online tutorials", "Documentation", "Starter templates"],
+                    "estimated_time": "1-2 weeks"
+                },
+                {
+                    "name": f"Intermediate Project: Interactive {topic} Application",
+                    "description": f"Create a more complex application using intermediate {topic} skills with greater functionality and sophistication.",
+                    "complexity": "Medium",
+                    "skills_practiced": [f"Intermediate {topic} techniques", "Code organization", "Testing"],
+                    "resources": ["GitHub repositories", "Online coding platforms", "Community forums"],
+                    "estimated_time": "3-4 weeks"
+                },
+                {
+                    "name": f"Capstone Project: Advanced {topic} Implementation",
+                    "description": f"Apply all learned skills in a comprehensive {topic} project that showcases mastery and solves a real-world problem.",
+                    "complexity": "High",
+                    "skills_practiced": [f"Advanced {topic} mastery", "System design", "Optimization"],
+                    "resources": ["Industry case studies", "Research papers", "Expert communities"],
+                    "estimated_time": "6-8 weeks"
+                }
+            ],
+            "resources": {
+                "books": [f"Introduction to {topic}", f"Advanced {topic} Techniques", f"Mastering {topic}"],
+                "online_courses": [f"{topic} for Beginners", f"Professional {topic} Masterclass"],
+                "communities": ["Stack Overflow", "Reddit", f"{topic} Discord Servers"],
+                "tools": [f"{topic} Development Environment", "Version Control", "Testing Frameworks"],
+                "practice_platforms": ["Codecademy", "Exercism", "LeetCode"]
+            },
+            "career_insights": [
+                f"Proficiency in {topic} is valuable for roles in software development, data science, and IT operations",
+                f"Entry-level {topic} positions typically require demonstrated project experience",
+                f"{topic} specialists can pursue careers in consulting, education, or product development"
+            ]
+        }
+
+    def get_course_details(self, course: pd.Series) -> Dict[str, str]:
+        """
+        Get detailed course information
+        """
+        return {
+            "name": course.get('Course Name', 'N/A'),
+            "difficulty": course.get('Difficulty Level', 'N/A'),
+            "rating": str(course.get('Course Rating', 'N/A')),
+            "url": course.get('Course URL', '#'),
+            "skills": course.get('Skills', 'N/A'),
+            "description": course.get('Description', 'No description available'),
+            "id": str(course.get('Course ID', '0'))
+        }
+
+    def display_roadmap(self, roadmap: Dict):
+        """
+        Display the learning roadmap in a beautiful format using rich
+        """
+        self.console.print("\n")
+        self.console.print(Panel("[bold cyan]YOUR PERSONALIZED LEARNING JOURNEY[/bold cyan]",
+                               box=box.DOUBLE, expand=False))
+
+        # Create a tree for learning path
+        learning_tree = Tree("[bold yellow]Learning Path[/bold yellow]")
+        for stage in roadmap["learningPath"]:
+            stage_node = learning_tree.add(f"[bold green]{stage['step']}[/bold green] ({stage['difficulty']}) - {stage['time_estimate']}")
+            stage_node.add(f"[italic]{stage['description']}[/italic]")
+
+            concepts_node = stage_node.add("[bold blue]Key Concepts:[/bold blue]")
+            for concept in stage.get("key_concepts", []):
+                concepts_node.add(concept)
+
+            if "milestones" in stage:
+                milestones_node = stage_node.add("[bold magenta]Milestones:[/bold magenta]")
+                for milestone in stage["milestones"]:
+                    milestones_node.add(milestone)
+                    
+            if "practice_activities" in stage:
+                activities_node = stage_node.add("[bold cyan]Practice Activities:[/bold cyan]")
+                for activity in stage["practice_activities"]:
+                    activities_node.add(activity)
+
+        self.console.print(learning_tree)
+        self.console.print("\n")
+
+        # Project suggestions table
+        project_table = Table(title="Recommended Projects", box=box.ROUNDED)
+        project_table.add_column("Project Name", style="cyan", no_wrap=True)
+        project_table.add_column("Description", style="white")
+        project_table.add_column("Complexity", style="magenta")
+        project_table.add_column("Est. Time", style="yellow")
+
+        for project in roadmap["projectSuggestions"]:
+            project_table.add_row(
+                project["name"],
+                project["description"],
+                project["complexity"],
+                project.get("estimated_time", "N/A")
+            )
+
+        self.console.print(project_table)
+        self.console.print("\n")
+
+        # Resources panel
+        resources = roadmap.get("resources", {})
+        resources_text = ""
+
+        resource_categories = {
+            "books": "Recommended Books",
+            "online_courses": "Online Courses",
+            "communities": "Communities",
+            "tools": "Essential Tools",
+            "practice_platforms": "Practice Platforms"
+        }
+        
+        for category, title in resource_categories.items():
+            if category in resources and resources[category]:
+                resources_text += f"[bold yellow]{title}:[/bold yellow]\n"
+                for item in resources[category]:
+                    resources_text += f"• {item}\n"
+                resources_text += "\n"
+
+        self.console.print(Panel(resources_text, title="[bold cyan]Learning Resources[/bold cyan]",
+                               box=box.ROUNDED, expand=False))
+                               
+        # Career insights
+        if "career_insights" in roadmap and roadmap["career_insights"]:
+            career_text = "[bold yellow]Career Insights:[/bold yellow]\n"
+            for insight in roadmap["career_insights"]:
+                career_text += f"• {insight}\n"
+                
+            self.console.print(Panel(career_text, title="[bold cyan]Career Opportunities[/bold cyan]",
+                               box=box.ROUNDED, expand=False))
+
+    def display_recommended_courses(self, courses: pd.DataFrame):
+        """
+        Display recommended courses in a beautiful format
+        """
+        if courses.empty:
+            self.console.print("[yellow]No courses match your criteria. Try broader search terms.[/yellow]")
+            return
+
+        table = Table(title="Recommended Courses", box=box.ROUNDED)
+        table.add_column("ID", style="dim")
+        table.add_column("Course Name", style="cyan")
+        table.add_column("Rating", style="yellow")
+        table.add_column("Difficulty", style="green")
+
+        for _, course in courses.iterrows():
+            table.add_row(
+                str(course.get('Course ID', 'N/A')),
+                course.get('Course Name', 'N/A').title(),
+                f"{course.get('Course Rating', 0):.1f} ★",
+                course.get('Difficulty Level', 'N/A').title()
+            )
+
+        self.console.print(table)
+        self.console.print("\n[dim]Use the course ID to get more details about a specific course.[/dim]")
+        
+    def roadmap_to_markdown(self, roadmap: Dict, topic: str, skill_level: str) -> str:
+        """
+        Convert a roadmap to markdown format for export or display
+        """
+        markdown = f"# Personalized Learning Roadmap: {topic.title()}\n\n"
+        markdown += f"*Skill Level: {skill_level.title()}*\n\n"
+        
+        # Learning Path
+        markdown += "## Learning Path\n\n"
+        for i, stage in enumerate(roadmap["learningPath"]):
+            markdown += f"### {i+1}. {stage['step']} ({stage['difficulty']}) - {stage['time_estimate']}\n\n"
+            markdown += f"{stage['description']}\n\n"
+            
+            markdown += "**Key Concepts:**\n"
+            for concept in stage.get("key_concepts", []):
+                markdown += f"- {concept}\n"
+            markdown += "\n"
+            
+            if "milestones" in stage:
+                markdown += "**Milestones:**\n"
+                for milestone in stage["milestones"]:
+                    markdown += f"- {milestone}\n"
+                markdown += "\n"
+                
+            if "practice_activities" in stage:
+                markdown += "**Practice Activities:**\n"
+                for activity in stage["practice_activities"]:
+                    markdown += f"- {activity}\n"
+                markdown += "\n"
+        
+        # Project Suggestions
+        markdown += "## Recommended Projects\n\n"
+        for i, project in enumerate(roadmap["projectSuggestions"]):
+            markdown += f"### {i+1}. {project['name']} ({project['complexity']})\n\n"
+            markdown += f"{project['description']}\n\n"
+            
+            if "skills_practiced" in project:
+                markdown += "**Skills Practiced:**\n"
+                for skill in project["skills_practiced"]:
+                    markdown += f"- {skill}\n"
+                markdown += "\n"
+                
+            markdown += "**Resources:**\n"
+            for resource in project.get("resources", []):
+                markdown += f"- {resource}\n"
+            markdown += "\n"
+            
+            if "estimated_time" in project:
+                markdown += f"**Estimated Time:** {project['estimated_time']}\n\n"
+        
+        # Resources
+        markdown += "## Learning Resources\n\n"
+        resources = roadmap.get("resources", {})
+        
+        resource_categories = {
+            "books": "Recommended Books",
+            "online_courses": "Online Courses",
+            "communities": "Communities",
+            "tools": "Essential Tools",
+            "practice_platforms": "Practice Platforms"
+        }
+        
+        for category, title in resource_categories.items():
+            if category in resources and resources[category]:
+                markdown += f"### {title}\n"
+                for item in resources[category]:
+                    markdown += f"- {item}\n"
+                markdown += "\n"
+        
+        # Career Insights
+        if "career_insights" in roadmap and roadmap["career_insights"]:
+            markdown += "## Career Opportunities\n\n"
+            for insight in roadmap["career_insights"]:
+                markdown += f"- {insight}\n"
+                
+        return markdown
+
+class TeacherRecommender(BaseRecommender):
+    def __init__(self, teachers_data: List[Dict[str, Any]]):
+        """
+        Initialize the teacher recommender with teacher data
+        """
+        super().__init__()
+        self.teachers = pd.DataFrame(teachers_data)
+        self._preprocess_data()
+        
+    def _preprocess_data(self):
+        """
+        Preprocess the teacher data for better recommendations
+        """
+        # Convert text columns to lowercase for easier matching
+        text_columns = ['name', 'location', 'subject', 'description', 'preferredMode']
+        for col in text_columns:
+            if col in self.teachers.columns:
+                self.teachers[col] = self.teachers[col].astype(str).str.lower()
+                
+        # Ensure numeric columns are properly formatted
+        self.teachers['rating'] = pd.to_numeric(self.teachers['rating'], errors='coerce').fillna(0)
+        self.teachers['fees'] = pd.to_numeric(self.teachers['fees'], errors='coerce').fillna(0)
+        self.teachers['experience'] = pd.to_numeric(self.teachers['experience'], errors='coerce').fillna(0)
+        
+        # Add teacher ID for easy reference
+        self.teachers['Teacher ID'] = range(1, len(self.teachers) + 1)
+    
+    def recommend_teachers(self, 
+                          subject: Optional[str] = None,
+                          location: Optional[str] = None,
+                          preferred_mode: Optional[str] = None,
+                          max_fees: Optional[float] = None,
+                          min_experience: Optional[int] = None,
+                          min_rating: Optional[float] = None,
+                          top_n: int = 5) -> pd.DataFrame:
+        """
+        Recommend teachers based on criteria
+        """
+        filtered_teachers = self.teachers.copy()
+        
+        # Show processing indicator
+        with self.console.status("[bold green]Finding the best teachers for you...", spinner="dots"):
+            # Filter by subject if provided
+            if subject:
+                subject = subject.lower()
+                # Calculate keyword match score for subject
+                filtered_teachers['subject_match'] = filtered_teachers['subject'].str.contains(subject).astype(int)
+                filtered_teachers = filtered_teachers[filtered_teachers['subject_match'] > 0]
+            
+            # Filter by location if provided
+            if location and not filtered_teachers.empty:
+                location = location.lower()
+                filtered_teachers = filtered_teachers[filtered_teachers['location'].str.contains(location)]
+            
+            # Filter by preferred mode if provided
+            if preferred_mode and not filtered_teachers.empty:
+                preferred_mode = preferred_mode.lower()
+                filtered_teachers = filtered_teachers[filtered_teachers['preferredMode'] == preferred_mode]
+            
+            # Filter by maximum fees if provided
+            if max_fees is not None and not filtered_teachers.empty:
+                filtered_teachers = filtered_teachers[filtered_teachers['fees'] <= max_fees]
+            
+            # Filter by minimum experience if provided
+            if min_experience is not None and not filtered_teachers.empty:
+                filtered_teachers = filtered_teachers[filtered_teachers['experience'] >= min_experience]
+            
+            # Filter by minimum rating if provided
+            if min_rating is not None and not filtered_teachers.empty:
+                filtered_teachers = filtered_teachers[filtered_teachers['rating'] >= min_rating]
+            
+            # Calculate recommendation score
+            if not filtered_teachers.empty:
+                filtered_teachers['recommendation_score'] = (
+                    filtered_teachers['rating'] * 0.4 +
+                    filtered_teachers['experience'] * 0.3 -
+                    (filtered_teachers['fees'] / 1000) * 0.2  # Normalize fees impact
+                )
+                
+                # Sort by recommendation score
+                filtered_teachers = filtered_teachers.sort_values('recommendation_score', ascending=False)
+        
+        return filtered_teachers.head(top_n)
+    
+    def get_teacher_details(self, teacher: pd.Series) -> Dict[str, str]:
+        """
+        Get detailed teacher information
+        """
+        return {
+            "name": teacher.get('name', 'N/A').title(),
+            "email": teacher.get('email', 'N/A'),
+            "location": teacher.get('location', 'N/A').title(),
+            "subject": teacher.get('subject', 'N/A').title(),
+            "rating": str(teacher.get('rating', 'N/A')),
+            "preferredMode": teacher.get('preferredMode', 'N/A').title(),
+            "fees": str(teacher.get('fees', 'N/A')),
+            "description": teacher.get('description', 'No description available'),
+            "experience": str(teacher.get('experience', 'N/A')),
+            "id": str(teacher.get('Teacher ID', '0'))
+        }
+    
+    def display_recommended_teachers(self, teachers: pd.DataFrame):
+        """
+        Display recommended teachers in a beautiful format
+        """
+        if teachers.empty:
+            self.console.print("[yellow]No teachers match your criteria. Try broader search terms.[/yellow]")
+            return
+        
+        table = Table(title="Recommended Teachers", box=box.ROUNDED)
+        table.add_column("ID", style="dim")
+        table.add_column("Name", style="cyan")
+        table.add_column("Subject", style="green")
+        table.add_column("Rating", style="yellow")
+        table.add_column("Experience", style="magenta")
+        table.add_column("Fees", style="blue")
+        table.add_column("Mode", style="cyan")
+        
+        for _, teacher in teachers.iterrows():
+            table.add_row(
+                str(teacher.get('Teacher ID', 'N/A')),
+                teacher.get('name', 'N/A').title(),
+                teacher.get('subject', 'N/A').title(),
+                f"{teacher.get('rating', 0):.1f} ★",
+                f"{teacher.get('experience', 0)} years",
+                f"${teacher.get('fees', 0):.2f}",
+                teacher.get('preferredMode', 'N/A').title()
+            )
+        
+        self.console.print(table)
+        self.console.print("\n[dim]Use the teacher ID to get more details about a specific teacher.[/dim]")
+    
+    def teachers_to_markdown(self, recommended_teachers: pd.DataFrame) -> str:
+        """
+        Format teacher recommendations as markdown
+        """
+        teachers_md = "# Recommended Teachers\n\n"
+        for i, (_, teacher) in enumerate(recommended_teachers.iterrows()):
+            teachers_md += f"## {i+1}. {teacher.get('name', 'N/A').title()}\n\n"
+            teachers_md += f"**Subject:** {teacher.get('subject', 'N/A').title()}\n\n"
+            teachers_md += f"**Rating:** {teacher.get('rating', 0):.1f} ★\n\n"
+            teachers_md += f"**Experience:** {teacher.get('experience', 0)} years\n\n"
+            teachers_md += f"**Location:** {teacher.get('location', 'N/A').title()}\n\n"
+            teachers_md += f"**Preferred Mode:** {teacher.get('preferredMode', 'N/A').title()}\n\n"
+            teachers_md += f"**Fees:** ${teacher.get('fees', 0):.2f}\n\n"
+            teachers_md += f"**Description:**\n{teacher.get('description', 'No description available')}\n\n"
+            teachers_md += f"**Contact:** {teacher.get('email', 'N/A')}\n\n"
+            teachers_md += "---\n\n"
+        return teachers_md
+
+def load_courses(file_path: str = 'Coursera.csv') -> Optional[CourseRecommender]:
+    """
+    Load courses from CSV and create a CourseRecommender instance
+    """
+    console = Console()
+
+    try:
+        with console.status("[bold green]Loading course data...", spinner="dots"):
+            df = pd.read_csv(file_path)
+            time.sleep(1)  # Simulate loading time for visual effect
+            console.print(f"[green]Successfully loaded {len(df)} courses![/green]")
+        return CourseRecommender(df)
+    except FileNotFoundError:
+        console.print(f"[red]Error: {file_path} file not found.[/red]")
+        return None
+    except Exception as e:
+        console.print(f"[red]An error occurred while reading the CSV: {e}[/red]")
+        return None
+
+def load_teachers(file_path: str = 'teachers.json') -> Optional[TeacherRecommender]:
+    """
+    Load teachers from JSON and create a TeacherRecommender instance
+    """
+    console = Console()
+    
+    try:
+        with console.status("[bold green]Loading teacher data...", spinner="dots"):
+            with open(file_path, 'r') as f:
+                teachers_data = json.load(f)
+                
+            # Check if it's a list of teachers or a single teacher
+            if not isinstance(teachers_data, list):
+                teachers_data = [teachers_data]
+                
+            console.print(f"[green]Successfully loaded {len(teachers_data)} teachers![/green]")
+        return TeacherRecommender(teachers_data)
+    except FileNotFoundError:
+        console.print(f"[red]Error: {file_path} file not found.[/red]")
+        return None
+    except Exception as e:
+        console.print(f"[red]An error occurred while reading the JSON: {e}[/red]")
+        return None
+
+def format_courses_as_markdown(recommended_courses: pd.DataFrame) -> str:
+    """
+    Format course recommendations as markdown
+    """
+    courses_md = "# Recommended Courses\n\n"
+    for i, (_, course) in enumerate(recommended_courses.iterrows()):
+        courses_md += f"## {i+1}. {course.get('Course Name', 'N/A').title()}\n\n"
+        courses_md += f"**Rating:** {course.get('Course Rating', 0):.1f} ★\n\n"
+        courses_md += f"**Difficulty:** {course.get('Difficulty Level', 'N/A').title()}\n\n"
+        courses_md += f"**Skills:** {course.get('Skills', 'N/A').title()}\n\n"
+        courses_md += f"**Description:**\n{course.get('Description', 'No description available')}\n\n"
+        if 'Course URL' in course and course['Course URL'] != '#':
+            courses_md += f"[View Course]({course['Course URL']})\n\n"
+        courses_md += "---\n\n"
+    return courses_md
+
+def main():
+    console = Console()
+
+    # Print welcome message
+    console.print(Panel.fit(
+        "[bold cyan]Enhanced Learning Platform[/bold cyan]\n"
+        "[yellow]Find the perfect courses, create your learning journey, and connect with expert teachers[/yellow]",
+        box=box.DOUBLE))
+
+    # Load both course and teacher data
+    course_recommender = load_courses()
+    teacher_recommender = load_teachers()
+    
+    if not course_recommender or not teacher_recommender:
+        return
+
+    console.print("[bold]Let's find the perfect learning path for you![/bold]\n")
+
+    topic = console.input("[bold green]Enter the topic you want to learn about: [/bold green]")
+    skill_level = console.input("[bold green]Enter your skill level (Beginner, Intermediate, Advanced): [/bold green]")
+
+    use_ai = False
+    user_goals = None
+
+    if course_recommender.ai_enabled:
+        use_ai = console.input("[bold green]Would you like AI-enhanced personalized recommendations? (y/n): [/bold green]").lower() == 'y'
+        if use_ai:
+            user_goals = console.input("[bold green]What are your learning goals or career objectives with this topic? [/bold green]")
+
+    # Generate and display roadmap
+    roadmap = course_recommender.generate_roadmap(topic, skill_level, user_goals, detailed=use_ai)
+    course_recommender.display_roadmap(roadmap)
+    
+    # Option to export roadmap
+    export = console.input("\n[bold green]Would you like to export this roadmap to a markdown file? (y/n): [/bold green]").lower() == 'y'
+    if export:
+        markdown = course_recommender.roadmap_to_markdown(roadmap, topic, skill_level)
+        filename = f"{topic.lower().replace(' ', '_')}_roadmap.md"
+        with open(filename, "w") as f:
+            f.write(markdown)
+        console.print(f"[green]Roadmap exported to {filename}[/green]")
+
+    console.print("\n[bold]Press Enter to see recommended courses...[/bold]")
+    input()
+
+    # Get and display recommended courses
+    recommended_courses = course_recommender.recommend_courses(topic, skill_level, personalized=use_ai, user_goals=user_goals)
+    course_recommender.display_recommended_courses(recommended_courses)
+
+    # Now offer teacher recommendations
+    find_teachers = console.input("\n[bold green]Would you like to find teachers for this subject? (y/n): [/bold green]").lower() == 'y'
+    
+    if find_teachers:
+        console.print("\n[bold cyan]Finding teachers for your learning journey...[/bold cyan]")
+        
+        # Get additional teacher filtering criteria
+        location = console.input("[bold green]Preferred location (or press Enter to skip): [/bold green]")
+        preferred_mode = console.input("[bold green]Preferred teaching mode (online/in-person, or press Enter to skip): [/bold green]")
+        
+        max_fees_str = console.input("[bold green]Maximum budget for teacher fees (or press Enter to skip): [/bold green]")
+        max_fees = float(max_fees_str) if max_fees_str else None
+        
+        min_experience_str = console.input("[bold green]Minimum years of experience (or press Enter to skip): [/bold green]")
+        min_experience = int(min_experience_str) if min_experience_str else None
+        
+        min_rating_str = console.input("[bold green]Minimum teacher rating (1-5, or press Enter to skip): [/bold green]")
+        min_rating = float(min_rating_str) if min_rating_str else None
+        
+        # Get teacher recommendations
+        recommended_teachers = teacher_recommender.recommend_teachers(
+            subject=topic,
+            location=location if location else None,
+            preferred_mode=preferred_mode if preferred_mode else None,
+            max_fees=max_fees,
+            min_experience=min_experience,
+            min_rating=min_rating
+        )
+        
+        # Display teacher recommendations
+        teacher_recommender.display_recommended_teachers(recommended_teachers)
+        
+        # Allow user to view detailed teacher info
+        while True:
+            teacher_id = console.input("\n[bold green]Enter a teacher ID for more details (or 'q' to quit): [/bold green]")
+            if teacher_id.lower() == 'q':
+                break
+            
+            try:
+                teacher_id = int(teacher_id)
+                teacher = recommended_teachers[recommended_teachers['Teacher ID'] == teacher_id]
+                if not teacher.empty:
+                    details = teacher_recommender.get_teacher_details(teacher.iloc[0])
+                    
+                    console.print(Panel(
+                        f"[bold cyan]{details['name']}[/bold cyan]\n\n"
+                        f"[yellow]Subject:[/yellow] {details['subject']}\n"
+                        f"[yellow]Rating:[/yellow] {details['rating']} ★\n"
+                        f"[yellow]Experience:[/yellow] {details['experience']} years\n"
+                        f"[yellow]Location:[/yellow] {details['location']}\n"
+                        f"[yellow]Preferred Mode:[/yellow] {details['preferredMode']}\n"
+                        f"[yellow]Fees:[/yellow] ${details['fees']}\n\n"
+                        f"[yellow]Description:[/yellow]\n{details['description']}\n\n"
+                        f"[yellow]Contact:[/yellow] {details['email']}",
+                        title="Teacher Details", box=box.ROUNDED, width=100
+                    ))
+                else:
+                    console.print("[yellow]Teacher ID not found. Please try again.[/yellow]")
+            except ValueError:
+                console.print("[yellow]Please enter a valid teacher ID.[/yellow]")
+
+    console.print(Panel("[bold cyan]Thank you for using our Enhanced Learning Platform![/bold cyan]", box=box.ROUNDED))
+
+def create_gradio_interface(course_recommender: CourseRecommender, teacher_recommender: TeacherRecommender):
+    """
+    Create a Gradio interface that includes both course and teacher recommendations
+    """
+    def recommend_all(topic, skill_level, goals, use_ai, location, preferred_mode, max_fees, min_experience, min_rating):
+        try:
+            # Generate roadmap
+            roadmap = course_recommender.generate_roadmap(
+                topic=topic, 
+                skill_level=skill_level, 
+                user_goals=goals if goals else None, 
+                detailed=use_ai
+            )
+            
+            # Get course recommendations
+            recommended_courses = course_recommender.recommend_courses(
+                topic=topic, 
+                skill_level=skill_level, 
+                personalized=use_ai, 
+                user_goals=goals if goals else None
+            )
+            
+            # Get teacher recommendations
+            recommended_teachers = teacher_recommender.recommend_teachers(
+                subject=topic,
+                location=location if location else None,
+                preferred_mode=preferred_mode if preferred_mode else None,
+                max_fees=float(max_fees) if max_fees else None,
+                min_experience=int(min_experience) if min_experience else None,
+                min_rating=float(min_rating) if min_rating else None
+            )
+            
+            # Convert roadmap to markdown
+            roadmap_md = course_recommender.roadmap_to_markdown(roadmap, topic, skill_level)
+            
+            # Format course recommendations as markdown
+            courses_md = format_courses_as_markdown(recommended_courses)
+            
+            # Format teacher recommendations as markdown
+            teachers_md = teacher_recommender.teachers_to_markdown(recommended_teachers)
+            
+            return roadmap_md, courses_md, teachers_md
+        except Exception as e:
+            return f"Error: {str(e)}", "Could not generate recommendations", "Could not generate teacher recommendations"
+    
+    with gr.Blocks(title="Complete Learning Platform") as demo:
+        gr.Markdown("# 🎓 Complete Learning Platform")
+        gr.Markdown("Generate a personalized learning roadmap, course recommendations, and find expert teachers.")
+        
+        with gr.Tabs():
+            with gr.TabItem("Learning Journey"):
+                with gr.Row():
+                    with gr.Column():
+                        topic_input = gr.Textbox(label="Topic you want to learn", placeholder="e.g. Python, Data Science, Machine Learning")
+                        skill_level = gr.Dropdown(
+                            ["Beginner", "Intermediate", "Advanced"], 
+                            label="Your current skill level"
+                        )
+                        goals_input = gr.Textbox(
+                            label="Your learning goals (optional)", 
+                            placeholder="e.g. Career change, specific project, skill enhancement",
+                            lines=3
+                        )
+                        use_ai = gr.Checkbox(label="Use AI-enhanced personalization")
+                    
+                    with gr.Column():
+                        location_input = gr.Textbox(label="Preferred location (optional)", placeholder="e.g. Bangalore, Remote")
+                        mode_input = gr.Radio(["online", "in-person", "both"], label="Preferred teaching mode", value="both")
+                        max_fees_input = gr.Number(label="Maximum budget for teacher fees (optional)")
+                        min_exp_input = gr.Number(label="Minimum years of experience (optional)", precision=0)
+                        min_rating_input = gr.Slider(minimum=1, maximum=5, value=3, step=0.5, label="Minimum teacher rating")
+                
+                generate_btn = gr.Button("Generate Complete Learning Plan")
+            
+            with gr.TabItem("Results"):
+                roadmap_output = gr.Markdown(label="Your Personalized Learning Roadmap")
+                courses_output = gr.Markdown(label="Recommended Courses")
+                teachers_output = gr.Markdown(label="Recommended Teachers")
+        
+        generate_btn.click(
+            recommend_all,
+            inputs=[topic_input, skill_level, goals_input, use_ai, 
+                   location_input, mode_input, max_fees_input, min_exp_input, min_rating_input],
+            outputs=[roadmap_output, courses_output, teachers_output]
+        )
+    
+    return demo
+
+if __name__ == "__main__":
+    # Check if being run on Hugging Face Spaces
+    if os.getenv("SPACE_ID"):
+        # Initialize with the data files that should be included in the Space
+        course_recommender = load_courses("Coursera.csv")
+        teacher_recommender = load_teachers("teachers.json")
+        
+        if course_recommender and teacher_recommender:
+            # Deploy as a Gradio app
+            app = create_gradio_interface(course_recommender, teacher_recommender)
+            app.launch()
+    else:
+        # Run as CLI application
+        main()

requirements.txt

@@ -0,0 +1,10 @@
+pandas
+numpy
+json5  # JSON is built-in, but some cases require json5
+requests
+python-dotenv
+rich
+tqdm
+openai
+gradio
+huggingface_hub