app.py

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 CourseRecommender:
    def __init__(self, dataframe: pd.DataFrame):
        """
        Initialize the course recommender with course data
        """
        self.courses = dataframe.drop(columns=['Unnamed: 1', 'Unnamed: 5'], errors='ignore')
        self._preprocess_data()
        self.console = Console()

        # Initialize OpenAI client
        api_key = os.getenv("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")
        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]")

    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

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 format_courses_as_markdown(recommended_courses: pd.DataFrame) -> str:
    """
    Format course recommendations as markdown - extracted common function
    """
    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]Course Recommender & Learning Roadmap Generator[/bold cyan]\n"
        "[yellow]Find the perfect courses and create your personalized learning journey[/yellow]",
        box=box.DOUBLE))

    recommender = load_courses()
    if recommender:
        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 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 = recommender.generate_roadmap(topic, skill_level, user_goals, detailed=use_ai)
        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 = 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 = recommender.recommend_courses(topic, skill_level, personalized=use_ai, user_goals=user_goals)
        recommender.display_recommended_courses(recommended_courses)

        # Allow user to view detailed course info
        while True:
            course_id = console.input("\n[bold green]Enter a course ID for more details (or 'q' to quit): [/bold green]")
            if course_id.lower() == 'q':
                break

            try:
                course_id = int(course_id)
                course = recommended_courses[recommended_courses['Course ID'] == course_id]
                if not course.empty:
                    details = recommender.get_course_details(course.iloc[0])

                    console.print(Panel(
                        f"[bold cyan]{details['name'].title()}[/bold cyan]\n\n"
                        f"[yellow]Rating:[/yellow] {details['rating']} ★\n"
                        f"[yellow]Difficulty:[/yellow] {details['difficulty'].title()}\n\n"
                        f"[yellow]Skills:[/yellow] {details['skills'].title()}\n\n"
                        f"[yellow]Description:[/yellow]\n{details['description']}\n\n"
                        f"[link={details['url']}]View Course[/link]",
                        title="Course Details", box=box.ROUNDED, width=100
                    ))
                else:
                    console.print("[yellow]Course ID not found. Please try again.[/yellow]")
            except ValueError:
                console.print("[yellow]Please enter a valid course ID.[/yellow]")

    console.print(Panel("[bold cyan]Thank you for using the Course Recommender![/bold cyan]", box=box.ROUNDED))

# Gradio interface for Hugging Face deployment
def create_gradio_interface(recommender: CourseRecommender):
    """
    Create a Gradio interface for the course recommender
    """
    def recommend_and_generate(topic, skill_level, goals, use_ai):
        try:
            # Generate roadmap
            roadmap = recommender.generate_roadmap(
                topic=topic, 
                skill_level=skill_level, 
                user_goals=goals if goals else None, 
                detailed=use_ai
            )
            
            # Get course recommendations
            recommended_courses = recommender.recommend_courses(
                topic=topic, 
                skill_level=skill_level, 
                personalized=use_ai, 
                user_goals=goals if goals else None
            )
            
            # Convert roadmap to markdown
            roadmap_md = recommender.roadmap_to_markdown(roadmap, topic, skill_level)
            
            # Format course recommendations as markdown
            courses_md = format_courses_as_markdown(recommended_courses)
            
            return roadmap_md, courses_md
        except Exception as e:
            return f"Error: {str(e)}", "Could not generate course recommendations"
    
    with gr.Blocks(css="""
        body, p, h1, h2, h3, h4, h5, h6, li, ul, a, span,em,strong, .gradio-container {
            background-color: #f9f9f9 !important;
            color: #000000 !important;
        }
        .gr-button, .gr-textbox, .gr-input, .gr-output, .gr-dropdown, .gr-checkbox, .gr-markdown, .gr-output, .gr-textbox-output {
            color: #000000 !important;
        }
    """) as demo:  # Custom CSS for background and text color
        gr.Markdown("# 🎓  Learning Roadmap & Course Recommender ASCEND ")
        gr.Markdown("Generate a personalized learning roadmap and course recommendations.")
        
        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")
                
                generate_btn = gr.Button("Generate Roadmap & Recommendations")
                
            with gr.Column():
                roadmap_output = gr.Markdown(label="Your Personalized Learning Roadmap")
                courses_output = gr.Markdown(label="Recommended Courses")
        
        generate_btn.click(
            recommend_and_generate,
            inputs=[topic_input, skill_level, goals_input, use_ai],
            outputs=[roadmap_output, courses_output]
        )
    
    return demo
    
if __name__ == "__main__":
    # Check if being run on Hugging Face Spaces
    if os.getenv("SPACE_ID"):
        # Initialize with the CSV file that should be included in the Space
        recommender = load_courses("Coursera.csv")
        if recommender:
            # Deploy as a Gradio app
            app = create_gradio_interface(recommender)
            app.launch()
    else:
        # Run as CLI application
        main()