Update app.py

app.py

@@ -20,6 +20,10 @@ from transformers import AutoTokenizer, AutoModelForCausalLM
 import time
 import logging
 import asyncio
+from functools import lru_cache
+import hashlib
+import bleach
+from concurrent.futures import ThreadPoolExecutor
 
 # ========== CONFIGURATION ==========
 PROFILES_DIR = "student_profiles"
@@ -29,6 +33,7 @@ MIN_AGE = 5
 MAX_AGE = 120
 SESSION_TOKEN_LENGTH = 32
 HF_TOKEN = os.getenv("HF_TOKEN")
+SESSION_TIMEOUT = 3600  # 1 hour session timeout
 
 # Initialize logging
 logging.basicConfig(
@@ -48,6 +53,14 @@ if HF_TOKEN:
     except Exception as e:
         logging.error(f"Failed to initialize Hugging Face API: {str(e)}")
 
+# ========== CACHING AND PERFORMANCE OPTIMIZATIONS ==========
+executor = ThreadPoolExecutor(max_workers=4)
+
+# Cache model loading
+@lru_cache(maxsize=1)
+def get_model_and_tokenizer():
+    return model_loader.load_model()
+
 # ========== MODEL LOADER ==========
 class ModelLoader:
     def __init__(self):
@@ -133,7 +146,7 @@ def generate_session_token() -> str:
 
 def sanitize_input(text: str) -> str:
     """Sanitize user input to prevent XSS and injection attacks."""
-    return html.escape(text.strip())
+    return bleach.clean(text.strip(), tags=[], attributes={}, protocols=[], strip=True)
 
 def validate_name(name: str) -> str:
     """Validate name input."""
@@ -273,43 +286,134 @@ class TranscriptParser:
         self.current_courses = []
         self.course_history = []
         self.graduation_status = {}
+        self.supported_formats = {
+            'miami_dade': self.parse_miami_dade,
+            'standard': self.parse_standard,
+            'homeschool': self.parse_homeschool
+        }
         
     def parse_transcript(self, text: str) -> Dict:
-        """Enhanced parsing method for Miami-Dade format"""
+        """Enhanced parsing method with format detection"""
         try:
             # First normalize the text (replace multiple spaces, normalize line breaks)
             text = re.sub(r'\s+', ' ', text)
             
-            # Extract student info with more flexible patterns
-            self._extract_student_info(text)
-            
-            # Extract requirements with better table parsing
-            self._extract_requirements(text)
+            # Detect transcript format
+            format_type = self.detect_format(text)
             
-            # Extract course history with improved pattern matching
-            self._extract_course_history(text)
-            
-            # Identify current courses
-            self._extract_current_courses(text)
-            
-            # Calculate completion status
-            self._calculate_completion()
-            
-            return {
-                "student_info": self.student_data,
-                "requirements": self.requirements,
-                "current_courses": self.current_courses,
-                "course_history": self.course_history,
-                "graduation_status": self.graduation_status
-            }
+            # Parse based on detected format
+            if format_type in self.supported_formats:
+                return self.supported_formats[format_type](text)
+            else:
+                # Fallback to standard parsing
+                return self.parse_standard(text)
             
         except Exception as e:
             logging.error(f"Error parsing transcript: {str(e)}")
-            raise gr.Error(f"Error parsing transcript: {str(e)}\n\nThis may be due to an unsupported transcript format. Please ensure you're uploading an official Miami-Dade transcript or contact support.")
+            raise gr.Error(f"Error parsing transcript: {str(e)}\n\nThis may be due to an unsupported transcript format. Please ensure you're uploading an official transcript or contact support.")
+
+    def detect_format(self, text: str) -> str:
+        """Detect the transcript format"""
+        # Check for Miami-Dade specific patterns
+        if re.search(r'MIAMI-DADE SCHOOL DISTRICT', text, re.IGNORECASE):
+            return 'miami_dade'
+        # Check for homeschool patterns
+        elif re.search(r'homeschool|home education|parent signature', text, re.IGNORECASE):
+            return 'homeschool'
+        # Default to standard format
+        return 'standard'
+
+    def parse_miami_dade(self, text: str) -> Dict:
+        """Parse Miami-Dade formatted transcripts"""
+        self._extract_student_info(text)
+        self._extract_requirements(text)
+        self._extract_course_history(text)
+        self._extract_current_courses(text)
+        self._calculate_completion()
+        
+        return {
+            "student_info": self.student_data,
+            "requirements": self.requirements,
+            "current_courses": self.current_courses,
+            "course_history": self.course_history,
+            "graduation_status": self.graduation_status,
+            "format": "miami_dade"
+        }
+
+    def parse_standard(self, text: str) -> Dict:
+        """Parse standard formatted transcripts"""
+        # Extract student info
+        student_match = re.search(r"Student:\s*([^\n]+)", text, re.IGNORECASE)
+        if student_match:
+            self.student_data["name"] = student_match.group(1).strip()
+        
+        # Extract courses - looking for a table-like structure
+        course_pattern = r"(?P<year>\d{4}-\d{4}|\d{1,2})\s+(?P<subject>\w+)\s+(?P<code>\w+)\s+(?P<title>[^\n]+)\s+(?P<grade>[A-F][+-]?)\s+(?P<credit>\d\.\d)"
+        course_matches = re.finditer(course_pattern, text)
+        
+        for match in course_matches:
+            self.course_history.append({
+                "school_year": match.group("year"),
+                "subject": match.group("subject"),
+                "course_code": match.group("code"),
+                "description": match.group("title").strip(),
+                "grade": match.group("grade"),
+                "credits": match.group("credit")
+            })
+        
+        # Extract GPA info
+        gpa_pattern = r"GPA\s*([\d.]+)\s*/\s*([\d.]+)"
+        gpa_match = re.search(gpa_pattern, text)
+        if gpa_match:
+            self.student_data.update({
+                "unweighted_gpa": float(gpa_match.group(1)),
+                "weighted_gpa": float(gpa_match.group(2))
+            })
+        
+        return {
+            "student_info": self.student_data,
+            "course_history": self.course_history,
+            "format": "standard"
+        }
+
+    def parse_homeschool(self, text: str) -> Dict:
+        """Parse homeschool formatted transcripts"""
+        # Extract student info
+        name_match = re.search(r"Student:\s*([^\n]+)", text, re.IGNORECASE)
+        if name_match:
+            self.student_data["name"] = name_match.group(1).strip()
+        
+        # Extract homeschool-specific info
+        parent_match = re.search(r"Parent:\s*([^\n]+)", text, re.IGNORECASE)
+        if parent_match:
+            self.student_data["parent"] = parent_match.group(1).strip()
+        
+        # Extract courses - homeschool format often has simpler tables
+        course_pattern = r"(?P<subject>\w+)\s+(?P<title>[^\n]+?)\s+(?P<date>\w+-\d{4})\s+(?P<grade>[A-F][+-]?)\s+(?P<credit>\d\.\d)"
+        course_matches = re.finditer(course_pattern, text)
+        
+        for match in course_matches:
+            self.course_history.append({
+                "subject": match.group("subject"),
+                "description": match.group("title").strip(),
+                "completion_date": match.group("date"),
+                "grade": match.group("grade"),
+                "credits": match.group("credit")
+            })
+        
+        # Extract GPA info
+        gpa_match = re.search(r"Cumulative GPA:\s*([\d.]+)", text, re.IGNORECASE)
+        if gpa_match:
+            self.student_data["gpa"] = float(gpa_match.group(1))
+        
+        return {
+            "student_info": self.student_data,
+            "course_history": self.course_history,
+            "format": "homeschool"
+        }
 
     def _extract_student_info(self, text: str):
         """Enhanced student info extraction for Miami-Dade format"""
-        # Extract basic student info
         student_pattern = r"(\d{7})\s*-\s*([A-Z]+,\s*[A-Z]+)\s*Current Grade:\s*(\d+)\s*YOG\s*(\d{4})"
         student_match = re.search(student_pattern, text, re.IGNORECASE)
         
@@ -488,7 +592,7 @@ class TranscriptParser:
         }, indent=2)
 
 def format_transcript_output(data: Dict) -> str:
