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-4o", # Using more capable model for better roadmaps 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() # Convert any legacy "in-person" to "offline" if 'preferredMode' in self.teachers.columns: self.teachers['preferredMode'] = self.teachers['preferredMode'].str.replace('in-person', 'offline').str.replace('inperson', 'offline') # 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().replace('in-person', 'offline') if preferred_mode != 'both': 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 """ mode = teacher.get('preferredMode', 'N/A').title() mode = mode.replace("Inperson", "Offline").replace("In-Person", "Offline") 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": mode, "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(): mode = teacher.get('preferredMode', 'N/A').title() mode = mode.replace("Inperson", "Offline").replace("In-Person", "Offline") 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}", mode ) 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()): mode = teacher.get('preferredMode', 'N/A').title() mode = mode.replace("Inperson", "Offline").replace("In-Person", "Offline") 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:** {mode}\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_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] # Clean and validate teacher data validated_teachers = [] for teacher in teachers_data: # Ensure required fields exist teacher.setdefault('rating', 0) teacher.setdefault('fees', 0) teacher.setdefault('experience', 0) teacher.setdefault('preferredMode', 'both') # Convert any legacy modes to offline if 'preferredMode' in teacher: teacher['preferredMode'] = teacher['preferredMode'].lower().replace('in-person', 'offline').replace('inperson', 'offline') validated_teachers.append(teacher) console.print(f"[green]Successfully loaded {len(validated_teachers)} teachers![/green]") return TeacherRecommender(validated_teachers) 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 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", "offline", "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()