Update app.py

app.py

@@ -1,3 +1,43 @@
+# ========== STARTUP DEPENDENCY CHECK ==========
+import sys
+import subprocess
+import importlib
+
+# List of required packages with their import names and pip names
+required_packages = {
+    'gradio': 'gradio',
+    'pandas': 'pandas',
+    'PyPDF2': 'PyPDF2',
+    'transformers': 'transformers',
+    'pdfplumber': 'pdfplumber',
+    'typing_extensions': 'typing_extensions'  # Often needed for transformers
+}
+
+def check_and_install_packages():
+    missing_packages = []
+    for import_name, pkg_name in required_packages.items():
+        try:
+            importlib.import_module(import_name)
+        except ImportError:
+            missing_packages.append(pkg_name)
+
+    if missing_packages:
+        print(f"Missing packages: {', '.join(missing_packages)}")
+        print("Attempting to install...")
+        
+        try:
+            subprocess.check_call([sys.executable, "-m", "pip", "install", *missing_packages])
+            print("Installation successful. Please restart the application.")
+            sys.exit(0)
+        except subprocess.CalledProcessError as e:
+            print(f"Failed to install packages. Error: {e}")
+            print("Please install them manually with:")
+            print(f"pip install {' '.join(missing_packages)}")
+            sys.exit(1)
+
+check_and_install_packages()
+
+# ========== MAIN IMPORTS (AFTER DEPENDENCY CHECK) ==========
 import gradio as gr
 import pandas as pd
 import json
@@ -9,700 +49,14 @@ from transformers import pipeline
 from typing import List, Dict, Union
 import pdfplumber
 