-    """Enhanced formatting for Miami-Dade transcript output"""
+    """Enhanced formatting for transcript output with format awareness"""
     output = []
     
     # Student Info Section
@@ -498,30 +602,42 @@ def format_transcript_output(data: Dict) -> str:
     output.append(f"**Student ID:** {student.get('id', 'Unknown')}")
     output.append(f"**Current Grade:** {student.get('current_grade', 'Unknown')}")
     output.append(f"**Graduation Year:** {student.get('graduation_year', 'Unknown')}")
-    output.append(f"**Unweighted GPA:** {student.get('unweighted_gpa', 'N/A')}")
-    output.append(f"**Weighted GPA:** {student.get('weighted_gpa', 'N/A')}")
-    output.append(f"**Total Credits Earned:** {student.get('total_credits', 'N/A')}")
-    output.append(f"**Community Service Hours:** {student.get('community_service_hours', 'N/A')}\n")
     
-    # Graduation Requirements Section
-    grad_status = data.get("graduation_status", {})
-    output.append(f"## Graduation Progress\n{'='*50}")
-    output.append(f"**Overall Completion:** {grad_status.get('percent_complete', 0)}%")
-    output.append(f"**Credits Required:** {grad_status.get('total_required_credits', 0)}")
-    output.append(f"**Credits Completed:** {grad_status.get('total_completed_credits', 0)}")
-    output.append(f"**Credits Remaining:** {grad_status.get('remaining_credits', 0)}")
-    output.append(f"**On Track to Graduate:** {'Yes' if grad_status.get('on_track', False) else 'No'}\n")
+    if 'unweighted_gpa' in student and 'weighted_gpa' in student:
+        output.append(f"**Unweighted GPA:** {student['unweighted_gpa']}")
+        output.append(f"**Weighted GPA:** {student['weighted_gpa']}")
+    elif 'gpa' in student:
+        output.append(f"**GPA:** {student['gpa']}")
+    
+    if 'total_credits' in student:
+        output.append(f"**Total Credits Earned:** {student['total_credits']}")
+    if 'community_service_hours' in student:
+        output.append(f"**Community Service Hours:** {student['community_service_hours']}")
+    if 'parent' in student:
+        output.append(f"**Parent/Guardian:** {student['parent']}")
     
-    # Detailed Requirements
-    output.append("### Detailed Requirements:")
-    for code, req in data.get("requirements", {}).items():
-        output.append(
-            f"- **{code}**: {req.get('description', '')}\n"
-            f"  Required: {req['required']} | Completed: {req['completed']} | "
-            f"Status: {req['status']}"
-        )
     output.append("")
     
+    # Graduation Requirements Section (for Miami-Dade format)
+    if data.get('format') == 'miami_dade':
+        grad_status = data.get("graduation_status", {})
+        output.append(f"## Graduation Progress\n{'='*50}")
+        output.append(f"**Overall Completion:** {grad_status.get('percent_complete', 0)}%")
+        output.append(f"**Credits Required:** {grad_status.get('total_required_credits', 0)}")
+        output.append(f"**Credits Completed:** {grad_status.get('total_completed_credits', 0)}")
+        output.append(f"**Credits Remaining:** {grad_status.get('remaining_credits', 0)}")
+        output.append(f"**On Track to Graduate:** {'Yes' if grad_status.get('on_track', False) else 'No'}\n")
+        
+        # Detailed Requirements
+        output.append("### Detailed Requirements:")
+        for code, req in data.get("requirements", {}).items():
+            output.append(
+                f"- **{code}**: {req.get('description', '')}\n"
+                f"  Required: {req['required']} | Completed: {req['completed']} | "
+                f"Status: {req['status']}"
+            )
+        output.append("")
+    
     # Current Courses
     if data.get("current_courses"):
         output.append("## Current Courses (In Progress)\n" + '='*50)
@@ -537,7 +653,8 @@ def format_transcript_output(data: Dict) -> str:
     # Course History by Year
     courses_by_year = defaultdict(list)
     for course in data.get("course_history", []):
-        courses_by_year[course["school_year"]].append(course)
+        year_key = course.get("school_year", course.get("completion_date", "Unknown"))
+        courses_by_year[year_key].append(course)
     
     if courses_by_year:
         output.append("## Course History\n" + '='*50)