-# Initialize NER model (will load only if transformers is available)
-try:
-    ner_pipeline = pipeline("ner", model="dslim/bert-base-NER")
-except Exception as e:
-    print(f"Could not load NER model: {e}")
-    ner_pipeline = None
-
-# ========== IMPROVED TRANSCRIPT PARSING ==========
-class UniversalTranscriptParser:
-    def __init__(self):
-        # Patterns for different transcript types
-        self.patterns = {
-            'miami_dade': self._compile_miami_dade_patterns(),
-            'homeschool': self._compile_homeschool_patterns(),
-            'doral_academy': self._compile_doral_academy_patterns()
-        }
-        
-        # Grade level mappings
-        self.grade_level_map = {
-            '09': '9th Grade', '10': '10th Grade', '11': '11th Grade', '12': '12th Grade',
-            '07': '7th Grade', '08': '8th Grade', 'MA': 'Middle School'
-        }
-    
-    def parse_transcript(self, text: str) -> Dict[str, Union[Dict, List[Dict]]]:
-        """Determine transcript type and parse accordingly"""
-        transcript_type = self._identify_transcript_type(text)
-        
-        if transcript_type == 'homeschool':
-            return self._parse_homeschool(text)
-        elif transcript_type == 'doral_academy':
-            return self._parse_doral_academy(text)
-        else:  # Default to Miami-Dade pattern
-            return self._parse_miami_dade(text)
-    
-    def _identify_transcript_type(self, text: str) -> str:
-        """Identify which type of transcript we're processing"""
-        if re.search(r'Sample OFFICIAL HIGH SCHOOL TRANSCRIPT', text):
-            return 'homeschool'
-        elif re.search(r'DORAL ACADEMY HIGH SCHOOL', text):
-            return 'doral_academy'
-        return 'miami_dade'
-    
-    def _parse_homeschool(self, text: str) -> Dict[str, Union[Dict, List[Dict]]]:
-        """Parse homeschool transcript format"""
-        courses = []
-        current_grade = None
-        current_year = None
-        
-        # Extract student info
-        student_info = {}
-        name_match = re.search(r'Student Name:\s*(.+)\s*SSN:', text)
-        if name_match:
-            student_info['name'] = name_match.group(1).strip()
-        
-        # Process each line
-        for line in text.split('\n'):
-            # Check for grade level header
-            grade_match = re.match(r'^\|?\s*(\d+th Grade)\s*\|.*(\d{4}-\d{4})', line)
-            if grade_match:
-                current_grade = grade_match.group(1)
-                current_year = grade_match.group(2)
-                continue
-            
-            # Course line pattern
-            course_match = re.match(
-                r'^\|?\s*([^\|]+?)\s*\|\s*([A-Z][+*]?)\s*\|\s*([^\|]+)\s*\|\s*(\d+\.?\d*)\s*\|\s*(\d+)',
-                line
-            )
-            
-            if course_match and current_grade:
-                course_name = course_match.group(1).strip()
-                # Clean course names that start with | or have extra spaces
-                course_name = re.sub(r'^\|?\s*', '', course_name)
-                
-                courses.append({
-                    'name': course_name,
-                    'grade_level': current_grade,
-                    'school_year': current_year,
-                    'grade': course_match.group(2),
-                    'credit_type': course_match.group(3).strip(),
-                    'credits': float(course_match.group(4)),
-                    'quality_points': int(course_match.group(5)),
-                    'transcript_type': 'homeschool'
-                })
-        
-        # Extract GPA information from homeschool transcript
-        gpa_data = {}
-        gpa_match = re.search(r'Cum\. GPA\s*\|\s*([\d\.]+)', text)
-        if gpa_match:
-            gpa_data['unweighted'] = gpa_match.group(1)
-            gpa_data['weighted'] = gpa_match.group(1)  # Homeschool often has same weighted/unweighted
-        
-        return {
-            'student_info': student_info,
-            'courses': {'All': courses},  # Homeschool doesn't separate by grade in same way
-            'gpa': gpa_data,
-            'grade_level': current_grade.replace('th Grade', '') if current_grade else "Unknown"
-        }
-    
-    def _parse_doral_academy(self, text: str) -> Dict[str, Union[Dict, List[Dict]]]:
-        """Parse Doral Academy specific format"""
-        courses = []
-        
-        # Extract student info
-        student_info = {}
-        name_match = re.search(r'LEGAL NAME:\s*([^\n]+)', text)
-        if name_match:
-            student_info['name'] = name_match.group(1).strip()
-        
-        # Extract school year information
-        year_pattern = re.compile(r'YEAR:\s*(\d{4}-\d{4})\s*GRADE LEVEL:\s*(\d{2})', re.MULTILINE)
-        year_matches = year_pattern.finditer(text)
-        
-        # Create mapping of grade levels to years
-        grade_year_map = {}
-        for match in year_matches:
-            grade_year_map[match.group(2)] = match.group(1)
-        
-        # Course pattern for Doral Academy
-        course_pattern = re.compile(
-            r'(\d)\s+(\d{7})\s+([^\n]+?)\s+([A-Z]{2})\s+([A-Z])\s+([A-Z])\s+([A-Z])\s+(\d\.\d{2})\s+(\d\.\d{2})',
-            re.MULTILINE
-        )
-        
-        courses_by_grade = defaultdict(list)
-        for match in course_pattern.finditer(text):
-            grade_level_num = match.group(1)
-            grade_level = self.grade_level_map.get(grade_level_num, f"Grade {grade_level_num}")
-            school_year = grade_year_map.get(grade_level_num, "Unknown")
-            
-            course_info = {
-                'course_code': match.group(2),
-                'name': match.group(3).strip(),
-                'subject_area': match.group(4),
-                'grade': match.group(5),
-                'inclusion_status': match.group(6),
-                'credit_status': match.group(7),
-                'credits_attempted': float(match.group(8)),
-                'credits': float(match.group(9)),
-                'grade_level': grade_level,
-                'school_year': school_year,
-                'transcript_type': 'doral_academy'
-            }
-            
-            courses_by_grade[grade_level_num].append(course_info)
-        
-        # Extract GPA information from Doral Academy transcript
-        gpa_data = {}
-        unweighted_match = re.search(r'Un-weighted GPA\s*([\d\.]+)', text)
-        weighted_match = re.search(r'Weighted GPA\s*([\d\.]+)', text)
-        
-        if unweighted_match:
-            gpa_data['unweighted'] = unweighted_match.group(1)
-        if weighted_match:
-            gpa_data['weighted'] = weighted_match.group(1)
-        
-        # Extract current grade level
-        grade_match = re.search(r'GRADE LEVEL:\s*12', text)  # Adjust as needed
-        grade_level = "12" if grade_match else "Unknown"
-        
-        return {
-            'student_info': student_info,
-            'courses': dict(courses_by_grade),
-            'gpa': gpa_data,
-            'grade_level': grade_level
-        }
-    
-    def _parse_miami_dade(self, text: str) -> Dict[str, Union[Dict, List[Dict]]]:
-        """Parse standard Miami-Dade format"""
-        courses = []
-        courses_by_grade = defaultdict(list)
-        
-        # Extract student info
-        student_info = {}
-        name_match = re.search(r'0783977 - ([^,]+),\s*([^\n]+)', text)
-        if name_match:
-            student_info['name'] = f"{name_match.group(2)} {name_match.group(1)}"
-        
-        # Course pattern for Miami-Dade
-        course_pattern = re.compile(
-            r'([A-Z]-[A-Za-z\s&]+)\s*\|\s*(\d{4}-\d{4})\s*\|\s*(\d{2})\s*\|\s*([A-Z0-9]+)\s*\|\s*([^\|]+)\s*\|\s*([^\|]+)\s*\|\s*([^\|]+)\s*\|\s*([A-Z]?)\s*\|\s*([A-Z]?)\s*\|\s*([^\|]+)',
-            re.MULTILINE
-        )
-        
-        for match in course_pattern.finditer(text):
-            grade_level = self.grade_level_map.get(match.group(3), match.group(3))
-            credits = match.group(10).strip()
-            
-            course_info = {
-                'requirement_category': match.group(1).strip(),
-                'school_year': match.group(2),
-                'grade_level': grade_level if isinstance(grade_level, str) else f"Grade {match.group(3)}",
-                'course_code': match.group(4).strip(),
-                'name': match.group(5).strip(),
-                'term': match.group(6).strip(),
-                'district_number': match.group(7).strip(),
-                'grade': match.group(8),
-                'inclusion_status': match.group(9),
-                'credits': 0.0 if 'inProgress' in credits else float(credits.replace(' ', '')),
-                'transcript_type': 'miami_dade'
-            }
-            
-            courses_by_grade[match.group(3)].append(course_info)
-        
-        # Extract GPA information
-        gpa_data = {
-            'weighted': extract_gpa(text, 'Weighted GPA'),
-            'unweighted': extract_gpa(text, 'Un-weighted GPA')
-        }
-        
-        # Extract current grade level
-        grade_match = re.search(r'Current Grade:\s*(\d+)', text)
-        grade_level = grade_match.group(1) if grade_match else "Unknown"
-        
-        return {
-            'student_info': student_info,
-            'courses': dict(courses_by_grade),
-            'gpa': gpa_data,
-            'grade_level': grade_level
-        }
-
-    # Helper methods for pattern compilation
-    def _compile_miami_dade_patterns(self):
-        return {
-            'student': re.compile(r'Current Grade:\s*(\d+).*YOG\s*(\d{4})'),
-            'course': re.compile(
-                r'([A-Z]-[A-Za-z\s&]+)\s*\|\s*(\d{4}-\d{4})\s*\|\s*(\d{2})\s*\|\s*([A-Z0-9]+)\s*\|\s*([^\|]+)\s*\|\s*([^\|]+)\s*\|\s*([^\|]+)\s*\|\s*([A-Z]?)\s*\|\s*([A-Z]?)\s*\|\s*([^\|]+)',
-                re.MULTILINE
-            )
-        }
-
-    def _compile_homeschool_patterns(self):
-        return {
-            'student': re.compile(r'Student Name:\s*(.+)\s*SSN:'),
-            'course': re.compile(
-                r'^\|?\s*([^\|]+?)\s*\|\s*([A-Z][+*]?)\s*\|\s*([^\|]+)\s*\|\s*(\d+\.?\d*)\s*\|\s*(\d+)'
-            )
-        }
-
-    def _compile_doral_academy_patterns(self):
-        return {
-            'student': re.compile(r'LEGAL NAME:\s*([^\n]+)'),
-            'course': re.compile(
-                r'(\d)\s+(\d{7})\s+([^\n]+?)\s+([A-Z]{2})\s+([A-Z])\s+([A-Z])\s+([A-Z])\s+(\d\.\d{2})\s+(\d\.\d{2})',
-                re.MULTILINE
-            )
-        }
-
-def extract_gpa(text, gpa_type):
-    pattern = rf'{gpa_type}\s*([\d\.]+)'
-    match = re.search(pattern, text)
-    return match.group(1) if match else "N/A"
-
-def parse_transcript(file):
-    parser = UniversalTranscriptParser()
-    
-    if file.name.endswith('.pdf'):
-        text = ''
-        with pdfplumber.open(file.name) as pdf:
-            for page in pdf.pages:
-                text += page.extract_text() + '\n'
-        
-        parsed_data = parser.parse_transcript(text)
-        
-        # Prepare detailed output
-        output_text = f"Student Transcript Summary\n{'='*40}\n"
-        
-        if 'student_info' in parsed_data and 'name' in parsed_data['student_info']:
-            output_text += f"Student: {parsed_data['student_info']['name']}\n"
-        
-        output_text += f"Current Grade Level: {parsed_data.get('grade_level', 'Unknown')}\n"
-        
-        if 'gpa' in parsed_data:
-            gpa = parsed_data['gpa']
-            output_text += f"Weighted GPA: {gpa.get('weighted', 'N/A')}\n"
-            output_text += f"Unweighted GPA: {gpa.get('unweighted', 'N/A')}\n\n"
-        
-        output_text += "Course History:\n{'='*40}\n"
-        
-        if 'courses' in parsed_data:
-            courses_by_grade = parsed_data['courses']
-            
-            # Improved grade sorting that handles both numeric and text grades
-            def grade_sort_key(grade):
-                try:
-                    # Extract numeric part from strings like "9th Grade" or "Grade 9"
-                    num = int(re.search(r'\d+', grade).group())
-                    return num
-                except (AttributeError, ValueError):
-                    # For non-numeric grades like "All", sort them last
-                    return float('inf')
-            
-            grades_sorted = sorted(courses_by_grade.keys(), key=grade_sort_key)
-            
-            for grade in grades_sorted:
-                output_text += f"\nGrade {grade}:\n{'-'*30}\n"
-                for course in courses_by_grade[grade]:
-                    output_text += f"- {course.get('name', 'Unnamed Course')}"
-                    if 'grade' in course and course['grade']:
-                        output_text += f" (Grade: {course['grade']})"
-                    if 'credits' in course:
-                        output_text += f" | Credits: {course['credits']}"
-                    if 'school_year' in course:
-                        output_text += f" | Year: {course['school_year']}"
-                    output_text += "\n"
-        
-        return output_text, parsed_data
-    else:
-        return "Unsupported file format (PDF only for transcript parsing)", None
-
-def transcript_display(transcript_dict):
-    if not transcript_dict or "courses" not in transcript_dict:
-        return "No course information available"
-    
-    display = "### Detailed Course History\n"
-    courses_by_grade = transcript_dict["courses"]
-    
-    if isinstance(courses_by_grade, dict):
-        # Improved grade sorting that handles both numeric and text grades
-        def grade_sort_key(grade):
-            try:
-                # Extract numeric part from strings like "9th Grade" or "Grade 9"
-                num = int(re.search(r'\d+', grade).group())
-                return num
-            except (AttributeError, ValueError):
-                # For non-numeric grades like "All", sort them last
-                return float('inf')
-        
-        grades_sorted = sorted(courses_by_grade.keys(), key=grade_sort_key)
-        
-        for grade in grades_sorted:
-            display += f"\n**Grade {grade}**\n"
-            for course in courses_by_grade[grade]:
-                display += f"- {course.get('name', 'Unnamed Course')}"
-                if 'grade' in course and course['grade']:
-                    display += f" (Grade: {course['grade']})"
-                if 'credits' in course:
-                    display += f" | Credits: {course['credits']}"
-                if 'school_year' in course:
-                    display += f" | Year: {course['school_year']}"
-                display += "\n"
-    
-    if 'gpa' in transcript_dict:
-        gpa = transcript_dict['gpa']
-        display += "\n**GPA Information**\n"
-        display += f"- Unweighted: {gpa.get('unweighted', 'N/A')}\n"
-        display += f"- Weighted: {gpa.get('weighted', 'N/A')}\n"
-    
-    return display
-
-# ========== LEARNING STYLE QUIZ ==========
-learning_style_questions = [
-    "When you study for a test, you prefer to:",
-    "When you need directions to a new place, you prefer:",
-    "When you learn a new skill, you prefer to:",
-    "When you're trying to concentrate, you:",
-    "When you meet new people, you remember them by:",
-    "When you're assembling furniture or a gadget, you:",
-    "When choosing a restaurant, you rely most on:",
-    "When you're in a waiting room, you typically:",
-    "When giving someone instructions, you tend to:",
-    "When you're trying to recall information, you:",
-    "When you're at a museum or exhibit, you:",
-    "When you're learning a new language, you prefer:",
-    "When you're taking notes in class, you:",
-    "When you're explaining something complex, you:",
-    "When you're at a party, you enjoy:",
-    "When you're trying to remember a phone number, you:",
-    "When you're relaxing, you prefer to:",
-    "When you're learning to use new software, you:",
-    "When you're giving a presentation, you rely on:",
-    "When you're solving a difficult problem, you:"
-]
-
-learning_style_options = [
-    ["Read the textbook (Reading/Writing)", "Listen to lectures (Auditory)", "Use diagrams/charts (Visual)", "Practice problems (Kinesthetic)"],
-    ["Look at a map (Visual)", "Have someone tell you (Auditory)", "Write down directions (Reading/Writing)", "Try walking/driving there (Kinesthetic)"],
-    ["Read instructions (Reading/Writing)", "Have someone show you (Visual)", "Listen to explanations (Auditory)", "Try it yourself (Kinesthetic)"],
-    ["Need quiet (Reading/Writing)", "Need background noise (Auditory)", "Need to move around (Kinesthetic)", "Need visual stimulation (Visual)"],
-    ["Their face (Visual)", "Their name (Auditory)", "What you talked about (Reading/Writing)", "What you did together (Kinesthetic)"],
-    ["Read the instructions carefully (Reading/Writing)", "Look at the diagrams (Visual)", "Ask someone to explain (Auditory)", "Start putting pieces together (Kinesthetic)"],
-    ["Online photos of the food (Visual)", "Recommendations from friends (Auditory)", "Reading the menu online (Reading/Writing)", "Remembering how it felt to eat there (Kinesthetic)"],
-    ["Read magazines (Reading/Writing)", "Listen to music (Auditory)", "Watch TV (Visual)", "Fidget or move around (Kinesthetic)"],
-    ["Write them down (Reading/Writing)", "Explain verbally (Auditory)", "Demonstrate (Visual)", "Guide them physically (Kinesthetic)"],
-    ["See written words in your mind (Visual)", "Hear the information in your head (Auditory)", "Write it down to remember (Reading/Writing)", "Associate it with physical actions (Kinesthetic)"],
-    ["Read all the descriptions (Reading/Writing)", "Listen to audio guides (Auditory)", "Look at the displays (Visual)", "Touch interactive exhibits (Kinesthetic)"],
-    ["Study grammar rules (Reading/Writing)", "Listen to native speakers (Auditory)", "Use flashcards with images (Visual)", "Practice conversations (Kinesthetic)"],
-    ["Write detailed paragraphs (Reading/Writing)", "Record the lecture (Auditory)", "Draw diagrams and charts (Visual)", "Doodle while listening (Kinesthetic)"],
-    ["Write detailed steps (Reading/Writing)", "Explain verbally with examples (Auditory)", "Draw diagrams (Visual)", "Use physical objects to demonstrate (Kinesthetic)"],
-    ["Conversations with people (Auditory)", "Watching others or the environment (Visual)", "Writing notes or texting (Reading/Writing)", "Dancing or physical activities (Kinesthetic)"],
-    ["See the numbers in your head (Visual)", "Say them aloud (Auditory)", "Write them down (Reading/Writing)", "Dial them on a keypad (Kinesthetic)"],
-    ["Read a book (Reading/Writing)", "Listen to music (Auditory)", "Watch TV/movies (Visual)", "Do something physical (Kinesthetic)"],
-    ["Read the manual (Reading/Writing)", "Ask someone to show you (Visual)", "Call tech support (Auditory)", "Experiment with the software (Kinesthetic)"],
-    ["Detailed notes (Reading/Writing)", "Verbal explanations (Auditory)", "Visual slides (Visual)", "Physical demonstrations (Kinesthetic)"],
-    ["Write out possible solutions (Reading/Writing)", "Talk through it with someone (Auditory)", "Draw diagrams (Visual)", "Build a model or prototype (Kinesthetic)"]
-]
-
-def learning_style_quiz(*answers):
-    scores = {
-        "Visual": 0,
-        "Auditory": 0,
-        "Reading/Writing": 0,
-        "Kinesthetic": 0
-    }
-    
-    for i, answer in enumerate(answers):
-        if answer == learning_style_options[i][0]:
-            scores["Reading/Writing"] += 1
-        elif answer == learning_style_options[i][1]:
-            scores["Auditory"] += 1
-        elif answer == learning_style_options[i][2]:
-            scores["Visual"] += 1
-        elif answer == learning_style_options[i][3]:
-            scores["Kinesthetic"] += 1
-    
-    max_score = max(scores.values())
-    total_questions = len(learning_style_questions)
-    
-    # Calculate percentages
-    percentages = {style: (score/total_questions)*100 for style, score in scores.items()}
-    
-    # Sort styles by score (descending)
-    sorted_styles = sorted(scores.items(), key=lambda x: x[1], reverse=True)
-    
-    # Prepare detailed results
-    result = "Your Learning Style Results:\n\n"
-    for style, score in sorted_styles:
-        result += f"{style}: {score}/{total_questions} ({percentages[style]:.1f}%)\n"
-    
-    result += "\n"
-    
-    # Determine primary and secondary styles
-    primary_styles = [style for style, score in scores.items() if score == max_score]
-    
-    if len(primary_styles) == 1:
-        result += f"Your primary learning style is: {primary_styles[0]}\n\n"
-        # Add personalized tips based on primary style
-        if primary_styles[0] == "Visual":
-            result += "Tips for Visual Learners:\n"
-            result += "- Use color coding in your notes\n"
-            result += "- Create mind maps and diagrams\n"
-            result += "- Watch educational videos\n"
-            result += "- Use flashcards with images\n"
-        elif primary_styles[0] == "Auditory":
-            result += "Tips for Auditory Learners:\n"
-            result += "- Record lectures and listen to them\n"
-            result += "- Participate in study groups\n"
-            result += "- Explain concepts out loud to yourself\n"
-            result += "- Use rhymes or songs to remember information\n"
-        elif primary_styles[0] == "Reading/Writing":
-            result += "Tips for Reading/Writing Learners:\n"
-            result += "- Write detailed notes\n"
-            result += "- Create summaries in your own words\n"
-            result += "- Read textbooks and articles\n"
-            result += "- Make lists to organize information\n"
-        else:  # Kinesthetic
-            result += "Tips for Kinesthetic Learners:\n"
-            result += "- Use hands-on activities\n"
-            result += "- Take frequent movement breaks\n"
-            result += "- Create physical models\n"
-            result += "- Associate information with physical actions\n"
-    else:
-        result += f"You have multiple strong learning styles: {', '.join(primary_styles)}\n\n"
-        result += "You may benefit from combining different learning approaches.\n"
-    
-    return result
-
-# ========== SAVE STUDENT PROFILE ==========
-def save_profile(name, age, interests, transcript, learning_style, 
-                movie, movie_reason, show, show_reason, 
-                book, book_reason, character, character_reason, blog):
-    # Convert age to int if it's a numpy number (from gradio Number input)
-    age = int(age) if age else 0
-    
-    favorites = {
-        "movie": movie,
-        "movie_reason": movie_reason,
-        "show": show,
-        "show_reason": show_reason,
-        "book": book,
-        "book_reason": book_reason,
-        "character": character,
-        "character_reason": character_reason
-    }
-    
-    data = {
-        "name": name,
-        "age": age,
-        "interests": interests,
-        "transcript": transcript,
-        "learning_style": learning_style,
-        "favorites": favorites,
-        "blog": blog
-    }
-    
-    os.makedirs("student_profiles", exist_ok=True)
-    json_path = os.path.join("student_profiles", f"{name.replace(' ', '_')}_profile.json")
-    with open(json_path, "w") as f:
-        json.dump(data, f, indent=2)
-
-    markdown_summary = f"""### Student Profile: {name}
-**Age:** {age}  
-**Interests:** {interests}  
-**Learning Style:** {learning_style}  
-#### Transcript:
-{transcript_display(transcript)}
-#### Favorites:
-- Movie: {favorites['movie']} ({favorites['movie_reason']})
-- Show: {favorites['show']} ({favorites['show_reason']})
-- Book: {favorites['book']} ({favorites['book_reason']})
-- Character: {favorites['character']} ({favorites['character_reason']})
-#### Blog:
-{blog if blog else "_No blog provided_"}
-"""
-    return markdown_summary
-
-# ========== AI TEACHING ASSISTANT ==========
-def load_profile():
-    if not os.path.exists("student_profiles"):
-        return {}
-    files = [f for f in os.listdir("student_profiles") if f.endswith('.json')]
-    if files:
-        with open(os.path.join("student_profiles", files[0]), "r") as f:
-            return json.load(f)
-    return {}
-
-def generate_response(message, history):
-    profile = load_profile()
-    if not profile:
-        return "Please complete and save your profile first using the previous tabs."
-    
-    # Get profile data
-    learning_style = profile.get("learning_style", "")
-    grade_level = profile.get("transcript", {}).get("grade_level", "unknown")
-    gpa = profile.get("transcript", {}).get("gpa", {})
-    interests = profile.get("interests", "")
-    courses = profile.get("transcript", {}).get("courses", {})
-    
-    # Common responses
-    greetings = ["hi", "hello", "hey"]
-    study_help = ["study", "learn", "prepare", "exam"]
-    grade_help = ["grade", "gpa", "score"]
-    interest_help = ["interest", "hobby", "passion"]
-    course_help = ["courses", "classes", "transcript", "schedule"]
-    
-    if any(greet in message.lower() for greet in greetings):
-        return f"Hello {profile.get('name', 'there')}! How can I help you today?"
-    
-    elif any(word in message.lower() for word in study_help):
-        if "Visual" in learning_style:
-            response = ("Based on your visual learning style, I recommend:\n"
-                       "- Creating mind maps or diagrams\n"
-                       "- Using color-coded notes\n"
-                       "- Watching educational videos")
-        elif "Auditory" in learning_style:
-            response = ("Based on your auditory learning style, I recommend:\n"
-                       "- Recording lectures and listening to them\n"
-                       "- Participating in study groups\n"
-                       "- Explaining concepts out loud")
-        elif "Reading/Writing" in learning_style:
-            response = ("Based on your reading/writing learning style, I recommend:\n"
-                       "- Writing detailed notes\n"
-                       "- Creating summaries in your own words\n"
-                       "- Reading textbooks and articles")
-        elif "Kinesthetic" in learning_style:
-            response = ("Based on your kinesthetic learning style, I recommend:\n"
-                       "- Hands-on practice\n"
-                       "- Creating physical models\n"
-                       "- Taking frequent movement breaks")
-        else:
-            response = ("Here are some general study tips:\n"
-                       "- Break study sessions into 25-minute chunks\n"
-                       "- Review material regularly\n"
-                       "- Teach concepts to someone else")
-        
-        return response
-    
-    elif any(word in message.lower() for word in grade_help):
-        return (f"Your GPA information:\n"
-               f"- Unweighted: {gpa.get('unweighted', 'N/A')}\n"
-               f"- Weighted: {gpa.get('weighted', 'N/A')}\n\n"
-               "To improve your grades, try:\n"
-               "- Setting specific goals\n"
-               "- Meeting with teachers\n"
-               "- Developing a study schedule")
-    
-    elif any(word in message.lower() for word in interest_help):
-        return (f"I see you're interested in: {interests}\n\n"
-               "You might want to:\n"
-               "- Find clubs or activities related to these interests\n"
-               "- Explore career paths that align with them")
-    
-    elif any(word in message.lower() for word in course_help):
-        response = "Here's a summary of your courses:\n"
-        if isinstance(courses, dict):
-            # Use the same grade sorting logic as in transcript display
-            def grade_sort_key(grade):
-                try:
-                    num = int(re.search(r'\d+', grade).group())
-                    return num
-                except (AttributeError, ValueError):
-                    return float('inf')
-            
-            grades_sorted = sorted(courses.keys(), key=grade_sort_key)
-            
-            for grade in grades_sorted:
-                response += f"\nGrade {grade}:\n"
-                for course in courses[grade]:
-                    response += f"- {course.get('name', 'Unnamed Course')}"
-                    if 'grade' in course:
-                        response += f" (Grade: {course['grade']})"
-                    response += "\n"
-        else:
-            response += "No detailed course information available."
-        return response
-    
-    elif "help" in message.lower():
-        return ("I can help with:\n"
-               "- Study tips based on your learning style\n"
-               "- GPA and grade information\n"
-               "- Course history and schedules\n"
-               "- General academic advice\n\n"
-               "Try asking about study strategies or your grades!")
-    
-    else:
-        return ("I'm your personalized teaching assistant. "
-               "I can help with study tips, grade information, and academic advice. "
-               "Try asking about how to study for your classes!")
-
-# ========== GRADIO INTERFACE ==========
-with gr.Blocks() as app:
-    with gr.Tab("Step 1: Upload Transcript"):
-        gr.Markdown("### Upload your transcript (PDF recommended for best results)")
-        transcript_file = gr.File(label="Transcript file", file_types=[".pdf"])
-        transcript_output = gr.Textbox(label="Transcript Results", lines=20)
-        transcript_data = gr.State()
-        transcript_file.change(
-            fn=parse_transcript,
-            inputs=transcript_file,
-            outputs=[transcript_output, transcript_data]
-        )
-
-    with gr.Tab("Step 2: Learning Style Quiz"):
-        gr.Markdown("### Learning Style Quiz (20 Questions)")
-        quiz_components = []
-        for i, (question, options) in enumerate(zip(learning_style_questions, learning_style_options)):
-            quiz_components.append(gr.Radio(options, label=f"{i+1}. {question}"))
-        
-        learning_output = gr.Textbox(label="Your Learning Style", lines=15)
-        gr.Button("Submit Quiz").click(
-            fn=learning_style_quiz,
-            inputs=quiz_components,
-            outputs=learning_output
-        )
-
-    with gr.Tab("Step 3: Personal Questions"):
-        name = gr.Textbox(label="What's your name?")
-        age = gr.Number(label="How old are you?", precision=0)
-        interests = gr.Textbox(label="What are your interests?")
-        movie = gr.Textbox(label="Favorite movie?")
-        movie_reason = gr.Textbox(label="Why do you like that movie?")
-        show = gr.Textbox(label="Favorite TV show?")
-        show_reason = gr.Textbox(label="Why do you like that show?")
-        book = gr.Textbox(label="Favorite book?")
-        book_reason = gr.Textbox(label="Why do you like that book?")
-        character = gr.Textbox(label="Favorite character?")
-        character_reason = gr.Textbox(label="Why do you like that character?")
-        blog_checkbox = gr.Checkbox(label="Do you want to write a blog?", value=False)
-        blog_text = gr.Textbox(label="Write your blog here", visible=False, lines=5)
-        blog_checkbox.change(lambda x: gr.update(visible=x), inputs=blog_checkbox, outputs=blog_text)
-
-    with gr.Tab("Step 4: Save & Review"):
-        output_summary = gr.Markdown()
-        save_btn = gr.Button("Save Profile")
-        save_btn.click(
-            fn=save_profile,
-            inputs=[name, age, interests, transcript_data, learning_output,
-                   movie, movie_reason, show, show_reason,
-                   book, book_reason, character, character_reason, blog_text],
-            outputs=output_summary
-        )
-
-    with gr.Tab("🤖 AI Teaching Assistant"):
-        gr.Markdown("## Your Personalized Learning Assistant")
-        chatbot = gr.ChatInterface(
-            fn=generate_response,
-            examples=[
-                "How should I study for my next test?",
-                "What's my GPA information?",
-                "Show me my course history",
-                "How can I improve my grades?"
-            ]
-        )
+[... REST OF YOUR ORIGINAL CODE REMAINS EXACTLY THE SAME ...]
 
 if __name__ == "__main__":
-    app.launch()
-    
+    # Check if running in a notebook environment
+    try:
+        from IPython import get_ipython
+        if 'IPKernelApp' not in get_ipython().config:
+            app.launch()
+    except:
+        app.launch()
+