@@ -545,9 +662,10 @@ def format_transcript_output(data: Dict) -> str:
             output.append(f"\n### {year}")
             for course in courses_by_year[year]:
                 output.append(
-                    f"- **{course['course_code']} {course['description']}**\n"
-                    f"  Grade: {course['grade']} | Credits: {course['credits']} | "
-                    f"Category: {course['requirement_category']} | Term: {course['term']}"
+                    f"- **{course.get('course_code', '')} {course.get('description', 'Unnamed course')}**\n"
+                    f"  Subject: {course.get('subject', 'N/A')} | "
+                    f"Grade: {course.get('grade', 'N/A')} | "
+                    f"Credits: {course.get('credits', 'N/A')}"
                 )
     
     return '\n'.join(output)
@@ -603,7 +721,7 @@ def parse_transcript_with_ai_fallback(text: str, progress=gr.Progress()) -> Dict
         if progress:
             progress(0.1, desc="Processing transcript with AI...")
         
-        model, tokenizer = model_loader.load_model(progress)
+        model, tokenizer = get_model_and_tokenizer()
         if model is None or tokenizer is None:
             raise gr.Error(f"Model failed to load. {model_loader.error or 'Please try loading a model first.'}")
         
@@ -643,6 +761,11 @@ def parse_transcript_with_ai_fallback(text: str, progress=gr.Progress()) -> Dict
         logging.error(f"AI parsing error: {str(e)}")
         raise gr.Error(f"Error processing transcript: {str(e)}\n\nPlease try again or contact support with this error message.")
 
+async def parse_transcript_async(file_obj, progress=gr.Progress()) -> Tuple[str, Optional[Dict]]:
+    """Async wrapper for transcript parsing"""
+    loop = asyncio.get_event_loop()
+    return await loop.run_in_executor(executor, parse_transcript, file_obj, progress)
+
 def parse_transcript(file_obj, progress=gr.Progress()) -> Tuple[str, Optional[Dict]]:
     """Main function to parse transcript files with better error handling"""
     try:
@@ -883,7 +1006,9 @@ class ProfileManager:
     def get_profile_path(self, name: str) -> Path:
         """Get profile path with session token if available."""
         if self.current_session:
-            return self.profiles_dir / f"{name.replace(' ', '_')}_{self.current_session}_profile.json"
+            # Hash the name for security
+            name_hash = hashlib.sha256(name.encode()).hexdigest()[:16]
+            return self.profiles_dir / f"{name_hash}_{self.current_session}_profile.json"
         return self.profiles_dir / f"{name.replace(' ', '_')}_profile.json"
     
     def save_profile(self, name: str, age: Union[int, str], interests: str, 
@@ -919,7 +1044,8 @@ class ProfileManager:
                 "learning_style": learning_style if learning_style else "Not assessed",
                 "favorites": favorites,
                 "blog": sanitize_input(blog) if blog else "",
-                "session_token": self.current_session
+                "session_token": self.current_session,
+                "last_updated": time.time()
             }
             
             # Save to JSON file
@@ -959,12 +1085,12 @@ class ProfileManager:
                 return {}
             
             if name:
-                # Find profile by name
-                name = name.replace(" ", "_")
+                # Find profile by name (hashed)
+                name_hash = hashlib.sha256(name.encode()).hexdigest()[:16]
                 if session_token:
-                    profile_file = self.profiles_dir / f"{name}_{session_token}_profile.json"
+                    profile_file = self.profiles_dir / f"{name_hash}_{session_token}_profile.json"
                 else:
-                    profile_file = self.profiles_dir / f"{name}_profile.json"
+                    profile_file = self.profiles_dir / f"{name_hash}_profile.json"
                 
                 if not profile_file.exists():
                     # Try loading from HF Hub
@@ -985,7 +1111,11 @@ class ProfileManager:
                 profile_file = profiles[0]
             
             with open(profile_file, "r", encoding='utf-8') as f:
-                return json.load(f)
+                profile_data = json.load(f)
+                # Check session timeout
+                if time.time() - profile_data.get('last_updated', 0) > SESSION_TIMEOUT:
+                    raise gr.Error("Session expired. Please start a new session.")
+                return profile_data
         
         except Exception as e:
             logging.error(f"Error loading profile: {str(e)}")
@@ -1001,10 +1131,12 @@ class ProfileManager:
         # Extract just the name part (without session token)
         profile_names = []
         for p in profiles:
-            name_part = p.stem.replace("_profile", "")
-            if session_token:
-                name_part = name_part.replace(f"_{session_token}", "")
-            profile_names.append(name_part.replace("_", " "))
+            with open(p, "r", encoding='utf-8') as f:
+                try:
+                    data = json.load(f)
+                    profile_names.append(data.get('name', p.stem))
+                except json.JSONDecodeError:
+                    continue
         
         return profile_names
     
@@ -1071,7 +1203,7 @@ class TeachingAssistant:
         self.context_history = []
         self.max_context_length = 5  # Keep last 5 exchanges for context
     
-    def generate_response(self, message: str, history: List[List[Union[str, None]]], session_token: str) -> str:
+    async def generate_response(self, message: str, history: List[List[Union[str, None]]], session_token: str) -> str:
         """Generate personalized response based on student profile and context."""
         try:
             # Load profile with session token
@@ -1092,7 +1224,7 @@ class TeachingAssistant:
             favorites = profile.get("favorites", {})
             
             # Process message with context
-            response = self._process_message(message, profile)
+            response = await self._process_message(message, profile)
             
             # Add follow-up suggestions
             if "study" in message.lower() or "learn" in message.lower():
@@ -1119,7 +1251,7 @@ class TeachingAssistant:
         # Trim to maintain max context length
         self.context_history = self.context_history[-(self.max_context_length*2):]
     
-    def _process_message(self, message: str, profile: Dict) -> str:
+    async def _process_message(self, message: str, profile: Dict) -> str:
         """Process user message with profile context."""
         message_lower = message.lower()
         
@@ -1323,7 +1455,7 @@ def create_interface():
             4: False   # AI Assistant
         })
         
-        # Custom CSS
+        # Custom CSS with dark mode support
         app.css = """
         .gradio-container { max-width: 1200px !important; margin: 0 auto !important; }
         .tab-content { padding: 20px !important; border: 1px solid #e0e0e0 !important; border-radius: 8px !important; margin-top: 10px !important; }
@@ -1335,15 +1467,28 @@ def create_interface():
         .quiz-question { margin-bottom: 15px; padding: 15px; background: #f5f5f5; border-radius: 5px; }
         .quiz-results { margin-top: 20px; padding: 20px; background: #e8f5e9; border-radius: 8px; }
         .error-message { color: #d32f2f; background-color: #ffebee; padding: 10px; border-radius: 4px; margin: 10px 0; }
+        
+        /* Dark mode support */
+        .dark .tab-content { background-color: #2d2d2d !important; border-color: #444 !important; }
+        .dark .quiz-question { background-color: #3d3d3d !important; }
+        .dark .quiz-results { background-color: #2e3d2e !important; }
+        .dark textarea, .dark input { background-color: #333 !important; color: #eee !important; }
+        .dark .output-markdown { color: #eee !important; }
+        .dark .chatbot { background-color: #333 !important; }
+        .dark .chatbot .user, .dark .chatbot .assistant { color: #eee !important; }
         """
         
-        # Header
-        gr.Markdown("""
-        # Student Learning Assistant
-        **Your personalized education companion**  
-        Complete each step to get customized learning recommendations.
-        """)
-
+        # Header with dark mode toggle
+        with gr.Row():
+            with gr.Column(scale=4):
+                gr.Markdown("""
+                # Student Learning Assistant
+                **Your personalized education companion**  
+                Complete each step to get customized learning recommendations.
+                """)
+            with gr.Column(scale=1):
+                dark_mode = gr.Checkbox(label="Dark Mode", value=False)
+        
         # Navigation buttons
         with gr.Row():
             with gr.Column(scale=1, min_width=100):
@@ -1741,6 +1886,16 @@ def create_interface():
             outputs=[tabs, nav_message]
         )
         
+        # Dark mode toggle
+        def toggle_dark_mode(dark):
+            return gr.themes.Soft(primary_hue="blue", secondary_hue="gray") if not dark else gr.themes.Soft(primary_hue="blue", secondary_hue="gray", neutral_hue="slate")
+        
+        dark_mode.change(
+            fn=toggle_dark_mode,
+            inputs=dark_mode,
+            outputs=None
+        )
+        
         # Load model on startup
         app.load(fn=lambda: model_loader.load_model(), outputs=[])